separate (ErrorHandler.Conversions.ToString.SemanticErr)
procedure SemanticErrExpl (E_Str   : in out E_Strings.T)

is
begin
   case Err_Num.ErrorNum is
      when 1 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If the identifier is declared in a" &
              " separate (or parent) package, the package must be included in an inherit clause" &
              " and the identifier prefixed with the package name." &
              " Ensure that there are no errors in the declaration of the identifier");
      when 5 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Usually associated with the use of an identifier other than a package" &
              " name as a prefix in a selected component.");
      when 8 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when the selector in a selected component of a record" &
              " references a non-existent field.");
      when 9 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs if the prefix to a selected component representing a procedure" &
              " in a procedure call statement or a type mark is not a package. Also" &
              " occurs if a selector is applied in an expression to an object which" &
              " is not a record variable.");
      when 11 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a package body is encountered for which there is no" &
              " package specification.");
      when 12 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If the object in question is really a constant, then remove it from" &
              " the enclosing package's own variable annotation.");
      when 14 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if the name in a ""separate"" clause of a subunit does not" &
              " correctly identify a compilation unit.  Common causes of this error" &
              " are a syntax error in the parent unit or omitting the" &
              " parent unit specification and/or parent unit body entries from the index file");
      when 15 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Common causes of this error are an error in the declaration" &
              " of the stub or the omission of the parent unit body from the index file");
      when 20 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a renaming declaration contains a non-existent operator.");
      when 21 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made to index into a name which does not" &
              " represent an array.");
      when 22 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs when the type given in the Ada declaration of an own variable" &
              " differs from that" &
              " ""announced"" in the package's own variable clause.");
      when 24 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When a procedure is called any global variables exported by that" &
              " procedure must be visible at the point of call. This error message" &
              " indicates that the global variable concerned is not visible." &
              " It may be that it needs to be added to the global annotation of" &
              " the procedure containing the call (or some further enclosing subprogram)" &
              " or it may be that an inherit clause is missing from the package containing" &
              " the call.");
      when 25 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When a procedure is called any global variables imported by that" &
              " procedure must be visible at the point of call. This error message" &
              " indicates that the global variable concerned is not visible." &
              " It may be that it needs to be added to the global annotation of" &
              " the subprogram containing the call (or some further enclosing subprogram)" &
              " or it may be that an inherit clause is missing from the package containing" &
              " the call.");
      when 26 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued at the end of a package specification if no full declaration" &
              " has been supplied for a deferred constant declared in the package" &
              " specification.");
      when 27 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued at the end of a package specification if no full declaration" &
              " has been supplied for a private type declared in the package specification.");
      when 28 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued at the end of a package body if an own variable announced in the" &
              " package specification has neither been given an Ada declaration nor refined.");
      when 30 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The attribute is identified in Annex K of the SPARK 95 report as a" &
              " valid SPARK 95" &
              " attribute but the Examiner does not currently support it." &
              " It is" &
              " possible to work round the omission by putting the use of the attribute" &
              " inside a" &
              " suitable function which is hidden from the Examiner.");
      when 32 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Likely causes are type conversions involving record types or" &
              " non-convertible arrays.");
      when 33 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if the prefix of an aggregate is not a composite type.");
      when 34 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a call is made to a user-defined subprogram in a" &
              " package initialization part.");
      when 35 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Indicates use of an undeclared binary operator; this message means that" &
              " the type on each side" &
              " of the operator cannot appear with the operator used. e.g." &
              " attempting to add an integer to" &
              " an enumeration literal.");
      when 39 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An unconstrained array type or variable of such a type is" &
              " illegally used. Use of" &
              " unconstrained arrays in SPARK is limited to passing them as" &
              " parameters, indexing into them" &
              " and taking attributes of them.  This message also arises if a string" &
              " literal is used as an actual parameter where the formal parameter is a string subtype." &
              " In this case, the error can be removed by qualifying the string literal with the subtype" &
              " name.");
      when 40 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This operator is only defined for numeric types and, if the" &
              " Ravenscar Profile is" &
              " selected, for type Ada.Real_Time.Time_Span.");
      when 41 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a subtype declaration taking the form of a constrained" &
              " subtype of an" &
              " unconstrained array type is encountered but with a type mark which" &
              " does not represent an" &
              " array.");
      when 42 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a name represents an object which is not of the required type.");
      when 44 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The bounds of an explicit range must be scalar types.");
      when 47 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an array type definition is encountered where one or" &
              " more of the index types used in the definition contained errors in its original declaration.  For" &
              " example, SPARK requires array index bounds to be constant (known at compile time) so an attempt" &
              " to use an illegal subtype with variable bounds as an array index will generate this message.");
      when 49 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Only SPARK 95 attributes 'Min and 'Max require two arguments.");
      when 50 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To assign a non-constant expression to a variable, an assignment statement" &
              " in the body of the program unit (following the 'begin') must be used.");
      when 51 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an ordering operator such as ""&lt;"" is encountered between" &
              " objects of an array" &
              " type other than string or a constrained subtype of string.");
      when 52 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ordering operators are only defined for scalar types and type" &
              " String plus, if the" &
              " Ravenscar Profile is selected, types Time and Time_Span in package" &
              " Ada.Real_Time.");
      when 53 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK record aggregates may not contain an others clause.");
      when 54 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when an attribute not supported by SPARK is used.");
      when 58 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs at the end of a package, subprogram, protected type, task type" &
              " or loop if the terminal identifier does not" &
              " match the name or label originally given.");
      when 59 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A subtype of the form applicable to a subrange of a scalar type has" &
              " been encountered" &
              " but the type provided is not a scalar type.");
      when 60 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK record aggregates may not contain multiple choices, each" &
              " field must be" &
              " assigned a value individually.");
      when 62 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an embedded package declares subprograms or own variables" &
              " and no body is" &
              " provided.");
      when 65 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The names of the parameters used in renaming declarations may not" &
              " be altered from Left," &
              " Right for binary operators and Right for unary operators. These are" &
              " the names given for" &
              " the parameters in the ARM and the SPARK Definition requires that" &
              " parameter names are not" &
              " changed.");
      when 66 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Either the package does not have an initializes annotation or all" &
              " the own variables" &
              " requiring initialization were given values at the point of declaration.");
      when 67 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This is an Ada 83 rule.  Machine code can only be used in procedures.");
      when 68 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made to rename an operator using a subtype" &
              " of the type for" &
              " which it was originally implicitly declared.");
      when 71 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if the name supplied in a pragma interface, import or attach_handler" &
              " does not match the name of the associated subprogram or variable.");
      when 72 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Pragma import may only occur in a body stub, or immediately" &
              " after a subprogram declaration in the visible part of a package," &
              " or immediately after a variable declaration." &
              " Pragma interface may only occur in a body stub or immediately" &
              " after a subprogram declaration in the visible part of a package.");
      when 73 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an Ada declaration is given for an own variable which" &
              " has been refined, or in" &
              " a refinement clause if an own variable is refined more than once.");
      when 74 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A subject of a refinement definition of a package must be an own" &
              " variable of that" &
              " package.");
      when 75 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made to refine an own variable onto an own" &
              " variable of a" &
              " non-embedded package.");
      when 76 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a refinement clause in a package body attempts to name" &
              " an embedded package" &
              " own variable as a refinement constituent and the name given for the" &
              " embedded package is" &
              " already in use.");
      when 77 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs in the own variable clause of a package embedded in another" &
              " package if an own" &
              " variable which is a refinement constituent of an own variable of the" &
              " enclosing package is" &
              " omitted.");
      when 78 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an own variable occurs in the initialization clause of" &
              " an embedded package" &
              " and the own variable concerned is a refinement constituent of another" &
              " own variable which" &
              " is not listed in the initialization specification of its package.");
      when 79 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs in the initialization clause of a package embedded in another" &
              " package if an own" &
              " variable which is a refinement constituent of an initialized own variable" &
              " of the enclosing" &
              " package is omitted.");
      when 82 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An own variable initialization clause and that of its refinement" &
              " constituents must be" &
              " consistent.");
      when 83 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an own variable does not occur in the initialization" &
              " clause of an embedded" &
              " package and the own variable concerned is a refinement constituent" &
              " of another own variable" &
              " which is listed in the initialization clause of its package.");
      when 84 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued at the end of a package if a refinement constituent of a" &
              " refined own variable" &
              " has not been given an Ada declaration or further refined.");
      when 85 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A variable XXX which has occurred in a refined global annotation" &
              " is neither a variable" &
              " that occurred in the earlier global definition nor a refinement" &
              " constituent of any such" &
              " variable.");
      when 86 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If the global annotation of a procedure specification contains" &
              " an own variable and that" &
              " own variable is later refined then at least one refinement constituent" &
              " of the own variable" &
              " shall appear in the second global annotation supplied for the procedure" &
              " body.");
      when 87 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A global definition containing abstract own variables was given in" &
              " the definition for" &
              " subprogram XXX, in a package specification. A refined global definition" &
              " is required in the" &
              " package body.");
      when 94 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued anywhere a boolean expression is required (e.g. in if, " &
              " exit  and while statements) and the expression provided" &
              " is not of type boolean.");
      when 97 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "'BASE may only be used as a prefix to another attribute.");
      when 99 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs if a subtype is declared of an array which is already constrained.");
      when 113 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Private subprograms would not be callable in SPARK 83 and are therefore not" &
              " permitted; they may be declared and called in SPARK 95.");
      when 114 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A subtype mark or an explicit Range attribute may not be used in a context" &
              " where a simple expression is expected.");
      when 115 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Annotation should be of the form 'own S is A, B, C;'");
      when 117 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Aggregates are qualified expressions so they must be prefixed with a" &
              " subtype mark. An exception is made in the case of aggregate assignments to" &
              " unconstrained arrays as the rules of Ada do not permit unconstrained array" &
              " aggregates to be qualified");
      when 118 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Unqualified aggregates may only be used in assignments to one-dimensional unconstrained" &
              " arrays. SPARK does not permit aggregate assignment to multi-dimensional unconstrained" &
              " arrays");
      when 119 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Indicates use of an undeclared unary operator; this message means that" &
              " the type on the right hand side" &
              " of the operator cannot appear with the operator used. e.g." &
              " attempting to negate an enumeration literal.");
      when 121 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The identifier indicating what kind of message to justify must be either" &
              " 'Flow_Message' or 'Warning_Message' or some unique abbreviation of them such as" &
              " 'Fl' or even 'F'.  Case is ignored.");
      when 122 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This item should be an integer literal representing the error or warning message that" &
              " is being marked as expected.");
      when 123 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "It does not make sense to allow certain warnings to be justified with the accept annotation." &
              " In particular, attempting to justify warnings raised by the justification system itself" &
              " could lead to some special kind of recursive hell that we would not wish to enter.");
      when 124 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This class of error does not reference any variables, and therefore requires" &
              " no names.");
      when 125 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This class of error references one variable, and therefore requires" &
              " one name.");
      when 126 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This class of error references two variables, and therefore requires" &
              " two names. Two names are need to justify expected information" &
              " flow messages such as ""X is not derived from Y""." &
              " Note that for messages of this kind the accept annotation should list the names in the order" &
              " ""export, import""");
      when 127 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This class of error references either zero or one variable, and therefore" &
              " requires either zero or one name. An ineffective assignment error requires" &
              " the name of variable being assigned to. An ineffective statement error" &
              " has no name associated with it.");
      when 128 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This class of error references either one or two variables, and therefore" &
              " requires either one or two names. One name is required when the export" &
              " is a function return value.");
      when 132 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A package should not 'with' itself and a subunit" &
              " should not 'with' the package (or main program) which declares its stub");
      when 135 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Possible causes of this error are" &
              " an error in the inherited package specification or" &
              " omitting an entry for the package specification from the index file or" &
              " circular inheritance");
      when 136 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A refinement clause of a package body defines the constituent" &
              " parts of own variables given in the own variable clause of the" &
              " corresponding package declaration");
      when 137 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Possible causes of this error are" &
              " an error in the child package specification or" &
              " omitting the child from the parent's component list in the index file" &
              " or omitting the child specification entry from the index file");
      when 138 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A constituent of a refinement clause which is defined in a" &
              " child package must be an own variable of the child package");
      when 139 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A package can only initialize variables" &
              " declared in its own variable clause");
      when 140 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The parent of a child package must be a library package and" &
              " must be declared prior to a child package.  If using an index file" &
              " the parent must have an entry in the index file and the child package" &
              " must be listed as a component of the parent package");
      when 142 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The prefix should appear in the inherit clause of the current package");
      when 144 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The name must denote an entire variable or an own variable" &
              " of a package.  If the variable or own variable is declared in a" &
              " separate (or parent) package, the package must be included in an inherit clause" &
              " and the identifier prefixed with the package name");
      when 145 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The identifier should be a typemark.  If the typemark is declared in a" &
              " separate (or parent) package, the package must be included in an inherit clause" &
              " and the identifier prefixed with the package name." &
              " Ensure that there are no errors in the declaration of the typemark");
      when 148 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables may be ""type announced"" as being of an abstract proof" &
              " type only where" &
              " that type is declared later in the same package. Thus --# own State :" &
              " T; is legal if" &
              " --# type T is abstract; appears later in the package; however, --# own" &
              " State : P.T; is" &
              " illegal if T is an abstract proof type declared in remote package P.");
      when 149 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs when an own variable clause announces more than one own variable" &
              " as being of" &
              " a type XXX and XXX is later declared as being of an abstract proof type." &
              " Each abstract" &
              " own variable must be of a unique type.");
      when 150 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a the name of a constant is found in a mandatory annotation such as" &
              " a global or derives annotation.  Constants should not appear in such annotations.");
      when 151 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A variable declared in a package must have been previously announced" &
              " as either an own" &
              " variable or as a concrete refinement constituent of an own variable.");
      when 153 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if the name, type or parameter mode of a parameter is different" &
              " in the" &
              " subprogram body declaration from that declared originally.");
      when 154 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A subprogram or task body must have a global annotation if it references" &
              " global variables; a" &
              " procedure or task body must have a dependency relation to perform" &
              " information flow analysis.");
      when 155 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Do not repeat global or derives annotations in the body" &
              " (or body stub) of a subprogram, entry or task except for" &
              " state (own variable) refinement.");
      when 156 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when an identifier which SPARK requires to be an entire" &
              " variable represents" &
              " something other than this. Most commonly this message occurs when" &
              " a component of a" &
              " structured variable appears in a core annotation.");
      when 158 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued in a global annotation if it names a formal parameter of the" &
              " subprogram.");
      when 161 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a parameter appears as an export to a procedure when it is of" &
              " parameter mode" &
              " in.");
      when 162 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a parameter appears as an import to a procedure when it is of" &
              " parameter mode" &
              " out.");
      when 163 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK contains rules to prevent construction of programs containing" &
              " recursive" &
              " subprogram calls; this error message occurs if a procedure or function" &
              " is called before" &
              " its body has been declared. Re-ordering of subprogram bodies in the" &
              " package concerned will" &
              " be required.");
      when 165 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Violation of the anti-aliasing rule.");
      when 166 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Violation of the anti-aliasing rule.");
      when 167 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when an own variable which is imported into the main program" &
              " procedure (or a task when the Ravenscar profile is enabled) has not" &
              " been declared as being initialized by its package.  At the main program" &
              " level the only" &
              " imports that are permitted are initialized own variables of inherited" &
              " packages.  There are" &
              " two possible cases to consider: (1) the main program should be importing" &
              " the variable in" &
              " which case it should be annotated in its package with --# initializes" &
              " (and, of course, actually" &
              " initialized in some way) or be an external variable or protected variable" &
              " which is implicitly" &
              " initialized; or (2) the own variable concerned is not initialized at" &
              " elaboration," &
              " should not therefore be considered an import to the main program and" &
              " should be removed from the" &
              " main program's import list.");
      when 169 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "It is an important property of SPARK  that functions cannot have" &
              " side-effects, therefore" &
              " only the reading of global variable is permitted.  It is usually" &
              " convenient to omit" &
              " modes from function global annotations but use of mode 'in' is" &
              " permitted.");
      when 172 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an actual parameter which is an array element is associated" &
              " with an exported" &
              " formal parameter in a procedure call. Exported parameters must be either" &
              " entire variables" &
              " or a record field.");
      when 173 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Violation of the anti-aliasing rule.");
      when 174 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs in initialization specifications if something other than a" &
              " variable is listed as" &
              " being initialized.");
      when 175 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A justification of an error requires the actual variables named in" &
              " the error message to be referenced.  The keyword ""all"" can only" &
              " be used with language profiles for auto-code generators such as SCADE KCG." &
              " Such profiles are only available with the SPARK Pro Toolset.");
      when 176 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When analysing with flow=auto, a procedure or entry without a derives annotation" &
              " may not be called by a procedure, task or entry with a derives annotation. This is because" &
              " the body of the caller must be checked against its derives annotation." &
              " In order to calculate the correct dependency relation for the body of the caller" &
              " there must be derives annotations present on all called procedures or entries.");
      when 180 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when an identifier which SPARK requires to be an entire" &
              " composite constant represents something other than this.");
      when 182 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a rule policy has already been declared for this" &
              " constant within this declarative region. This rule policy will" &
              " be ineffective.");
      when 200 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Each formal parameter of a subprogram shall be imported or exported or both.");
      when 201 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Every variable in a global definition must also appear in the associated derives annotation" &
              " where it will be either imported or exported or both.");
      when 252 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The value of 'Size must be static and must be of" &
              " an integer type");
      when 253 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The value of 'Size must be a positive integer or zero");
      when 254 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Setting 'Size for a user-defined non-first subtype is not permitted." &
              " See Ada95 LRM 13.3(48)");
      when 255 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada95 LRM Annex N.31 defines a program unit to be either a package, a task unit," &
              " a protected unit, a protected entry, a generic unit, or an explicitly" &
              " declared subprogram other than an enumeration literal.");
      when 273 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Where a type mark is included in an own variable declaration it" &
              " indicates that the own" &
              " variable will either be of a concrete type of that name (which may" &
              " be either already" &
              " declared or be declared later in the package) or of an abstract proof" &
              " type declared in" &
              " the package specification.  In the former case the refinement is" &
              " illegal because own" &
              " variables of concrete Ada types may not be refined.  In the latter case" &
              " it is legal;" &
              " however, no suitable proof type declaration has been found in this case.");
      when 300 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A renaming declaration must be the first declarative item of a package" &
              " body or main" &
              " program or it must be placed immediately after the declaration of" &
              " an embedded package.");
      when 301 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A renaming declaration may be placed immediately after the declaration" &
              " of an embedded" &
              " package; in this case it may only rename subprograms declared in that" &
              " package.");
      when 302 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued in a subprogram renaming declaration if it contains parameter" &
              " names, numbers or" &
              " types which differ from those originally declared.");
      when 303 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a renaming declaration has a different operator on each" &
              " side of the reserved" &
              " word RENAMES.");
      when 305 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued in an operator renaming declaration if it contains types" &
              " which differ from those" &
              " applicable to the operator being renamed.");
      when 306 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs in an operator renaming declaration if an attempt is made" &
              " to rename an operator" &
              " which is already visible. (The message will also appear as a secondary" &
              " consequence of" &
              " trying to rename an operator between undeclared types.)");
      when 308 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made to assign a variable of a type which is" &
              " limited or which" &
              " contains a limited type.");
      when 309 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This message means that the operator exists between the types on each" &
              " side of it but" &
              " that it is not visible. The most likely cause is that the types" &
              " concerned are defined in" &
              " another package and that renaming is required to make the operator visible.");
      when 310 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The % operator is used to indicate the value of a variable on entry to a for loop.  This is because" &
              " the variable may be used in the exit expression of the loop and may also be modified in the body" &
              " of the loop.  Since the semantics of Ada require the exit expression to be fixed after evaluation" &
              " we require a way of reasoning about the original value of a variable prior to any alteration in" &
              " the loop body.  No other situation requires this value so % may not be used anywhere else.");
      when 311 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Where an own variable is announced as being of some type," &
              " SPARK requires that type" &
              " to be declared; the declaration cannot be in the form of an" &
              " unconstrained array because" &
              " SPARK prohibits unconstrained variables.");
      when 314 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made to use, in a second annotation, an own" &
              " variable which has" &
              " been refined. Second annotations should use the appropriate refinement" &
              " constituents of the" &
              " own variable.");
      when 315 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Certain proof contexts have been included in the syntax of SPARK but" &
              " are not yet" &
              " supported; this error message results if one is found.");
      when 316 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If a type is private, then record field selectors may not be used." &
              " In pre- and post-conditions, a proof function can be declared to" &
              " yield the required attribute of a private type.");
      when 317 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The tilde decoration indicates the initial value of a variable or" &
              " parameter which is both imported and exported. A function may not have an explicit side effect" &
              " on a program variable and so cannot be regarded as exporting such a variable.  For modelling purposes" &
              " a read of an external (stream) variable is regarded as having a side effect (outside the SPARK" &
              " boundary).  Since it may be necessary to refer to the initial value of the external variable, before" &
              " this implicit side effect occurs, the use of tilde is allowed only for external variables of mode IN which" &
              " are globally referenced by function.");
      when 318 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The tilde decoration indicates the initial value of a variable or" &
              " parameter which is" &
              " both imported and exported. Percent indicates the value of a variable" &
              " on entry to a for loop; this message occurs if either operator is applied" &
              " to any other object.");
      when 319 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The tilde decoration indicates the initial value of a variable or" &
              " parameter which is" &
              " both imported and exported; this message occurs if the variable" &
              " concerned is either" &
              " exported only or imported only in which case no distinction between" &
              " its initial and final" &
              " value is required.");
      when 320 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Tilde (and %) may not be applied to an element of an array or field of a record." &
              " e.g. to" &
              " indicate the initial value of the Ith element of array V use V~(I)" &
              " not V(I)~.");
      when 321 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Since it does not make sense to refer to anything other than the" &
              " initial value of a" &
              " variable in a pre-condition there is no need to use tilde to distinguish" &
              " initial from" &
              " final values.");
      when 322 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Pre-conditions are concerned with the initial values of information" &
              " carried into a" &
              " subprogram. Since only imports can do this only imports can appear in" &
              " pre-condition" &
              " expressions.");
      when 323 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The extended SPARK update syntax is only used to express changes to" &
              " components of a" &
              " structured variable.");
      when 324 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When using the extended SPARK update syntax for a record, you can not" &
              " update more than" &
              " one element in each clause of the update. For example, you cannot use" &
              " [x,y =&gt; z], you" &
              " must instead use [x =&gt; z; y =&gt; z].");
      when 325 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs if a type is ""announced"" as part of an own variable" &
              " clause and the end" &
              " of the package is reached without an Ada declaration for a type of" &
              " this name being found.");
      when 326 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs anywhere where a proof context is found not to be a boolean" &
              " expression.");
      when 328 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Occurs if a function calls a procedure which exports a global variable;" &
              " this would" &
              " create an illegal side-effect of the function.");
      when 329 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a call is made to a user-defined subprogram in a package" &
              " initialization part.");
      when 330 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made, in a package initialization part, to" &
              " update an own" &
              " variable of a non-enclosing package.");
      when 332 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where the type contains a component which is a limited private" &
              " type, but where" &
              " the declaration of this type in the visible part of the package does" &
              " not specify that the" &
              " type is limited.");
      when 333 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when an own variable is initialized either by assignment or" &
              " by having a pragma Import attached to it when initialization of the variable" &
              " is not announced in its package's own variable initialization specification.");
      when 335 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a function is declared in a package specification without an" &
              " annotation but" &
              " one is then supplied on the function body.");
      when 337 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Selected component notation may not be used in places where an item is" &
              " directly" &
              " visible.");
      when 338 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Parameters passed as mode in out must be listed as imports in the" &
              " subprogram's" &
              " dependency relation if they are of scalar types. The rule also applies" &
              " to a parameter of a" &
              " private type if its full declaration is scalar.");
      when 340 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "User-declared subprograms may not be renamed in package specifications" &
              " although the" &
              " implicitly declared function subprograms associated with operators may be.");
      when 341 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a range is found where a single value is expected, for example," &
              " if an array" &
              " slice is constructed.");
      when 342 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Like global and derives annotations, proof annotations should be placed" &
              " on the first" &
              " appearance of a subprogram.  There may also be a requirement for a" &
              " second proof annotation" &
              " on a subprogram body where it references an abstract own variable.");
      when 343 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a second proof annotation for a subprogram is found but" &
              " the subprogram does" &
              " not reference any abstract own variables.  A second annotation is" &
              " only required where it" &
              " is necessary to express both an abstract (external) and a refined" &
              " (internal) view of an" &
              " operation.");
      when 399 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a proof annotation contains an expression that would cause" &
              " a constraint error" &
              " if it were in an executable Ada statement.  For example: ""--# post X =" &
              " T'Succ(T'Last);""" &
              " VCs generated from such malformed predicates would always be unprovable.");
      when 400 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a static expression, evaluated using perfect arithmetic," &
              " is found to" &
              " contain a division by zero.");
      when 401 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a numeric literal is illegal because it contains, for example," &
              " digits not" &
              " compatible with its number base.");
      when 402 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued whenever a static expression would cause a constraint error." &
              " e.g. assigning a" &
              " value to a constant outside the constant's type range. In SPARK a static" &
              " expression may" &
              " not yield a value which violates a range constraint.");
      when 403 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when an array attribute containing an argument is found and the" &
              " value of the" &
              " argument is inconsistent with the number of dimensions of the array" &
              " type to which it is" &
              " being applied.");
      when 407 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Choices in case statements and array aggregates may not overlap.");
      when 408 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A case statement must either explicitly supply choices to cover the" &
              " whole range of the" &
              " (sub)type of the controlling expression, or it must supply an others choice.");
      when 409 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK, no static range is permitted to be null.");
      when 410 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The choices in case statements and array aggregates must be within" &
              " the constraints of" &
              " the appropriate (sub)type.");
      when 411 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where an others clause is required to satisfy the Ada language rules.");
      when 413 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where a range constraint is outside the range of the (sub)type to" &
              " which the" &
              " constraint applies.");
      when 414 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An array aggregate must either explicitly supply values for all array" &
              " elements or" &
              " provide an others clause.");
      when 415 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where an array aggregate using positional association contains" &
              " more entries than" &
              " required by the array index type.");
      when 418 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where assignment, association or type conversion is attempted" &
              " between two" &
              " different constrained subtypes of the same unconstrained array type, and" &
              " where the index" &
              " bounds do not match.");
      when 419 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When an entity is renamed, the fully qualified name is no longer visible," &
              " and so must not be used.");
      when 420 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when an attempt is made to convert between two arrays whose indexes" &
              " are neither" &
              " of the same type nor numeric.");
      when 421 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a type conversion attempts to convert between two array types" &
              " whose" &
              " components are of different types.");
      when 422 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a type conversion attempts to convert between two array types" &
              " whose" &
              " components are of the same type but do not have constraints which can be" &
              " statically" &
              " determined to be identical.");
      when 423 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when attempting to convert between two array types which have" &
              " different numbers" &
              " of dimensions.");
      when 424 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Character attributes such as 'Val, 'Pos, 'Succ and 'Pred are not" &
              " permitted below a concatentation operator in a String expression.");
      when 425 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if the argument of a type conversion is a string literal. A common" &
              " cause is an" &
              " attempt to type qualify a string and accidentally omitting the tick character.");
      when 500 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when performing data flow analysis only where a subprogram has no" &
              " dependency" &
              " clause and its global variables have not been given modes in the global" &
              " annotation.");
      when 501 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A dependency relation is required for each procedure if information flow" &
              " analysis is to" &
              " be performed.");
      when 502 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a procedure has both a global annotation with modes and a" &
              " dependency" &
              " relation, and a global of mode in is listed as an export in the dependency" &
              " relation.");
      when 503 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a procedure has both a global annotation with modes and a" &
              " dependency" &
              " relation, and a global of mode out is listed as an import in the" &
              " dependency relation.");
      when 505 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where a procedure has both a global annotation with modes and" &
              " a dependency" &
              " relation, and a global variable of mode in out is not listed as an" &
              " import in the" &
              " dependency relation.");
      when 507 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where a procedure has both a global annotation with modes" &
              " and a dependency" &
              " relation, and a global variable of mode in out is not listed as an" &
              " export in the" &
              " dependency relation.");
      when 509 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When using refinement in automatic flow analysis mode, if there is a" &
              " dependency relation on the subprogram specification then there must" &
              " also be one on the body. Similarly, if there is no dependency relation" &
              " on the specification then the body is not permitted to have one.");
      when 604 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In Ada 95, a package body is illegal unless it is required for the" &
              " purpose of providing" &
              " a subprogram body, or unless this pragma is used. This error is" &
              " issued where a package" &
              " body is found for a package whose specification does not require a body.");
      when 606 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when the parameter to a pragma Elaborate_Body is invalid.");
      when 607 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued where a package specification contains no subprogram declarations," &
              " but whose own" &
              " variables (as specified in the package annotation) are not all declared" &
              " (and initialized" &
              " where appropriate) in the package specification. This is because such a" &
              " package is not" &
              " allowed a body in Ada 95 unless either the pragma is given or a" &
              " subprogram declared.");
      when 613 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a dotted name appears in a body stub as in ""package body" &
              " P.Q is" &
              " separate"". No legal stub could ever have such a name.");
      when 614 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made to declare a child package which is" &
              " embedded in a package" &
              " or subprogram.");
      when 615 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if the closing identifier of a package has a different number of" &
              " identifiers" &
              " from the name originally given for the package. For example ""package" &
              " P.Q is ... end" &
              " P.Q.R;""");
      when 616 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an attempt is made to with or inherit a private package" &
              " from the visible part" &
              " of a public package.");
      when 617 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Arises from attempting to inherit a public sibling child package" &
              " from a private child" &
              " package.");
      when 618 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A private descendent (although it may be a public package) can only" &
              " inherit a remote package if its parent also inherits" &
              " it; this is a analogous to the behaviour of embedded packages which" &
              " may also only inherit" &
              " a remote package if their enclosing package also does so.");
      when 619 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This message indicates an attempt to claim that own variables of a" &
              " package other than a" &
              " private child package of the current package are refinement constituents" &
              " of an abstract" &
              " own variable of the current package.");
      when 620 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables of private child packages must appear as refinement" &
              " constituents of the" &
              " package which owns the child. If the Examiner has seen the owner" &
              " package body before" &
              " processing the child and has not found the required refinement" &
              " constituent then this" &
              " message results on processing the child.");
      when 621 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables of private child packages must appear as refinement" &
              " constituents of the" &
              " package which owns the child. If the Examiner has seen a child package" &
              " which declares an" &
              " own variable before examining its owner&#146;s body then this message" &
              " is issued if the" &
              " owner lacks the required refinement constituent declaration.");
      when 622 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an own variable appears in an initialization clause and is" &
              " also a refinement" &
              " constituent of an own variable which is not marked as initialized.");
      when 623 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an own variable does not appear in an initialization clause" &
              " and is also a" &
              " refinement constituent of an own variable that is marked as initialized.");
      when 624 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A package must appear in a with clause before types declared in" &
              " it can be specified in a use type clause.");
      when 630 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Only generic subprogram can be instantiated.");
      when 631 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Subprogram kind of generic and its instantiation must match");
      when 632 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Subprogram kind of generic and its instantiation must match");
      when 635 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The number of generic formal and actual parameters must match exactly");
      when 636 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See ALRM 12.5.  Each generic formal type parameter must be supplied with an actual type" &
              " which is of a compatible class.  Note that SPARK does not have default values for such" &
              " associations");
      when 637 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "There are weaknesses in the generic type model of Ada 83 that prevent the implementation" &
              " of a safe subset of generics in SPARK 83.  These deficiencies are overcome in Ada 95." &
              " SPARK 83 users may employ the predefined unit Unchecked_Conversion only.");
      when 638 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A standalone generic subprogram may not have a global annotation.  Note that a subprogram in a" &
              " generic package may have a global annotation as long as it only refers to own variables that" &
              " are local to the package.");
      when 639 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK restricts formal objects to being constants in order to avoid concealed information" &
              " flows.");
      when 640 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK restricts formal objects to being constants in order to avoid concealed information" &
              " flows.");
      when 641 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A generic body must be preceded by a generic declaration of the same name.");
      when 645 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See ALRM 12.5.  Each generic formal type parameter must be supplied with an actual type" &
              " which is of a compatible class.  Note that SPARK does not have default values for such" &
              " associations");
      when 646 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See ALRM 12.5.  Each generic formal type parameter must be supplied with an actual type" &
              " which is of a compatible class.  Note that SPARK does not have default values for such" &
              " associations");
      when 647 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See ALRM 12.5.  Each generic formal type parameter must be supplied with an actual type" &
              " which is of a compatible class.  Note that SPARK does not have default values for such" &
              " associations");
      when 648 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See ALRM 12.5.  Each generic formal type parameter must be supplied with an actual type" &
              " which is of a compatible class.  Note that SPARK does not have default values for such" &
              " associations");
      when 649 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See ALRM 12.5.  Each generic formal type parameter must be supplied with an actual type" &
              " which is of a compatible class.  Note that SPARK does not have default values for such" &
              " associations");
      when 650 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See ALRM 12.5.  Each generic formal type parameter must be supplied with an actual type" &
              " which is of a compatible class.  Note that SPARK does not have default values for such" &
              " associations");
      when 651 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In non-generic code we statically know the value being assigned to the variable and can" &
              " check that it is in range.  In the case of a generic we cannot do this because we do not" &
              " know the bounds of the variable's type.  The variable may, however, be assigned to in the sequence" &
              " of statements in the generic body because generation of run-time checks will provide" &
              " suitable protection from out-of-range values.");
      when 652 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In non-generic code we statically know the values being used as the range bounds for" &
              " a subtype and can check that they are in range.  In the case of a generic we cannot" &
              " do this because we do not know the bounds of the variable's type.");
      when 653 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In non-generic code we statically know the value being assigned to the constant and can" &
              " check that it is in range.  In the case of a generic we cannot do this because we do not" &
              " know the bounds of the constant's type.  A variable, assigned to in the sequence" &
              " of statements in the generic body, may be a suitable substitute for such a constant.");
      when 654 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Generic units provide a template for creating callable units and are not directly" &
              " callable.");
      when 655 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Components of generic packages cannot be accessed directly.  First instantiate the package" &
              " and then access components of the instantiation.");
      when 657 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The 'Always_Valid assertion can only be applied to variables or" &
              " to components of record variables.");
      when 658 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The 'Always_Valid assertion can only be applied to objects which are:" &
              " (1) of a scalar type," &
              " (2) a one dimensional array of scalar components," &
              " (3) an entire record variable of a non-tagged type with all" &
              " components that are either scalar or an array of scalar components," &
              " (4) an array variable whose components are records satisfying (3)." &
              " Additionally a field of a record satisfying these constraints may" &
              " be marked individually as always valid.");
      when 662 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The 'Always_Valid assertion can only be applied to variables which are" &
              " own variables with the mode in, or to subcomponents of records" &
              " which are mode in own variables.");
      when 700 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables may be given a mode to indicate that they are system level" &
              " inputs" &
              " or outputs (i.e. they obtain values from or pass values to the external" &
              " environment).  Since effective SPARK design strictly separates inputs from" &
              " outputs the mode 'in out' is not permitted.");
      when 701 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If an abstract own variable is given a mode then its refinement" &
              " constituents must" &
              " all be of the same mode.");
      when 702 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an own variable of an embedded package is not given the" &
              " same mode as" &
              " the earlier refinement constituent that announced it would exist.");
      when 703 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an own variable of an embedded package is not given the same" &
              " mode as" &
              " the earlier refinement constituent that announced it would exist.");
      when 704 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if an own variable of an embedded package is given a mode when" &
              " the earlier refinement constituent that announced it would exist did not" &
              " have one.");
      when 705 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If a refinement constituent is an own variable of a private package then the" &
              " constituent must have the same mode as the own variable to which it refers.");
      when 706 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If a refinement constituent is an own variable of a private package then the" &
              " constituent must have the same mode as the own variable to which it refers.");
      when 707 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If a refinement constituent is an own variable of a private package then the" &
              " constituent can only be given a mode if the own variable to which it" &
              " refers has one.");
      when 708 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Mode own variables (stream variables) are implicitly initialized by the" &
              " environment" &
              " to which they are connected and may not appear in initializes clauses" &
              " since this" &
              " would require their explicit initialization.");
      when 709 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Functions are permitted to reference own variables that are either unmoded" &
              " or of" &
              " mode 'in'.  Since mode 'out' own variables represent outputs to the" &
              " environment," &
              " reading them in a function does not make sense and is not allowed.");
      when 710 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Global modes, if given, must be consistent with the modes of own variables" &
              " that appear" &
              " in the global list.");
      when 711 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Global modes, if given, must be consistent with the modes of own" &
              " variables that appear" &
              " in the global list.");
      when 712 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Global modes, if given, must be consistent with the modes of own variables" &
              " that appear" &
              " in the global list.");
      when 713 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables with mode 'in' denote system-level inputs; their exportation" &
              " is" &
              " not allowed.");
      when 714 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables with mode 'out' denote system-level outputs; their" &
              " importation is" &
              " not allowed.");
      when 715 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To avoid ordering effects, functions which globally access own" &
              " variables which" &
              " have modes (indicating that they are connected to the external" &
              " environment) may" &
              " only appear directly in assignment or return statements." &
              " They may not appear as" &
              " actual parameters or in any other form of expression.");
      when 716 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To avoid ordering effects, own variables which" &
              " have modes (indicating that they are connected to the external" &
              " environment) may" &
              " only appear directly in assignment or return statements. They may not" &
              " appear as" &
              " actual parameters (other than to instantiations of Unchecked_Conversion) or in any other form of expression.");
      when 717 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables with mode 'in' represent inputs to the system from the" &
              " external" &
              " environment. As such, assigning to them does not make sense and is not" &
              " permitted.");
      when 718 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables with mode 'out' represent outputs to the external" &
              " environment from the system. As such, referencing them does not make sense" &
              " and is not permitted.");
      when 719 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables with modes represent inputs and outputs between the external" &
              " environment and the system. Referencing or updating them during package" &
              " elaboration would introduce ordering effects and is not permitted.");
      when 720 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables with modes represent inputs and outputs between the external" &
              " environment and the system. Referencing or updating them during package" &
              " elaboration would introduce ordering effects and is not permitted.");
      when 721 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Functions may be used to reference external (stream) variables and the" &
              " Examiner" &
              " generates the appropriate information flow to show that the value returned" &
              " by" &
              " the function is 'volatile'.  If the abstract view of the same function" &
              " shows it" &
              " referencing an own variable which is not an external stream then the" &
              " volatility" &
              " of the function is concealed.  The error can be removed either by making the" &
              " abstract own variable a mode 'in' stream or by using a procedure instead" &
              " of a" &
              " function to read the refined stream variable.");
      when 722 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Where a procedure references an external (stream) variable of mode 'in' the" &
              " Examiner constructs appropriate information flow to show that the input" &
              " stream" &
              " is 'volatile'. If the abstract view shows that the procedure obtains its" &
              " result" &
              " by simply reading an own variable which is not an external stream then the" &
              " volatility is concealed.  The error can be removed either by making the" &
              " global" &
              " mode of XXX 'in out' or making XXX an external (stream) variable of mode" &
              " 'in'.");
      when 723 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a global variable which is present in the first (abstract)" &
              " global annotation" &
              " is omitted from the second (refined) one.");
      when 724 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If an exit statement names a loop label, then the most closely enclosing" &
              " loop statement must have a matching label");
      when 725 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To avoid ordering effects, protected functions  may" &
              " only appear directly in assignment or return statements. They may not" &
              " appear as" &
              " actual parameters or in any other form of expression.  Ordering effects" &
              " occur" &
              " because the global state referenced by the protected function may be updated" &
              " by another process during expression evaluation.");
      when 730 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If a loop has neither an iteration scheme nor any exit statements then it" &
              " will" &
              " run forever. Any statements following it will be unreachable. SPARK only" &
              " allows" &
              " one such loop which must be the last statement of the main program");
      when 750 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The type mark used for the index of an array type declaration must not" &
              " be the same as the name of the array type being declared");
      when 751 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The type mark given for a field in a record type declaration must" &
              " not be the same as the name of the record type being declared");
      when 752 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "For an identifier to appear legally as an import in a derives annotation," &
              " it must be a formal parameter or must appear legally in a" &
              " preceding global annotation and must be of mode 'in' or mode 'in out'");
      when 753 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "For an identifier to appear legally as an export in a derives annotation," &
              " it must be a formal parameter or must appear legally in a" &
              " preceding global annotation and must be of mode 'out' or mode 'in out'");
      when 754 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "For a package name to be visible in Ada context, it must appear in" &
              " both the inherit clause and the with clause of the enclosing package");
      when 755 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A parent of a child package must be inherited (but not withed)" &
              " to be visible in that child.");
      when 756 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A grandparent of a child package should not be included in prefixes" &
              " referencing a declaration of the child package");
      when 770 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If the type Any_Priority is defined in package System, then the subtypes" &
              " Priority and" &
              " Interrupt_Priority must also be defined; if support for tasking is not" &
              " required, then" &
              " the definition of Any_Priority may be removed");
      when 771 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada 95 requires that both Priority and Interrupt_Priority be immediate" &
              " subtypes" &
              " of Any_Priority.");
      when 772 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada 95 requires that the range of the subtype Priority include at least" &
              " 30 values;" &
              " this requirement is stated in the Ada 95 Language Reference Manual at" &
              " D.1(26)");
      when 773 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada 95 requires that task priority types meet the following criteria," &
              " the second of which is relevant to this error:" &
              " subtype Any_Priority is Integer range implementation-defined;" &
              " subtype Priority is Any_Priority range Any_Priority'First .. implementation-defined;" &
              " subtype Interrupt_Priority is Any_Priority range Priority'Last+1 .. Any_Priority'Last");
      when 774 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada 95 requires that task priority types meet the following criteria," &
              " the third of which is relevant to this error:" &
              " subtype Any_Priority is Integer range implementation-defined;" &
              " subtype Priority is Any_Priority range Any_Priority'First .. implementation-defined;" &
              " subtype Interrupt_Priority is Any_Priority range Priority'Last+1 .. Any_Priority'Last");
      when 775 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada 95 requires that task priority types meet the following criteria," &
              " the third of which is relevant to this error:" &
              " subtype Any_Priority is Integer range implementation-defined;" &
              " subtype Priority is Any_Priority range Any_Priority'First .. implementation-defined;" &
              " subtype Interrupt_Priority is Any_Priority range Priority'Last+1 .. Any_Priority'Last");
      when 776 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK95 mode, the packages that may be specified in the target" &
              " configuration file are: Standard, System, Ada.Real_Time and Ada.Interrupts." &
              " The latter two are ignored unless the Ravenscar profile is selected.");
      when 777 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada 95, and hence SPARK95, defines Priority as being an immediate" &
              " subtype of Integer");
      when 778 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The specified identifier cannot be used here; it is most probably" &
              " either not valid in the target configuration file at all, or might" &
              " be valid in a different package, but not here.");
      when 779 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK83 mode, only package Standard may be specified in the" &
              " target configuration file.");
      when 780 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This type may only be declared as private in the target configuration" &
              " file.");
      when 781 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This error can only be generated in SPARK95 mode when the configuration" &
              " file specifies" &
              " a value for System.Min_Int");
      when 782 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This error can only be generated in SPARK95 mode when the configuration" &
              " file specifies" &
              " a value for System.Max_Int");
      when 783 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This error can only be generated in SPARK95 mode when the configuration" &
              " file specifies" &
              " a value for System.Max_Binary_Modulus");
      when 785 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The maximum decimal precision for a floating point type, where" &
              " a range specification has not been included, is defined" &
              " by System.Max_Digits");
      when 786 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The maximum decimal precision for a floating point type, where" &
              " a range specification has been included, is defined" &
              " by System.Max_Base_Digits");
      when 791 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Predefined types are those defined either by the language, or in package" &
              " Standard, using the configuration file mechanism");
      when 793 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If a predefined type is to be used in a base type assertion or in" &
              " a derived type declaration, then it must appear in the configuration" &
              " file and have a well-defined range.");
      when 796 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A base type assertion can only be given exactly once. Explicitly derived" &
              " scalar types and predefined types never need a base type assertion.");
      when 800 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK, modular types must have a modulus which is a positive" &
              " power of 2");
      when 801 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Ada83 (and hence SPARK83) does not include modular types");
      when 803 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Unary arithmetic operators are of little value.  The ""abs"" and ""+"" operators" &
              " have no effect for modular types, and so are not required.  The unary minus" &
              " operator is a source of potential confusion, and so is not permitted in" &
              " SPARK");
      when 804 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A universal expression cannot be used as the left hand operand of a binary" &
              " operator if the right hand operand is of a modular type.  Qualification of" &
              " the" &
              " left hand expression is required in this case.");
      when 805 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A universal expression cannot be used as the right hand operand of a binary" &
              " operator if the left hand operand is of a modular type.  Qualification of" &
              " the" &
              " right hand expression is required in this case.");
      when 806 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A universal expression cannot be used as operand of an unary ""not""" &
              " operator if no type can be determined from the context of the expression." &
              " Qualification of the operand is required in this case.");
      when 814 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The only possible type for the constant System.Default_Bit_Order" &
              " is System.Bit_Order when it appears in the configuration file");
      when 815 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "System.Bit_Order is implicity declared in package System when a configuration" &
              " file is given. This is an enumeration type with only two literals" &
              " Low_Order_First and High_Order_First");
      when 820 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Only non-abstract tagged types are currently supported.  It is hoped to" &
              " lift this" &
              " restriction in a future Examiner release.");
      when 821 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If a type is declared as ""tagged private"" then its full declaration must" &
              " be a tagged" &
              " record.");
      when 822 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK, ""new"" can only be used to declare a type extension; other" &
              " derived types are not permitted.");
      when 823 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK only permits types from another library package to be extended." &
              " This rule prevents" &
              " overloading of inherited operations.");
      when 824 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK only permits one type extension per package.  This rule prevents" &
              " overloading of inherited operations.");
      when 825 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Since SPARK only permits one type extension per package it follows that" &
              " the declaration" &
              " ""new XXX with private"" in a package visible part must be paired with ""new" &
              " XXX with record...""" &
              " in its private part.  The ancestor type XXX must be the same in both" &
              " declarations.");
      when 826 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Type extension is an Ada 95 feature not included in Ada or SPARK 83.");
      when 827 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "There are several reasons for this SPARK rule.  Firstly, Ada requires" &
              " tagged parameters to be" &
              " passed by reference and so an object must exist at least implicitly." &
              " Secondly, in order to" &
              " perform flow analysis of inherited subprogram calls, the Examiner needs" &
              " identify what subset of the" &
              " information available at the point of call" &
              " is passed to and from the called subprogram.  Since information can only" &
              " flow through objects it" &
              " follows that actual parameter must be an object.");
      when 828 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This SPARK rule facilitates the main uses of tagged types while greatly" &
              " simplifying visibility rules.");
      when 829 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To avoid overloading, SPARK prohibits more than one potentially visible" &
              " subprogram having the" &
              " same name.");
      when 830 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This rule means that a private type can only be implemented as a tagged" &
              " type if the private" &
              " type itself is tagged.");
      when 831 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This is an Ada rule: type conversions simply omit unused fields of the" &
              " extended type.  It follows" &
              " that conversions must be in the direction of the root type.");
      when 832 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "For flow analysis purposes the Examiner needs to know what subset of the" &
              " information in" &
              " the unconverted view is available in the converted view.  Since" &
              " information can only flow" &
              " through objects it follows that only objects can be converted.");
      when 833 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If an extended type has a private ancestor then an extension aggregate" &
              " must be used rather" &
              " than a normal aggregate.");
      when 834 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An empty record can have no use in a SPARK program others than as a" &
              " root type from which" &
              " other types can be derived and extended. For this reason, null records" &
              " are only allowed" &
              " if they are tagged.");
      when 835 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An extension aggregate is only appropriate if the record type it is" &
              " defining is" &
              " an extended record.  A normal aggregate should be used for other record" &
              " (and array)" &
              " types.");
      when 836 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The expression before the reserved word ""with"" must be of an ancestor type" &
              " of the overall aggregate" &
              " type.  In SPARK, the ancestor expression may not be a subtype mark.");
      when 837 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The ancestor type can be an tagged type with a private extension;" &
              " however, there must be no private" &
              " extensions between the ancestor type and the type of the aggregate.");
      when 838 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The aggregate form ""with null record"" can only be used if the type of" &
              " the aggregate is a null record" &
              " extension of the ancestor type.  If any fields are added between the" &
              " ancestor type and the aggregate type then" &
              " values need to be supplied for them so ""null record"" is inappropriate.");
      when 839 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK permits one root tagged type or one tagged type extension per" &
              " package, but not both.  This rule prevents" &
              " the declaration of illegal operations with more than one controlling" &
              " parameter.");
      when 840 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A primitive function controlled by its return result would be almost" &
              " unusable in SPARK because a data" &
              " flow error would occur wherever it was used.");
      when 841 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when there is an error in the return type on a function's" &
              " initial declaration.  In this situation" &
              " we cannot be sure what return type is expected in the function's body." &
              " It would be misleading to simply" &
              " report a type mismatch since the types might match perfectly and both" &
              " be wrong.  Instead, the Examiner reports" &
              " the above error and refuses to analyse the function body until its" &
              " specification is corrected.");
      when 844 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK2005, an operation which successfully overrides a parent operation" &
              " must be specified as Overriding.");
      when 845 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In SPARK2005, an overriding operation must successfully override an" &
              " operation inherited from the parent.");
      when 850 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Support for concurrent features of the SPARK language, including" &
              " protected objects," &
              " tasking, etc. are only supported when the Ravenscar profile is selected.");
      when 851 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The parameter to pragma Atomic must be a simple_name; and may not be" &
              " passed using" &
              " a named association");
      when 852 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This is an Ada rule (pragma Atomic takes a local name see LRM 13.1(1))." &
              " Note that this precludes the use of pragma Atomic on a predefined type");
      when 853 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "pragma Atomic may only be applied to base types that are scalar. (i.e." &
              " enumeration types, integer types, real types, modular types) or a non-tagged" &
              " record type with a single field which is a predefined scalar type, such" &
              " as Integer, Character or Boolean. As an additional special case, a" &
              " record type with a single field of type System.Address is also allowed.");
      when 855 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An own variable with a task modifier must be of a task type. A task own" &
              " variable must have the task modifier. An own variable with a protected" &
              " modifier must be a protected object, suspension object or pragma" &
              " atomic type. A protected or suspension object own variable must" &
              " have the protected modifier.");
      when 858 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A variable in a protects list is effectively protected and hence" &
              " cannot be refined.");
      when 859 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Protected state cannot be refined or be used as refinement constituents");
      when 860 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Protected state (including all refinement constituents) must be initialized.");
      when 861 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If an abstract own variable has an Integrity property, then so must" &
              " all its refinement constituents, and vice-versa.");
      when 862 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If both an abstract own variable and a refinement constituent have" &
              " Integrity properties specified, then the value of the Integrity" &
              " must be the same.");
      when 863 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Protected own variables must always be initialized, and should not appear in" &
              " initializes annotations.");
      when 864 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An own variable initialization clause and that of its refinement" &
              " constituents must be" &
              " consistent.");
      when 865 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An extension aggregate must supply values for all fields that are part of" &
              " the overall aggregate" &
              " type but not those which are part of the ancestor part.");
      when 866 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When the Ravenscar Profile is selected, the delay until statement may be" &
              " used." &
              " The argument of this statement must be of type Ada.Real_Time.Time.");
      when 867 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Any subprogram that may call delay until must have a delay property in a" &
              " declare annotation.  Your subprogram is directly or indirectly making a" &
              " call to delay until");
      when 868 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This error message is issued if a type mark representing a protected type" &
              " appears anywhere other than in" &
              " a library level variable declaration or library-level own variable type" &
              " announcement.");
      when 869 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The Ravenscar profile prohibits a protected type from declaring more than" &
              " one entry.");
      when 870 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A protected type which provides no operations can never be used so SPARK" &
              " requires the" &
              " declaration of at least one.");
      when 872 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In order to avoid the possibility of shared data corruption," &
              " SPARK prohibits protected operations" &
              " from accessing unprotected data items.");
      when 873 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In order to statically-detect certain bounded errors defined by the" &
              " Ravenscar profile, SPARK" &
              " requires every visible operation of protected type to globally" &
              " reference the abstract state of" &
              " the type.");
      when 874 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Because there is no guarantee that a concurrent thread that initializes a" &
              " protected object will be executed before one that reads it, the only way" &
              " we can be sure that a protected object is properly initialized is to do" &
              " so at the point of declaration. You have either declared some protected" &
              " state and not included an initialization or you have tried to initialize" &
              " some protected state in package body elaboration.");
      when 875 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Access discriminants have been allowed in SPARK solely to allow devices" &
              " made up of co-operating" &
              " Ravenscar-compliant units to be constructed.  For this reason only" &
              " protected types may appear in" &
              " access discriminants.");
      when 876 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To allow the static detection of certain bounded errors defined by the" &
              " Ravenscar profile, SPARK requires" &
              " an explicitly-set priority for each protected type, task type or object" &
              " of those types.  The System.Default_Priority" &
              " may used explicitly provided package System has been defined in the" &
              " configuration file.");
      when 878 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To allow the static detection of certain bounded errors defined by the" &
              " Ravenscar profile, SPARK requires" &
              " an explicitly-set priority for each protected type or object." &
              " The System.Default_Priority may used explicitly" &
              " provided package System has been defined in the configuration file.");
      when 879 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "pragma Interrupt_Priority must be the first item in" &
              " a protected type declaration or task type declaration; pragma Priority" &
              " must be the first item in" &
              " a protected type declaration, task type declaration or the main program.");
      when 880 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a pragma other than Priority or Interrupt_Priority appears as" &
              " the first item in" &
              " a protected type or task type declaration.");
      when 881 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See LRM D.1(17).");
      when 883 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Interrupt_Handler is of no use unless dynamic attachment of interrupt" &
              " handlers is to be used.");
      when 884 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Pragma Attach_Handler may only be used within a protected type" &
              " declaration.  Furthermore, it must" &
              " immediately follow a protected procedure declaration with the same name" &
              " as the first argument to the pragma.");
      when 885 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See LRM C.3.1(5).");
      when 887 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued when a task or protected type priority is set using an expression" &
              " involving a discriminant. The use" &
              " of such an expression greatly complicates the static evaluation of the" &
              " priority of task or protected subtypes" &
              " thus preventing the static elimination of certain Ravenscar bounded errors.");
      when 888 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A procedure may only have a maximum of one delay annotation.");
      when 889 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The type used to declare this object must be a protected type with and" &
              " entry or a suspension object type");
      when 890 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Items may not appear more than once in an a suspends list.");
      when 891 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued in a subtype declaration where the constraint is a discriminant" &
              " constraint.  Only task and protected types" &
              " may take a discriminant constraint as part of a subtype declaration.");
      when 892 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued in a subtype declaration where the constraint is a either a" &
              " discriminant constraint or an index" &
              " constraint (these two forms cannot always be distinguished" &
              " syntactically).  Only task and protected types" &
              " may take a discriminant constraint and only array types may" &
              " take an index constraint as part of a" &
              " subtype declaration.");
      when 893 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued in a subtype declaration if too many or two few discriminant" &
              " constraints are supplied.");
      when 894 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK supports the keyword aliased in variable declarations only so" &
              " that protected and task types can support" &
              " access discriminants.  Since it has no other purpose it may not be" &
              " used except in a protected object declaration.");
      when 895 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This is a slightly annoying Ada issue.  Marking a variable as aliased" &
              " prevents it being placed in a register" &
              " which would make pointing at it hazardous; however, SPARK only permits" &
              " 'Access on protected types which are" &
              " limited and therefore always passed by reference anyway and immune from" &
              " register optimization.   Requiring" &
              " aliased on protected objects that will appear in discriminant" &
              " constraints is therefore unwanted syntactic sugar" &
              " only.");
      when 896 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued at the end of a package body if a task type declared in its" &
              " specification contains neither a body" &
              " nor a body stub for it.");
      when 897 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued at the end of a package body if a protected type declared in" &
              " its specification contains neither a body" &
              " nor a body stub for it.");
      when 898 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a body or body stub for a task or protected type is" &
              " encountered and there is no matching specification.");
      when 899 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a body or body stub for a task or protected type is" &
              " encountered and an earlier body" &
              " has already been encountered.");
      when 901 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Suspension objects must be declared at library level. They cannot" &
              " be used in protected type state or as local variables in subprograms.");
      when 903 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Protected and suspension objects are used to ensure integrity of shared" &
              " objects. If it is necessary to share constant data then these constructs" &
              " should not be used.");
      when 904 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK does not currently support this feature.");
      when 905 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK does not currently support this feature.");
      when 906 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Protected and suspension objects cannot be used in record or array" &
              " structures.");
      when 907 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "You are calling delay until from an invalid construct." &
              " Any construct that calls delay until must have a delay property in the" &
              " declare annotation. This construct must be one of a task or procedure body");
      when 908 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Procedures in protected scope must not block and therefore blocking" &
              " properties are prohibited");
      when 909 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "You are either applying the suspendable property to an own variable" &
              " that cannot suspend or you have declared a variable (whose own variable" &
              " has the suspendable property) which cannot suspend. Or you have used an" &
              " item in a suspends list that does not have the suspendable property." &
              " An object can only suspend if it is a suspension object or a protected" &
              " type with an entry.");
      when 910 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Protected entry calls and calls to" &
              " Ada.Synchronous_Task_Control.Suspend_Until_True may block the currently" &
              " executing task. SPARK requires you announce this fact by placing the" &
              " actual callee name in the suspends list for the enclosing unit.");
      when 911 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "If the main program priority is not an integer literal then you" &
              " should declare a constant that has the required value in the" &
              " declarative part of the main program prior to the position of the pragma.");
      when 912 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The call being made has a declare annotation that contains a delay" &
              " property. SPARK requires that this property is propagated up" &
              " the call chain and hence must appear in a declare annotation" &
              " for the enclosing unit.");
      when 913 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The call being made has a declare annotation that contains a suspends" &
              " list. SPARK requires that the entire list is propagated up the call" &
              " chain and hence must appear in a declare annotation for the enclosing unit.");
      when 914 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "You have specified the name of a protected or suspension object in" &
              " the suspends list that can never be called by this procedure or task.");
      when 915 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "You have specified a delay property for this procedure but delay" &
              " until can never be called from it.");
      when 916 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The type of the protected object mentions the protected object name in" &
              " the derives list for the given subprogram");
      when 917 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The procedure being called may block and hence cannot be called from" &
              " a protected action.");
      when 918 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The delay property may only be applied to a procedure");
      when 919 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The priority property can only be applied to protected own variables" &
              " which are type announced. If the type has been declared it must be a" &
              " protected type");
      when 920 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The suspends property may only be applied to task type specifications" &
              " and procedures");
      when 921 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The property list can only specify the reserved word delay, suspends or" &
              " priority.");
      when 922 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In order to perform the ceiling priority checks the priority property must" &
              " be given to all own variables of protected type.");
      when 923 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Blocking is seen as a side effect and hence procedures that potentially" &
              " block cannot be called from functions.");
      when 924 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Objects that suspend must be declared as own protected variables");
      when 925 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variables of protected type and own tasks must have a type announcement");
      when 926 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Task objects must be declared in library level package specifications or" &
              " bodies.");
      when 927 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The task type declaration has name XXX in its list and this must appear" &
              " in the own task annotation");
      when 928 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Protected type XXX has been used to declare a protected, moded own variable." &
              " Protected, moded own variables are refined onto a set of virtual elements with" &
              " the same mode. As such private elements are not allowed.");
      when 929 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Declare annotations cannot appear on the procedure body if it appears" &
              " on the procedure specification");
      when 930 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A task has been declared that is not specified as an own task of the" &
              " package.");
      when 931 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A task name appears in the own task annotation for this package but" &
              " is never declared");
      when 932 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The priority given in the priority property must match that given in" &
              " the protected type.");
      when 933 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When SPARK profile Ravenscar is selected, all tasks, protected objects" &
              " and the main program must explicitly be assigned a priority.");
      when 934 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The active priority of a task is the higher of its base priority" &
              " and the ceiling priorities of all protected objects that it is" &
              " executing. The active priority at the point of a call to a" &
              " protected operation must not exceed the ceiling priority of the" &
              " callee.");
      when 935 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An own variable has been declared using a protected type with a pragma" &
              " attach handler. Such objects are used in interrupt processing and must" &
              " have the interrupt property specified in their own variable declaration");
      when 936 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The interrupt property can only be applied to protected own variables" &
              " that are type announced. If the type is declared then it must be a" &
              " protected type that contains an attach handler");
      when 937 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The protects property can only be applied to protected own variables" &
              " that are type announced. If the type is declared then it must be a" &
              " protected type.");
      when 938 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "XXX is an unprotected variable that appears in the global list of the" &
              " threads YYY and ZZZ. Unprotected variables cannot be shared between" &
              " threads in SPARK. A thread is one of: the main program, a task, an" &
              " interrupt handler.");
      when 939 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "XXX is an own variable with the suspends property that appears in the" &
              " suspends list of the threads YYY and ZZZ. SPARK prohibits this to" &
              " prevent more than one thread being suspended on the same item at any" &
              " one time. A thread is one of: the main program, a task, an interrupt" &
              " handler.");
      when 940 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The use of protected variables in pre and postconditions or other proof annotations is not (currently)" &
              " supported.  Protected variables are volatile because they can be changed at any time by another program" &
              " thread and this may invalidate some common proof techniques.  The prohibition of protected variables" &
              " does not prevent proof of absence of run-time errors nor proof of protected operation bodies.  See the" &
              " manual ""SPARK Proof Manual"" for more details.");
      when 941 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The type used to an announce an own variable with a protects property" &
              " must be declared in the same package.");
      when 942 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Type XXX has a protects property. This means there can be only one object" &
              " in the package that has this type or any subtype of this type.");
      when 943 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "All items in a protects list must be unprotected own variables owned by" &
              " this package");
      when 944 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The name XXX appears in more than one protects list. The first time" &
              " it appeared was for own variable YYY. XXX should appear in at most" &
              " one protects list.");
      when 945 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This property can only accept a static expression.");
      when 946 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The own variable XXX is protected by the protected type YYY and hence" &
              " must never be accessed from anywhere else.");
      when 947 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The protected type YYY claims to protect XXX via a protects property." &
              " However, the variable XXX is not used by any operation in YYY.");
      when 948 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own tasks and protected own variables of a protected type must be" &
              " announced using the base type. The" &
              " subsequent variable declaration may be a subtype of the base type");
      when 949 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When the sequential SPARK profile is selected, the global and derives" &
              " annotation on the main program describes" &
              " the entire program's behaviour.  No additional, partition annotation" &
              " is required or permitted.  Note that an" &
              " annotation must appear here if the Ravenscar profile is selected.");
      when 950 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "When the Ravenscar profile is selected the global and derives annotation" &
              " on the main program describes the" &
              " behaviour of the environment task only, not the entire program." &
              " An additional annotation, called the" &
              " partition annotation, is required to describe the entire program's" &
              " behaviour; this annotation follows" &
              " immediately after 'main_program;'");
      when 951 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "In order to ensure that a Ravenscar program is complete, SPARK requires" &
              " that all 'active' packages" &
              " inherited by the environment task also appear in a corresponding" &
              " with clause.  This check ensures that" &
              " any program entities described in the partition annotation are also" &
              " linked into the program itself.");
      when 952 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Interrupt handler operations cannot be called.");
      when 953 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The handler names in an interrupt property must match one in the" &
              " protected type of the own variable.");
      when 954 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The stream name must be unprefixed and not already in use within the" &
              " scope of the package.");
      when 955 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Interrupt stream variables are used only to enhance the partition" &
              " wide flow annotation and must not be used elsewhere.");
      when 956 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "An interrupt handler can be mapped onto exactly one interrupt stream" &
              " variable. An interrupt stream variable may be mapped onto many interrupt" &
              " handlers.");
      when 957 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A protected variable cannot be updated without direct reference to its" &
              " preceding value more than once within a subprogram or task." &
              " Each update of a protected variable may have a wider effect than" &
              " just the change of value of the protected variable. The overall" &
              " change is considered to be the accumulation of all updates and" &
              " reads of the protected variable and to preseve this information flow" &
              " successive updates must directly depend on the preceding value of" &
              " the variable");
      when 958 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "A task may not import unprotected state unless it is mode in." &
              " This is because under the concurrent elaboration policy, the task cannot" &
              " rely on the state being initialized before it is run.");
      when 959 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Own variable XXX is being accessed by a task. The order in which the task" &
              " is run and the own variable initialized is non-deterministic under a" &
              " concurrent elaboration policy. In this case SPARK forces the task to" &
              " perform the initialization and as such the own variable must not appear" &
              " in an initializes clause.");
      when 960 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To avoid ordering effects, functions which globally access own" &
              " variables which have modes (indicating that they are connected to" &
              " the external environment) may only appear directly in assignment or" &
              " return statements. They may not appear as actual parameters or in any" &
              " other form of expression." &
              " SPARK relaxes the illegal use of function calls in elaboration code in" &
              " the case of the function Ada.Real_Time.Clock. However the function can only" &
              " be used to directly initialize a constant value.");
      when 961 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Please check the user manual for valid property value formats.");
      when 962 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "This message is echoed to the screen if an unrecoverable" &
              " error occurs which" &
              " makes the generation of VCs for the current subprogram impossible." &
              " Another message more precisely identifying the problem will be placed in" &
              " the .vcg file.");
      when 986 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "See LRM 9.5.1 (2). A protected function has read access to the" &
              " protected elements of the type whereas" &
              " the called procedure has read-write access. There is no way in which" &
              " an Ada compiler can determine whether" &
              " the procedure will illegally update the protected state or not so the" &
              " call is prohibited by the rules of Ada." &
              " (Of course, in SPARK, we know there is no function side effect but the" &
              " rules of Ada must prevail nonetheless).");
      when 987 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The Examiner performs certain important checks at the whole program level" &
              " such as detection of illegal sharing of" &
              " unprotected state and partition-level information flow analysis." &
              " These checks require visibility of task" &
              " types and protected types (especially those containing interrupt" &
              " handlers).  SPARK therefore requires these" &
              " types to be declare in package specifications.  Subtypes and objects" &
              " of task types, protected types and their" &
              " subtypes may be declared in package bodies.");
      when 988 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "SPARK does not allow the re-use of operation names which are already" &
              " in use in a directly visible" &
              " protected type.  The restriction is necessary to avoid overload resolution" &
              " issues in the protected" &
              " body.  For example, type PT in package P declares operation K." &
              " Package P also declares an operation K." &
              " From inside the body of PT, a call to K could refer to either of the" &
              " two Ks since both are directly visible.");
      when 989 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "To prevent any possibility of a task terminating (which can lead to a" &
              " bounded error), SPARK requires" &
              " each task to end with a non-terminating loop.  The environment task (or" &
              " ""main program"") does not need" &
              " to end in a plain loop provided the program closure includes at least" &
              " one other task.  If there are" &
              " no other tasks, then the environment task must be made non-terminating" &
              " with a plain loop.");
      when 990 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a pre, post or declare annotation is attached to a task body.");
      when 991 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if task body is encountered for which there is no preceding" &
              " declaration.");
      when 992 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a duplicate body or body stub is encountered for a task.");
      when 993 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a body is found for a protected types for which there is" &
              " no preceding declaration.");
      when 994 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "The SPARK Ravenscar rules require a simple Boolean guard which must" &
              " be one of the protected elements" &
              " of the type declaring the entry.");
      when 995 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Local entries are not permitted so a protected body can declare at" &
              " most one entry body and that must have" &
              " declared in the protected type specification.");
      when 996 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Each exported protected operation must have a matching implementation" &
              " in the associated protected body.");
      when 997 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Each protected type declaration must have exactly one matching" &
              " protected body or body stub.");
      when 998 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Issued if a protected body or body stub is found and there is no" &
              " matching declaration for it.");
      when 999 =>
         E_Strings.Append_String
            (E_Str => E_Str,
             Str   => "Generics are currently limited to instantiation of Unchecked_Conversion.");
      when others => null;
   end case;
end SemanticErrExpl;
