;;; -*- mode:lisp;base:10.;fonts:(cptfontb) -*-
;;; $Header: /ct/interp/eror.l,v 1.91 85/01/24 18:11:54 penny Exp $
;;;
;;;

 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;                           eror.l                                 ;;;
;;; Paul Robertson                                  January 30, 1983 ;;;
;;;                                                                  ;;;
;;;         The C*T Ada Interpreters error handlers                  ;;;
;;;                                                                  ;;;
;;; This file is part of a proprietary software project.  Source     ;;;
;;; code and documentation describing implementation details are     ;;;
;;; available on a confidential, non-disclosure basis only.  These   ;;;
;;; materials, including this file in particular, are trade secrets  ;;;
;;; of Computer * Thought Corporation.                               ;;;
;;;                                                                  ;;;
;;; (c) Copyright 1982 and 1983,  Computer * Thought Corporation.    ;;;
;;;     All Rights Reserved.                                         ;;;
;;;                                                                  ;;;
;;; Reference materials:                                             ;;;
;;;   Miller, 1982.  The C*T Ada Tutor: Guide to the Implementation. ;;;
;;;   Charniak et al., 198?.  Artificial Intelligence Programming.   ;;;
;;;                                                                  ;;;
;;; The following code assumes familiarity with the above.           ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Ensure presence of needed files. 


(eval-when (compile load eval) (ct_load 'aip))	      ;AIP macros pkg. 

(eval-when (compile load eval) (ct_load 'compat))     ;Franz/LM compat pkg. 

(eval-when (compile load eval) (ct_load 'charmac))

(eval-when (compile load eval) (ct_load 'time))       ;Timing functions. 

(eval-when (compile load eval) (ct_load 'sema))       ;sc_diana_macro

(eval-when (compile load eval) (ct_load 'pser))       ;parsing syntax macros.

(eval-when (compile load eval) (ct_load 'reference)) ;handles doc refers
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Compiler Declarations and Global/Special Variables -- 

#+franz (declare (macros t))
(declare (ct_includef 'intrpdcl))		; get the specials
(eval-when (compile load eval) (ct_load 'ferec))	; get the macros etc.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Externally Call-able Functions/Macros -- 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Internal Use Only Functions/Macros -- 

       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun greater-or-equal-experience-than (level lang)
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (and (status feature tutor)
       (let ((experience (second (assq lang
				       (db_find_entry  **current_student_folder**
                                                       'language_profile)))))
    (member level (member experience '(advanced intermediate elementary none))))))

       ;;;;;;;;;;;;;;;;;;;;
(defun less-experience-than (level lang)
       ;;;;;;;;;;;;;;;;;;;;

  (and (status feature tutor)
       (let ((experience (second (assq lang
				       (db_find_entry  **current_student_folder**
                                                       'language_profile)))))
    (member level (member experience '(none elementary intermediate advanced))))))


;;;(less-experience-than 'intermediate 'ada)

       ;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun student-preferred-language ()
       ;;;;;;;;;;;;;;;;;;;;;;;;;;

  (db_find_entry **current_student_folder** 'pref_language))

       ;;;;;;;;;;;;;;;;;;;;;;
(defun def_ada_error_recovery macro (l) ;hangs error recovery code onto plists.
       ;;;;;;;;;;;;;;;;;;;;;;

       (let ((fname (concat 'ada_error_recovery_ (cadr l) (gensym))))
	 `(progn 'compile
		 (defun ,fname . ,(cdaddr l))
		 (defprop ,(cadr l) ,fname error_missing))))

       ;;;;;;;;;;;;;;;;;;;;;;
(defun def_ada_embedded_error macro (l) ;hangs error recovery code onto plists.
       ;;;;;;;;;;;;;;;;;;;;;;

       (let ((fname (concat 'ada_embedded_error_ (cadr l) (gensym))))
	 `(progn 'compile
		 (defun ,fname . ,(cdaddr l))
		 (defprop ,(cadr l) ,fname embedded_error))))

       ;;;;;;;;;;;;;;;;;;;;;;
(defun def_sem_error_recovery macro (l) ;hangs sem error recovery code onto plists.
       ;;;;;;;;;;;;;;;;;;;;;;

       (let ((fname (concat 'sem_error_recovery_ (cadr l) (gensym))))
	 `(progn 'compile
		 (defun ,fname . ,(cdaddr l))
		 (defprop ,(cadr l) ,fname sem_error))))

(defun def_sem_warning macro (l) ;hangs sem error recovery code onto plists.
       ;;;;;;;;;;;;;;;;;;;;;;

       (let ((fname (concat 'sem_warning_ (cadr l) (gensym))))
	 `(progn 'compile
		 (defun ,fname . ,(cdaddr l))
		 (defprop ,(cadr l) ,fname sem_warning))))

       ;;;;;;;;;;;;;;;;;
(defun is_ada_ssemantics macro (l)	; hangs static semantics onto plists.
       ;;;;;;;;;;;;;;;;;

       (let ((fname (concat 'ada_ssemantics_ (cadr l) (gensym))))
	 `(progn 'compile
		 (defun ,fname . ,(cdaddr l))
		 (defprop ,(cadr l) ,fname ada_ssemantics))))



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Semantic warnings

    (def_sem_warning will_raise_exception
      (lambda (l)
	(swarn `(,(format nil "This program will raise the exception ~a."
			  (car l))))))

    (def_sem_warning semwarn_undefined
      (lambda (l)
	(swarn `(,(format nil
			  "Internal error: the message ~a is undefined."
			  (car l))))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Syntax errors of the class "Error in <nonterminal>"



    
    (def_ada_embedded_error proc_param_decl
      (lambda ()
	  (gripe '("An error was encountered in a procedure's formal parameter list.")
	      '((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 8))))))

;;; accept_sequence_of_statements 9.5 2 ex 9.5 19      
    (def_ada_embedded_error sequence_of_statements
      (lambda ()
	(ct_selectq (car *current_non_terminal*)
	    (if_statement (gripe '("An error was encountered in the statements in an if statement.")
	      '((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))
		(lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 5 nil)))))
	  (case_statement_naka (gripe '("An error was encountered in the statements in a case statement.")
	      '((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 7 nil)))))
	  (loop_statement (gripe '("An error was encountered in the statements in a loop statement.")
	      '((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 9 12)))))
	  (statement_part (gripe '("An error was encountered in the statements in a begin .. end block.")
	      '((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 19 nil))))))))
    
    (def_ada_embedded_error accept_sequence_of_statements
      (lambda ()
	  (gripe '("An error was encountered in the statements in an accept statement.")
		 '((lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 5 nil))))))
    
    (def_ada_embedded_error type_definition
      (lambda ()
 	  (gripe '("An error was encountered in a type definition.")
	      '((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_embedded_error declarative_part_extnb
      (lambda ()
	  (gripe '("An error was encountered in the declarations in this block.")
	      '((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 1 4))
		(lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil))))))

    (def_ada_embedded_error declarative_part
      (lambda ()
	  (gripe '("An error was encountered in the declarations of this compilation unit.")
	      '((lrmref "LRM" (lrmsec 3 1 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error subtype_indication
      (lambda ()
	  (gripe '("An error was encountered in a type mark.")
	      '((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 3))
		(lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_embedded_error subtype_indication_init
      (lambda ()
	  (gripe '("An error was encountered in a type mark or an initializing expression.")
	      '((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
  
    (def_ada_embedded_error idlist_oper_colon
      (lambda ()
	  (gripe '("An error was encountered in an identifier list.")
	      '((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 nil))
		(lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 13 nil))))))
  
    (def_ada_embedded_error arrayref_oper_rparen        
      (lambda ()
	  (gripe '("An error was encountered in an array reference.")
	      '((lrmref "LRM" (lrmsec 4 1 1) (lrmpar 2 nil))
		(lrmref "LRM" (lrmsec 4 1 1) (lrmpar 5 nil))))))

    
    
    (def_ada_embedded_error accuracy_constraint
	(lambda ()
	    (gripe '("An error was encountered in an accuracy constraint.")
		'((lrmref "LRM" (lrmsec 3 5 9) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 9) (lrmpar 18 nil))))))
    
    (def_ada_embedded_error type_definition
	(lambda ()
	    (gripe '("An error was encountered in a type definition.")
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_embedded_error derived_type_definition
	(lambda ()
	    (gripe '("An error was encountered in a type definition.")
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_embedded_error incomplete_type_definition
	(lambda ()
	    (gripe '("An error was encountered in a type definition.")
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_embedded_error enumeration_literal
	(lambda ()
	    (gripe '("An error was encountered in an enumeration literal.")
		'((lrmref "LRM" (lrmsec 3 5 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 1) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error type_mark
	(lambda ()
	    (gripe '("An error was encountered in a type mark.")
		'((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_embedded_error subtype_declaration
	(lambda ()
	    (gripe '("An error was encountered in a subtype declaration.")
		'((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_embedded_error range
	(lambda ()
	    (gripe '("An error was encountered in a range.")
		'((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error range_constraint
	(lambda ()
	    (gripe '("An error was encountered in a range constraint.")
		'((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error floating_point_constraint
	(lambda ()
	    (gripe '("An error was encountered in a floating point constraint.")
		'((lrmref "LRM" (lrmsec 3 5 7) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 7) (lrmpar 18 nil))))))
    
    (def_ada_embedded_error fixed_point_constraint
	(lambda ()
	    (gripe '("An error was encountered in a fixed point constraint.")
		'((lrmref "LRM" (lrmsec 3 5 9) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 9) (lrmpar 18 nil))))))
    
    (def_ada_embedded_error array_type_declaration
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))
    
    (def_ada_embedded_error array_type_declaration_centreexit
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))

(def_ada_embedded_error array_type_declaration_bottomloop
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))

    (def_ada_embedded_error array_type_declaration_toploop
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))  
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))

    (def_ada_embedded_error constrained_array_type_declaration_init
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))  
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11))))))
    
    (def_ada_embedded_error record_type_definition
	(lambda ()
	    (gripe '("An error was encountered in a record type definition.")
		'((lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 2  nil))
                    (lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 9 nil))))))
    
    (def_ada_embedded_error pragma
	(lambda ()
	    (gripe '("An error was encountered in a pragma.")
		'((lrmref "LRM" (lrmsec 2 8 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 2 8 nil) (lrmpar 10 nil))))))
    
    (def_ada_embedded_error obj_num_exc_declaration	;  What is this?
	(lambda ()
	    (gripe '("An error was encountered in an object, number or exception declaration.")
		'((lrmref "LRM" (lrmsec 3 1 nil) (lrmpar 3 nil))))))
    
    (def_ada_embedded_error constant_definition
	(lambda ()
	    (gripe '("An error was encountered in an object declaration.")
		'((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 nil))
                    (lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 13 nil))))))
    
    (def_ada_embedded_error constraint
	(lambda ()
	    (gripe '("An error was encountered in a constraint.")
		'((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_embedded_error declarative_item
	(lambda ()
	    (gripe '("An error was encountered in a declarative item.")
		'((lrmref "LRM" (lrmsec 3 9 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error index_range
	(lambda ()
	    (gripe '("An error was encountered in an index range.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 1) (lrmpar 12 nil))))))
    
    (def_ada_embedded_error component_list
	(lambda ()
	    (gripe '("An error was encountered in a component list.")
		'((lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 9 nil))))))
    
    (def_ada_embedded_error component_list_when_part
	(lambda ()
	    (gripe '("An error was encountered in a component list.")
		'((lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 9 nil))))))
    
    (def_ada_embedded_error choice_range
	(lambda ()
	    (gripe '("An error was encountered in a choice range.")
		'((lrmref "LRM" (lrmsec 3 7 3) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error discriminant_part
	(lambda ()
	    (gripe '("An error was encountered in a discriminant.")
		'((lrmref "LRM" (lrmsec 3 7 3) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error discriminant_part_body
	(lambda ()
	    (gripe '("An error was encountered in a discriminant part.")
		'((lrmref "LRM" (lrmsec 3 7 3) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error name
	(lambda ()
	    (gripe '("An error was encountered in a name.")
		'((lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 2 nil))))))

   (def_ada_embedded_error name_aux
	(lambda ()
	    (gripe '("An error was encountered in a name.")
		'((lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error name_cdr
	(lambda ()
	    (gripe '("An error was encountered in a name.")
		'((lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 11 nil))))))
    
    (def_ada_embedded_error operator_symbol
	(lambda ()
	    (gripe '("An error was encountered in an operator symbol.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error literal
	(lambda ()
	    (gripe '("An error was encountered in a literal.")
		'((lrmref "LRM" (lrmsec 2 4 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 2 5 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 2 6 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error program_component
	(lambda ()
	    (gripe '("An error was encountered in a later declarative item.")
		'((lrmref "LRM" (lrmsec 3 9 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error factor
	(lambda ()
	    (gripe '("An error was encountered in a factor.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
   (def_ada_embedded_error expression
	(lambda ()
		(ct_selectq (car *current_non_terminal*)
			    (case_statement (gripe
			      '("An error was encountered in the expression after the reserved word 'case'.")
			     '((lrmref "LRM" (lrmsec 5 4 nil)(lrmpar 2 nil))
				(lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 7 nil)))))
			    (obj_num_exc_decl (gripe
				'("An error was encountered in an expression in an object initialization.")
			     '((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 nil))
			       (lrmref "LRM" (lrmsec 3 2 1) (lrmpar 20 nil))))))))
    
    (def_ada_embedded_error term
	(lambda ()
	    (gripe '("An error was encountered in a term.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error relation
	(lambda ()
	    (gripe '("An error was encountered in a relation.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error simple_expression
	(lambda ()
	  (ct_selectq (car *current_non_terminal*)
	    (relational_expression (gripe
		     '("An error was encountered in a simple expression in a relation expression.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 4 5 2) (lrmpar 11 nil)))))
	    (index_range (gripe
		     '("An error was encountered in a simple expression in a range.")
		'((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))))
    
    (def_ada_embedded_error primary
	(lambda ()
	    (gripe '("An error was encountered in a primary.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error general_aggregate
	(lambda ()
	    (gripe '("An error was encountered in an aggregate.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error general_aggregate_naka
	(lambda ()
	    (gripe '("An error was encountered in an aggregate.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))

    (def_ada_embedded_error general_aggregate_naka_no_naka
	(lambda ()
	    (gripe '("An error was encountered in an aggregate.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))

    (def_ada_embedded_error general_aggregate_naka_no_naka_car
	(lambda ()
	    (gripe '("An error was encountered in an aggregate.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error if_statement
	(lambda ()
	    (gripe '("An error was encountered in an if statement.")
		'((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 5 nil))))))
    
    (def_ada_embedded_error case_statement
	(lambda ()
	    (gripe '("An error was encountered in a case statement.")
		'((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 5 nil))))))

    (def_ada_embedded_error case_statement_naka
	(lambda ()
	    (gripe '("An error was encountered in a case statement.")
		'((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 5 nil))))))
    
    (def_ada_embedded_error loop_statement
	(lambda ()
	    (gripe '("An error was encountered in a loop statement.")
		'((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 10 12))))))
    
    (def_ada_embedded_error block_stmt
	(lambda ()
	    (gripe '("An error was encountered in a block statement.")
		'((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil))))))
    
    (def_ada_embedded_error statement_part
	(lambda ()
	    (gripe '("An error was encountered in a statement part.")
		'((lrmref "LRM" (lrmsec 5 1 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error exception_part
	(lambda ()
	    (gripe '("An error was encountered in an exception part.")
		'((lrmref "LRM" (lrmsec 11 2 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 11 2 nil) (lrmpar 7 nil))))))
    
    (def_ada_embedded_error exit_statement
	(lambda ()
	    (gripe '("An error was encountered in an exit statement.")
		'((lrmref "LRM" (lrmsec 5 7 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 7 nil) (lrmpar 5 nil))))))
    
    (def_ada_embedded_error return_statement
	(lambda ()
	    (gripe '("An error was encountered in a return statement.")
		'((lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 7 nil))))))
    
    (def_ada_embedded_error goto_statement
	(lambda ()
	    (gripe '("An error was encountered in a goto statement.")
		'((lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil))))))
    
    (def_ada_embedded_error proc_param_decl
	(lambda ()
	    (gripe '("An error was encountered in the parameter declarations for a procedure.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))))))
   
    (def_ada_embedded_error funct_param_decl
	(lambda ()
	    (gripe '("An error was encountered in the parameter declarations for a function.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 8 nil))))))
    
    (def_ada_embedded_error funct_formal_part
	(lambda ()
	    (gripe '("An error was encountered in the function's parameter list.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                      (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 nil))))))
    
    (def_ada_embedded_error proc_formal_part
	(lambda ()
	    (gripe '("An error was encountered in the procedure's parameter list.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 8 nil))))))
    
    (def_ada_embedded_error body_part
	(lambda ()
	    (gripe '("An error was encountered in a body.")
		'((lrmref "LRM" (lrmsec 3 9 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error actual_parameter_part
	(lambda ()
	    (gripe '("An error was encountered in the actual parameter list.")
		'((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 7 8))))))

    (def_ada_embedded_error actual_parameter_part_formal
	(lambda ()
	    (gripe '("An error was encountered in the actual parameter list.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 8))))))
    
    (def_ada_embedded_error procedure_or_entry_call
	(lambda ()
	    (gripe '("An error was encountered in a procedure or entry call.")
		'((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 2 nil))))))

    (def_ada_embedded_error procedure_or_entry_call_formal
	(lambda ()
	    (gripe '("An error was encountered in a procedure or entry call.")
		'((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error package_spec_part
	(lambda ()
	    (gripe '("An error was encountered in the package's specification.")
		'((lrmref "LRM" (lrmsec 7 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 7 2 nil) (lrmpar 5 nil))))))
    
    (def_ada_embedded_error use_clause
	(lambda ()
	    (gripe '("An error was encountered in a use clause.")
		'((lrmref "LRM" (lrmsec 8 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 8 4 nil) (lrmpar 10 11))))))
    
    (def_ada_embedded_error task_spec_part
	(lambda ()
	    (gripe '("An error was encountered in a task specification.")
		'((lrmref "LRM" (lrmsec 9 1 nil) (lrmpar 3 nil))
                    (lrmref "LRM" (lrmsec 9 1 nil) (lrmpar 8 nil))))))
    
    (def_ada_embedded_error accept_statement
	(lambda ()
	    (gripe '("An error was encountered in an accept statement.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 13 nil))))))
    
    (def_ada_embedded_error accept_statement_naka
	(lambda ()
	    (gripe '("An error was encountered in an accept statement.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 13))))))
    
    (def_ada_embedded_error delay_statement
	(lambda ()
	    (gripe '("An error was encountered in a delay statement.")
		'((lrmref "LRM" (lrmsec 9 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 6 nil) (lrmpar 8 nil))))))
    
    (def_ada_embedded_error select_statement
	(lambda ()
	    (gripe '("An error was encountered in a select statement.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 nil))))))
    
    (def_ada_embedded_error select_statement_naka
	(lambda ()
	    (gripe '("An error was encountered in a select statement.")
		'((lrmref "LRM" (lrmsec 9 7 1 ) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 13))))))
    
    (def_ada_embedded_error abort_statement
	(lambda ()
	    (gripe '("An error was encountered in an abort statement.")
		'((lrmref "LRM" (lrmsec 9 10 nil) (lrmpar 2 nil))
                      (lrmref "LRM" (lrmsec 9 10 nil) (lrmpar 9 nil))))))
    
    (def_ada_embedded_error compilation
	(lambda ()
	    (gripe '("An error was encountered in a compilation.")
		'((lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 2 nil))))))

    (def_ada_embedded_error compilation_unit
	(lambda ()
	    (gripe '("An error was encountered in a compilation.")
		'((lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 2 nil))))))
    
    (def_ada_embedded_error subunit
	(lambda ()
	    (gripe '("An error was encountered in a subunit.")
		'((lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 10 2 1) (lrmpar 3 7))))))
    
    (def_ada_embedded_error raise_statement
	(lambda ()
	    (gripe '("An error was encountered in a raise statement.")
		'((lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 4 nil))))))
    
    (def_ada_embedded_error generic_specification
	(lambda ()
	    (gripe '("An error was encountered in a generic specification.")
		'((lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 7 9))))))
    
    (def_ada_embedded_error generic_formal_parameter
	(lambda ()
	    (gripe '("An error was encountered in a generic formal parameter.")
		'((lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 7 nil))))))
    
    (def_ada_embedded_error generic_instantiation
	(lambda ()
	    (gripe '("An error was encountered in a generic instantiation.")
		'((lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 19 nil))))))
    
    (def_ada_embedded_error generic_instantiation_naka
	(lambda ()
	    (gripe '("An error was encountered in a generic instantiation.")
		'((lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 19 nil))))))

    (def_ada_embedded_error generic_instantiation_cdr
	(lambda ()
	    (gripe '("An error was encountered in a generic instantiation.")
		'((lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 19 nil))))))
    
    (def_ada_embedded_error representation_specification
	(lambda ()
	    (gripe '("An error was encountered in a representation specification.")
		'((lrmref "LRM" (lrmsec 13 1 nil) (lrmpar 2 nil))))))

    (def_ada_embedded_error representation_specification_naka
	(lambda ()
	    (gripe '("An error was encountered in a representation specification.")
		'((lrmref "LRM" (lrmsec 13 1 nil) (lrmpar 2 nil))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Syntax errors of the class - "<nonterminal/terminal> was expected"


    (def_ada_error_recovery nil
      (lambda ()
        (*throw 'embedded_error 'embedded_error)))
 

    (def_ada_error_recovery symb_renames
      (lambda ()
	  (gripe '("The reserved word 'renames' was expected.")
	       '((lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 10 11))))))


;;; ***this needs more context***
    (def_ada_error_recovery lex_ident
      (lambda ()
	(ct_selectq (car *current_non_terminal*)
	  (loop_statement (gripe '("An identifier was expected in loop statement.")
	      	      '((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
		        (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 11 nil)))))
          (type_declaration (gripe
		      '("An identifier was expected in type statement.")
	      	      '((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 7 nil))))))))
    
    (def_ada_error_recovery proc_param_decl
      (lambda ()
	  (gripe '("An error was encountered in a procedure's formal parameter list.")
	      '((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 8))))))
    				       
    (def_ada_error_recovery symb_procedure
      (lambda ()
	  (gripe '("A subprogram declaration was expected.")
	      '((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 8))))))

;;; accept_sequence_of_statements 9.5 2 ex 9.5 19      
    (def_ada_error_recovery sequence_of_statements
      (lambda ()
	(ct_selectq (car *current_non_terminal*)
	    (if_statement (gripe '("Statements were expected in an if statement.")
	      '((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))
		(lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 5 nil)))))
	  (case_statement_naka (gripe '("Statements were expected in a case statement.")
	      '((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 7 nil)))))
	  (loop_statement (gripe '("Statements were expected in a loop statement.")
	      '((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 9 12)))))
	  (statement_part (gripe '("Statements were expected in a begin .. end block.")
	      '((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 19 nil))))))))
    
    (def_ada_error_recovery accept_sequence_of_statements
      (lambda ()
	  (gripe '("Statements were expected in an accept statement.")
		 '((lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery type_definition
      (lambda ()
 	  (gripe '("A type definition was expected.")
	      '((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_error_recovery declarative_part_extnb
      (lambda ()
	  (gripe '("Declarations were expected.")
	      '((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 1 4))
		(lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil))))))

    (def_ada_error_recovery declarative_part
      (lambda ()
	  (gripe '("Declarations were expected.")
	      '((lrmref "LRM" (lrmsec 3 1 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery subtype_indication
      (lambda ()
	  (gripe '("A type mark was expected.")
	      '((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 3))
		(lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_error_recovery subtype_indication_init
      (lambda ()
	  (gripe '("A type mark was expected.")
	      '((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_error_recovery oper_assign
      (lambda ()
	  (gripe '("The assignment operator (:=) was expected.")
	      '((lrmref "LRM" (lrmsec 5 2 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 2 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery symb_separate
      (lambda ()
	  (gripe '("The reserved word 'separate' was expected.")
	      '((lrmref "LRM" (lrmsec 10 2 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 10 2 1) (lrmpar 5 7))))))

    (def_ada_error_recovery symb_then
      (lambda ()
	  (gripe '("The reserved word 'then' was expected in an 'if' statement.")
	      '((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 5 nil))))))
  
    (def_ada_error_recovery symb_if
      (lambda ()
	  (gripe '("The reserved words 'end if' were expected at the end of an 'if' statement.")
	      '((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 5 nil))))))
  
    (def_ada_error_recovery symb_case
      (lambda ()
	  (gripe '("The reserved words 'end case' were expected at the end of a 'case' statement.")
	      '((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 7 nil) (lrmpar 7 nil))))))
  
    (def_ada_error_recovery symb_loop
      (lambda ()
	  (gripe '("The reserved words 'end loop' were expected at the end of a 'loop' statement.")
	      '((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 9 10))))))

;;;  ***needs more context***
;;;  idlist_oper_colon
;;; could be in declarations or param specs 
    (def_ada_error_recovery oper_colon
      (lambda ()
	  (gripe '("A colon was probably omitted.")
	      '((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 nil))
		(lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 13 nil))))))
  
    (def_ada_error_recovery idlist_oper_colon
      (lambda ()
	  (gripe '("A colon was probably omitted after an identifier list.")
	      '((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 nil))
		(lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 13 nil))))))
  

;;; ***needs more context***
;;; arrayref_oper_rparen 4.1.1 2 ex 4.1.1 5
;;; proc_call_oper_rparen 
;;; func_call_oper_rparen
;;; unbalanced parens in expression
    (def_ada_error_recovery oper_rparen        
      (lambda ()
	  (gripe '("A right parenthesis was probably omitted.")
	      '((lrmref "LRM" (lrmsec 4 1 1) (lrmpar 2 nil))
		(lrmref "LRM" (lrmsec 4 1 1) (lrmpar 5 nil))))))
  
    (def_ada_error_recovery arrayref_oper_rparen        
      (lambda ()
	  (gripe '("A right parenthesis was probably omitted in an array reference.")
	      '((lrmref "LRM" (lrmsec 4 1 1) (lrmpar 2 nil))
		(lrmref "LRM" (lrmsec 4 1 1) (lrmpar 5 nil))))))

    (def_ada_error_recovery unbalanced_exp_oper_rparen        
      (lambda ()
	  (gripe '("The parentheses in this expression are unbalanced.")
	      '((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
		(lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
  

    (def_ada_error_recovery symb_do
      (lambda ()
	  (gripe '("The reserved word 'do' was expected.")
	      '((lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 10 nil))))))
  
    (def_ada_error_recovery symb_of
      (lambda ()
	  (gripe '("The reserved word 'of' was expected in an 'array' specification.")
	      '((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 13))))))
;;; ***needs context if possible***
;;; arrayref_oper_lparen 4.1.1 2 ex 4.1.1 5 
;;; proc_call_oper_lparen
;;; func_call_oper_lparen 
;;; unbalanced parens in an expression
    (def_ada_error_recovery oper_lparen
      (lambda ()
	  (gripe '("A left parenthesis was probably omitted.")
	      '((lrmref "LRM" (lrmsec 4 1 1) (lrmpar 2 nil))
		(lrmref "LRM" (lrmsec 4 1 1) (lrmpar 5 nil))))))
;;; ***needs more context here***
;;; sep_body_stub_symb_is  10.2 2 ex 10.2.1 5 7
;;; proc__symb_is 10.2. 2 10.2.1 2
;;; case_symb_is 5.4 2 5.4 7
;;; type_symb_is 3.3.1 2 3.3.1 7
;;; generic instant_symb_is 12.3 2 12.3 19
;;; generic decl_symb_is 12.1 2 12.1.2 7 9
;;; package_symb_is 7.1 2 7.1 5
;;; private_symb_is 7.4 2 7.4 5
;;;
    (def_ada_error_recovery symb_is
      (lambda ()
	  (gripe '("The reserved word 'is' was expected.")
	      nil)))
  
    (def_ada_error_recovery oper_ltgt
      (lambda ()
	  (gripe '("The reserved symbol '<>' was expected.")
	      '((lrmref "LRM" (lrmsec 12 1 2) (lrmpar 8 12))
		   (lrmref "LRM" (lrmsec 12 1 2) (lrmpar 15 16))))))

    (def_ada_error_recovery oper_goes
      (lambda ()
	  (gripe '("The reserved symbol '=>' was expected.")
	      '((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 7 nil))))))

    (def_ada_error_recovery symb_use
      (lambda ()
	  (gripe '("The reserved word 'use' was expected in a representation specification.")
	      '((lrmref "LRM" (lrmsec 13 4 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery symb_record
      (lambda ()
	  (gripe '("The reserved words 'end record' were expected at the end of a record declaration.")
	      '((lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 2 nil))
		   (lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 9 nil))))))

    (def_ada_error_recovery symb_return
      (lambda ()
	  (gripe '("The reserved word 'return' was expected in a function specification.")
	      '((lrmref "LRM" (lrmsec 6 5 nil) (lrmpar 1 4))))))

    (def_ada_error_recovery symb_range
      (lambda ()
	  (gripe '("The reserved word 'range' was expected.")
	      '((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 1 5))
		   (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 13 14))))))

    (def_ada_error_recovery symb_end
      (lambda ()
	  (gripe '("The reserved word 'end' was expected.")
	      )))

    (def_ada_error_recovery oper_semicolon
        (lambda ()
	  (gripe '("A semicolon was probably omitted.")
	      '((lrmref "LRM" (lrmsec 2 2 nil) (lrmpar 1 9))))))

    (def_ada_error_recovery oper_comment	; This is impossible
    	(lambda ()
	   (gripe '("The comment leader (--) was expected.")
	       '((lrmref "LRM" (lrmsec 2 7 nil) (lrmpar 1 4))))))

    (def_ada_error_recovery oper_comma
    	(lambda ()
	    (gripe '("A comma (,) was probably omitted.")
		'((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 13))))))
    
    (def_ada_error_recovery oper_dotdot
    	(lambda ()
	    (gripe '("The reserved symbol '..' was expected.")
		'((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 3 5 1) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery oper_lbracket	; This is probably impossible
    	(lambda ()
	    (gripe '("A left bracket ([) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_rbracket	; This is probably impossible 
    	(lambda ()
	    (gripe '("A right bracket (]) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_quote
	(lambda ()
	    (gripe '("A quote (') was probably omitted.")
		)))
					  
    (def_ada_error_recovery oper_period
	(lambda ()
	    (gripe '("A period (.) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_bar
	(lambda ()
	    (gripe '("A bar (|) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_star
	(lambda ()
	    (gripe '("An asterisk (*) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_starstar
	(lambda ()
	    (gripe '("A double asterisk (**) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_slash
	(lambda ()
	    (gripe '("A slash (/) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_equals
	(lambda ()
	    (gripe '("An equal sign (=) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_notequals	;  I doubt that this is
						; possible
	(lambda ()
	    (gripe '("A not equal sign (/=) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_lt		; I doubt that this is
						; possible
	(lambda ()
	    (gripe '("A less than sign (<) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_le		;  I doubt that this is
						; possible
	(lambda ()
	    (gripe '("A less than or equal sign (<=) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_gt		; I doubt that this is
						; possible
	(lambda ()
	    (gripe '("A greater than sign (>) was probably omitted.")
		)))
    
    (def_ada_error_recovery oper_ge		;  I doubt that this is
						; possible
	(lambda ()
	    (gripe '("A greater than or equal sign (>=) was probably omitted.")
		)))
    
    (def_ada_error_recovery plus		;  I doubt that this is
						; possible
	(lambda ()
	    (gripe '("A plus sign (+) was probably omitted.")
		)))

    (def_ada_error_recovery minus		;  I doubt that this is
						; possible
	(lambda ()
	    (gripe '("A minus sign (-) was probably omitted.")
		)))

    (def_ada_error_recovery oper_ampersand
	(lambda ()
	    (gripe '("An ampersand (&) was probably omitted.")
		)))
   (def_ada_error_recovery oper_mlt
	(lambda ()
	    (gripe '("The reserved symbol '<<' was expected.")
		'((lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil))))))

    (def_ada_error_recovery oper_mgt
	(lambda ()
	    (gripe '("The reserved symbol '>>' was expected.")
		'((lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery symb_abort
	(lambda ()
	    (gripe '("The reserved word 'abort' was expected.")
		'((lrmref "LRM" (lrmsec 9 10 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 10 nil) (lrmpar 9 nil))))))
    
    (def_ada_error_recovery symb_accept
	(lambda ()
	    (gripe '("The reserved word 'accept' was expected.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 nil))))))
    
    (def_ada_error_recovery symb_access
	(lambda ()
	    (gripe '("The reserved word 'access' was expected.")
		'((lrmref "LRM" (lrmsec 3 8 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 8 nil) (lrmpar 7 nil))))))
    
    (def_ada_error_recovery symb_all
	(lambda ()
	    (gripe '("The reserved word 'all' was expected.")
		'((lrmref "LRM" (lrmsec 4 1 3) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 1 3) (lrmpar 21 nil))))))
    
    (def_ada_error_recovery symb_and
	(lambda ()
	    (gripe '("The reserved word 'and' was expected.")
		'((lrmref "LRM" (lrmsec 4 5 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 5 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery symb_array
	(lambda ()
	    (gripe '("The reserved word 'array' was expected.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 nil))))))
    
    (def_ada_error_recovery symb_at
	(lambda ()
	    (gripe '("The reserved word 'at' was expected.")
		)))
    
    (def_ada_error_recovery symb_begin
	(lambda ()
	    (gripe '("The reserved word 'begin' was expected.")
		'((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery symb_body
	(lambda ()
	    (gripe '("The reserved word 'body' was expected.")
		)))
    
    (def_ada_error_recovery symb_constant
	(lambda ()
	    (gripe '("The reserved word 'constant' was expected.")
		)))
    
    (def_ada_error_recovery symb_declare
	(lambda ()
	    (gripe '("The reserved word 'declare' was expected.")
		'((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery symb_delay
	(lambda ()
	    (gripe '("The reserved word 'delay' was expected.")
		'((lrmref "LRM" (lrmsec 9 6 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 9 6 nil) (lrmpar 8 nil))))))
    
    (def_ada_error_recovery symb_delta
	(lambda ()
	    (gripe '("The reserved word 'delta' was expected.")
		'((lrmref "LRM" (lrmsec 12 1 2) (lrmpar 12 nil))
                     (lrmref "LRM" (lrmsec 12 1 2) (lrmpar 15 nil))))))
    
    (def_ada_error_recovery symb_digits
	(lambda ()
	    (gripe '("The reserved word 'digits' was expected.")
		'((lrmref "LRM" (lrmsec 12 1 2) (lrmpar 11 nil))
                     (lrmref "LRM" (lrmsec 12 1 2) (lrmpar 15 nil))))))
    
    (def_ada_error_recovery symb_else
	(lambda ()
	    (gripe '("The reserved word 'else' was expected.")
		'((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery symb_elsif
	(lambda ()
	    (gripe '("The reserved word 'elsif' was expected.")
		'((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery symb_entry
	(lambda ()
	    (gripe '("The reserved word 'entry' was expected.")
		'((lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 9 5 nil) (lrmpar 17 nil))))))
    
    (def_ada_error_recovery symb_exception
	(lambda ()
	    (gripe '("The reserved word 'exception' was expected.")
		)))
    
    (def_ada_error_recovery symb_exit
	(lambda ()
	    (gripe '("The reserved word 'exit' was expected.")
		'((lrmref "LRM" (lrmsec 5 7 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 5 7 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery symb_for
	(lambda ()
	    (gripe '("The reserved word 'for' was expected.")
		'((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 11 nil))))))
    
    (def_ada_error_recovery symb_function
	(lambda ()
	    (gripe '("The reserved word 'function' was expected.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery symb_generic
	(lambda ()
	    (gripe '("The reserved word 'generic' was expected.")
		)))
    
    (def_ada_error_recovery symb_goto
	(lambda ()
	    (gripe '("The reserved word 'goto' was expected.")
		'((lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 2 nil))
                     (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery symb_in
	(lambda ()
	    (gripe '("The reserved word 'in' was expected.")
		)))
    
    (def_ada_error_recovery symb_limited
	(lambda ()
	    (gripe '("The reserved word 'limited' was expected.")
		'((lrmref "LRM" (lrmsec 7 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 7 4 4) (lrmpar 12 nil))))))
    
    (def_ada_error_recovery symb_mod
	(lambda ()
	    (gripe '("The reserved word 'mod' was expected.")
		)))
    
    (def_ada_error_recovery symb_new
	(lambda ()
	    (gripe '("The reserved word 'new' was expected.")
		)))
    
    (def_ada_error_recovery symb_not
	(lambda ()
	    (gripe '("The reserved word 'not' was expected.")
		)))
    
    (def_ada_error_recovery symb_null
	(lambda ()
	    (gripe '("A 'null' statement was expected.")
		)))
    
    (def_ada_error_recovery symb_or
	(lambda ()
	    (gripe '("The reserved word 'or' was expected.")
		)))
    
    (def_ada_error_recovery symb_others
	(lambda ()
	    (gripe '("The reserved word 'others' was expected.")
		'((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery symb_out
        (lambda ()
            (gripe '("The reserved word 'out' was expected.")
                '((lrmref "LRM" (lrmsec 6 2 nil) (lrmpar 1 6))
                    (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 nil))))))

    (def_ada_error_recovery symb_package
        (lambda ()
            (gripe '("The reserved word 'package' was expected.")
                '((lrmref "LRM" (lrmsec 7 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 19 nil))))))

    (def_ada_error_recovery symb_pragma 
        (lambda ()
            (gripe '("The reserved word 'pragma' was expected.")
                '((lrmref "LRM" (lrmsec 2 8 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 2 8 nil) (lrmpar 6 nil))))))

    (def_ada_error_recovery symb_private
        (lambda ()
            (gripe '("The reserved word 'private' was expected.")
                '((lrmref "LRM" (lrmsec 7 4 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery symb_raise
        (lambda ()
            (gripe '("The reserved word 'raise' was expected.")
                '((lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 4 nil))))))

    (def_ada_error_recovery symb_rem
        (lambda ()
            (gripe '("The reserved word 'rem' was expected.")
                )))

    (def_ada_error_recovery symb_reverse
        (lambda ()
            (gripe '("The reserved word 'reverse' was expected.")
                '((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))))))


    (def_ada_error_recovery symb_select
	(lambda ()
	    (gripe '("The reserved word 'select' was expected.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 nil))))))
    
    (def_ada_error_recovery symb_symbtype
	(lambda ()
	    (gripe '("The reserved word 'subtype' was expected.")
		'((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_error_recovery symb_terminate
	(lambda ()
	    (gripe '("The reserved word 'terminate' was expected.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 13 nil))))))

    (def_ada_error_recovery symb_task
	(lambda ()
	    (gripe '("The reserved word 'task' was expected.")
		'((lrmref "LRM" (lrmsec 9 1 nil) (lrmpar 3 nil))
                    (lrmref "LRM" (lrmsec 9 1 nil) (lrmpar 8 10)) ))))

    (def_ada_error_recovery symb_type
	(lambda ()
	    (gripe '("The reserved word 'type' was expected.")
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 7 nil))))))

    (def_ada_error_recovery symb_when
	(lambda ()
	    (gripe '("The reserved word 'when' was expected.")
		'((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 nil))))))

    (def_ada_error_recovery symb_while
	(lambda ()
	    (gripe '("The reserved word 'while' was expected.")
		'((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 10 nil))))))

    (def_ada_error_recovery symb_with
	(lambda ()
	    (gripe '("The reserved word 'with' was expected.")
		'((lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 10 nil))))))

    (def_ada_error_recovery symb_xor
	(lambda ()
	    (gripe '("The reserved word 'xor' was expected.")
		)))
    
    (def_ada_error_recovery lex_eof
	(lambda ()
	    (gripe '("An end of file mark or a compilation unit was expected.")
		)))
    
    (def_ada_error_recovery lex_string
	(lambda ()
	    (gripe '("A string was expected.")
		'((lrmref "LRM" (lrmsec 2 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 2 6 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery lex_char
	(lambda ()
	    (gripe '("A character was expected.")
		'((lrmref "LRM" (lrmsec 2 5 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 2 5 nil) (lrmpar 3 nil))))))
    
    (def_ada_error_recovery lex_number
	(lambda ()
	    (gripe '("A number was expected.")
		'((lrmref "LRM" (lrmsec 2 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 2 4 1) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery accuracy_constraint
	(lambda ()
	    (gripe '("An accuracy constraint was expected.")
		'((lrmref "LRM" (lrmsec 3 5 9) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 9) (lrmpar 18 nil))))))
    
    (def_ada_error_recovery type_definition
	(lambda ()
	    (gripe '("A type definition was expected.")
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_error_recovery derived_type_definition
	(lambda ()
	    (gripe '("An error was encountered in a type definition.")
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_error_recovery incomplete_type_definition
	(lambda ()
	    (gripe '("An error was encountered in a type definition.")
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 1) (lrmpar 6 7))))))
    
    (def_ada_error_recovery enumeration_literal
	(lambda ()
	    (gripe '("An enumeration literal was expected.")
		'((lrmref "LRM" (lrmsec 3 5 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 1) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery type_mark
	(lambda ()
	    (gripe '("A type mark was expected.")
		'((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_error_recovery subtype_declaration
	(lambda ()
	    (gripe '("A subtype declaration was expected.")
		'((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_error_recovery range
	(lambda ()
	    (gripe '("A range was expected.")
		'((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery range_constraint
	(lambda ()
	    (gripe '("A range constraint was expected.")
		'((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery floating_point_constraint
	(lambda ()
	    (gripe '("A floating point constraint was expected.")
		'((lrmref "LRM" (lrmsec 3 5 7) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 7) (lrmpar 18 nil))))))
    
    (def_ada_error_recovery fixed_point_constraint
	(lambda ()
	    (gripe '("A fixed point constraint was expected.")
		'((lrmref "LRM" (lrmsec 3 5 9) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 5 9) (lrmpar 18 nil))))))
    
    (def_ada_error_recovery array_type_declaration
	(lambda ()
	    (gripe '("An array type declaration was expected.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))
    
    (def_ada_error_recovery array_type_declaration_centreexit
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))

    (def_ada_error_recovery array_type_declaration_bottomloop
	(lambda ()
	  (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))

    (def_ada_error_recovery array_type_declaration_toploop
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 12))))))

    (def_ada_error_recovery constrained_array_type_declaration_init
	(lambda ()
	    (gripe '("An error was encountered in an array type declaration.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11))))))
    
    (def_ada_error_recovery record_type_definition
	(lambda ()
	    (gripe '("A record type definition was expected.")
		'((lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 2  nil))
                    (lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 9 nil))))))
    
    (def_ada_error_recovery pragma
	(lambda ()
	    (gripe '("A pragma was expected.")
		'((lrmref "LRM" (lrmsec 2 8 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 2 8 nil) (lrmpar 10 nil))))))
    
    (def_ada_error_recovery obj_num_exc_declaration	;  What is this?
	(lambda ()
	    (gripe '("An object, number or exception declaration was expected.")
		'((lrmref "LRM" (lrmsec 3 1 nil) (lrmpar 3 nil))))))
    
    (def_ada_error_recovery constant_definition
	(lambda ()
	    (gripe '("An object declaration was expected.")
		'((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 nil))
                    (lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 13 nil))))))
    
    (def_ada_error_recovery constraint
	(lambda ()
	    (gripe '("A constraint was expected.")
		'((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))
    
    (def_ada_error_recovery declarative_item
	(lambda ()
	    (gripe '("A declarative item was expected.")
		'((lrmref "LRM" (lrmsec 3 9 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery index_range
	(lambda ()
	    (gripe '("An index range was expected.")
		'((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 6 1) (lrmpar 12 nil))))))
    
    (def_ada_error_recovery component_list
	(lambda ()
	    (gripe '("A component list was expected.")
		'((lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 9 nil))))))
    
    (def_ada_error_recovery component_list_when_part
	(lambda ()
	    (gripe '("An error was encountered in a component list.")
		'((lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 nil) (lrmpar 9 nil))))))
    
    (def_ada_error_recovery choice_range
	(lambda ()
	    (gripe '("A choice range was expected.")
		'((lrmref "LRM" (lrmsec 3 7 3) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery discriminant_part
	(lambda ()
	    (gripe '("A discriminant was expected.")
		'((lrmref "LRM" (lrmsec 3 7 3) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery discriminant_part_body
	(lambda ()
	    (gripe '("An error was encountered in a discriminant part.")
		'((lrmref "LRM" (lrmsec 3 7 3) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery name
	(lambda ()
	    (gripe '("A name was expected.")
		'((lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 11 nil))))))

    (def_ada_error_recovery name
	(lambda ()
	    (gripe '("A name was expected.")
		'((lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 11 nil))))))
    
    (def_ada_error_recovery name_cdr
	(lambda ()
	    (gripe '("An error was encountered in a name.")
		'((lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 1 nil) (lrmpar 11 nil))))))
    
    (def_ada_error_recovery operator_symbol
	(lambda ()
	    (gripe '("An operator symbol was probably omitted.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery literal
	(lambda ()
	    (gripe '("A literal was expected.")
		)))
    
    (def_ada_error_recovery program_component
	(lambda ()
	    (gripe '("A later declarative item was expected.")
		'((lrmref "LRM" (lrmsec 3 1 nil) (lrmpar 3 nil))))))
    
    (def_ada_error_recovery factor
	(lambda ()
	    (gripe '("A factor was expected.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
   (def_ada_error_recovery expression
	(lambda ()
		(ct_selectq (car *current_non_terminal*)
			    (case_statement (gripe
			      '("An expression was expected after the reserved word 'case'.")
			     '((lrmref "LRM" (lrmsec 5 4 nil)(lrmpar 2 nil))
				(lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 7 nil)))))
			    (obj_num_exc_decl (gripe
				'("An expression was expected in an object initialization.")
			     '((lrmref "LRM" (lrmsec 3 2 nil) (lrmpar 9 nil))
			       (lrmref "LRM" (lrmsec 3 2 1) (lrmpar 20 nil))))))))
    
    (def_ada_error_recovery term
	(lambda ()
	    (gripe '("A term was expected.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery relation
	(lambda ()
	    (gripe '("A relation was expected.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery simple_expression
	(lambda ()
	  (ct_selectq (car *current_non_terminal*)
	    (relational_expression (gripe
		     '("A simple expression was expected in a relational expression.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 4 5 2) (lrmpar 11 nil)))))
	    (index_range (gripe
		     '("A simple expression was expected in a range.")
		'((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil))))))))
    
    (def_ada_error_recovery primary
	(lambda ()
	    (gripe '("A primary was expected.")
		'((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil)))))) 
    
    (def_ada_error_recovery general_aggregate
	(lambda ()
	    (gripe '("An aggregate was expected.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery general_aggregate_naka
	(lambda ()
	    (gripe '("An error was encountered in an aggregate.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery general_aggregate_naka_no_naka
	(lambda ()
	    (gripe '("An error was encountered in an aggregate.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery general_aggregate_naka_no_naka_car
	(lambda ()
	    (gripe '("An error was encountered in an aggregate.")
		'((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery if_statement
	(lambda ()
	    (gripe '("An if statement was expected.")
		'((lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 2 nil)) 
                    (lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery case_statement
	(lambda ()
	    (gripe '("A case statement was expected.")
		'((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 5 nil))))))

    (def_ada_error_recovery case_statement_naka
	(lambda ()
	    (gripe '("An error was encountered in a case statement.")
		'((lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 4 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery loop_statement
	(lambda ()
	    (gripe '("A loop statement was expected.")
		'((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 10 12))))))
    
    (def_ada_error_recovery block_stmt
	(lambda ()
	    (gripe '("A block statement was expected.")
		'((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery statement_part
	(lambda ()
	    (gripe '("A statement part was expected.")
		)))
    
    (def_ada_error_recovery exception_part
	(lambda ()
	    (gripe '("An exception part was expected.")
		'((lrmref "LRM" (lrmsec 11 2 nil) (lrmpar 2 4))))))
    
    (def_ada_error_recovery exit_statement
	(lambda ()
	    (gripe '("An exit statement was expected.")
		'((lrmref "LRM" (lrmsec 5 7 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 7 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery return_statement
	(lambda ()
	    (gripe '("A return statement was expected.")
		'((lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 7 nil))))))
    
    (def_ada_error_recovery goto_statement
	(lambda ()
	    (gripe '("A goto statement was expected.")
		'((lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil))))))
    
    (def_ada_error_recovery proc_param_decl
	(lambda ()
	    (gripe '("Parameter declarations for a procedure were expected.")
		'((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 2 nil))))))
   
    (def_ada_error_recovery funct_param_decl
	(lambda ()
	    (gripe '("Parameter declarations for a function were expected.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 8 nil))))))
    
    (def_ada_error_recovery funct_formal_part
	(lambda ()
	    (gripe '("An error was encountered in the function's parameter list.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                      (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 nil))))))
    
    (def_ada_error_recovery proc_formal_part
	(lambda ()
	    (gripe '("An error was encountered in the procedure's parameter list.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 8 nil))))))
    
    (def_ada_error_recovery body_part
	(lambda ()
	    (gripe '("An error was encountered in the body of this compilation unit.")
		)))
    
    (def_ada_error_recovery actual_parameter_part
	(lambda ()
	    (gripe '("An error was encountered in the actual parameter list.")
		'((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 7 8))))))

    (def_ada_error_recovery actual_parameter_part_formal
	(lambda ()
	    (gripe '("An error was encountered in the actual parameter list.")
		'((lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 6 1 nil) (lrmpar 7 8))))))
    
    (def_ada_error_recovery procedure_or_entry_call
	(lambda ()
	    (gripe '("An error was encountered in a procedure or entry call.")
		'((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery procedure_or_entry_call_formal
	(lambda ()
	    (gripe '("An error was encountered in a procedure or entry call.")
		'((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery package_spec_part
	(lambda ()
	    (gripe '("Package specifications were expected.")
		'((lrmref "LRM" (lrmsec 7 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 7 2 nil) (lrmpar 5 nil))))))
    
    (def_ada_error_recovery use_clause
	(lambda ()
	    (gripe '("A use clause was expected.")
		'((lrmref "LRM" (lrmsec 8 4 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 8 4 nil) (lrmpar 10 11))))))
    
    (def_ada_error_recovery task_spec_part
	(lambda ()
	    (gripe '("A task specification part was expected.")
		'((lrmref "LRM" (lrmsec 9 1 nil) (lrmpar 3 nil))
                    (lrmref "LRM" (lrmsec 9 1 nil) (lrmpar 8 nil))))))
    
    (def_ada_error_recovery accept_statement
	(lambda ()
	    (gripe '("An accept statement was expected.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 13 nil))))))
    
    (def_ada_error_recovery accept_statement_naka
	(lambda ()
	    (gripe '("An error was encountered in an accept statement.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 13))))))
    
    (def_ada_error_recovery delay_statement
	(lambda ()
	    (gripe '("A delay statement was expected.")
		'((lrmref "LRM" (lrmsec 9 6 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 6 nil) (lrmpar 8 nil))))))
    
    (def_ada_error_recovery select_statement
	(lambda ()
	    (gripe '("A select statement was expected.")
		'((lrmref "LRM" (lrmsec 9 7 1) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 nil))))))
    
    (def_ada_error_recovery select_statement_naka
	(lambda ()
	    (gripe '("An error was encountered in a select statement.")
		'((lrmref "LRM" (lrmsec 9 7 1 ) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 9 7 1) (lrmpar 12 13))))))
    
    (def_ada_error_recovery abort_statement
	(lambda ()
	    (gripe '("An abort statement was expected.")
		'((lrmref "LRM" (lrmsec 9 10 nil) (lrmpar 2 nil))
                      (lrmref "LRM" (lrmsec 9 10 nil) (lrmpar 9 nil))))))
    
    (def_ada_error_recovery compilation
	(lambda ()
	    (gripe '("A compilation unit was expected.")
		'((lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery compilation_unit
	(lambda ()
	    (gripe '("A compilation unit was expected.")
		'((lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 2 nil))))))
    
    (def_ada_error_recovery subunit
	(lambda ()
	    (gripe '("A subunit was expected.")
		'((lrmref "LRM" (lrmsec 10 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 10 2 1) (lrmpar 3 7))))))
    
    (def_ada_error_recovery raise_statement
	(lambda ()
	    (gripe '("A raise statement was expected.")
		'((lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 4 nil))))))
    
    (def_ada_error_recovery generic_specification
	(lambda ()
	    (gripe '("A generic specification was expected.")
		'((lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 7 9))))))
    
    (def_ada_error_recovery generic_formal_parameter
	(lambda ()
	    (gripe '("A generic formal parameter was expected.")
		'((lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 7 nil))))))
    
    (def_ada_error_recovery generic_instantiation
	(lambda ()
	    (gripe '("A generic instantiation was expected.")
		'((lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 19 nil))))))
    
    (def_ada_error_recovery generic_instantiation_naka
	(lambda ()
	    (gripe '("An error was encountered in a generic instantiation.")
		'((lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 19 nil))))))

    (def_ada_error_recovery generic_instantiation_cdr
	(lambda ()
	    (gripe '("An error was encountered in a generic instantiation.")
		'((lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 2 nil))
                    (lrmref "LRM" (lrmsec 12 3 nil) (lrmpar 19 nil))))))
    
    (def_ada_error_recovery representation_specification
	(lambda ()
	    (gripe '("A representation specification was expected.")
		'((lrmref "LRM" (lrmsec 13 1 nil) (lrmpar 2 nil))))))

    (def_ada_error_recovery      representation_specification_naka
	(lambda ()
	    (gripe '("An error was encountered in the representation specification.")
		'((lrmref "LRM" (lrmsec 13 1 nil) (lrmpar 2 nil))))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; all of the semantic errors replacing sgripes in the file

   
   (def_sem_error_recovery non_matching_num_ind
    (lambda (l)
        (sgripe `(,(format nil "The number of indices provided, ~D,in the index constraint for the array is not the amount required, ~D" (car l) (cadr l) 
			   ))
		'((lrmref "LRM" (lrmsec 3 6 1) (lrmpar 3 nil))
		  (lrmref "LRM" (lrmsec 3 6 1) (lrmpar 12 nil))
		  ))))

  (def_sem_error_recovery cant_constrain_a_constr_access
    (lambda (l)
        (sgripe `(,(format nil "A constrained access cannot be reconstrained"
			   ))
		'((lrmref "LRM" (lrmsec 3 7 2) (lrmpar 15 nil))
		  (lrmref "LRM" (lrmsec 3 7 2) (lrmpar 14 nil))
		  ))))

  (def_sem_error_recovery incomplete_type
    (lambda (l)
        (sgripe `(,(format nil "Incorrect use of an incomplete type"
			   ))
		'((lrmref "LRM" (lrmsec 3 3 1) (lrmpar 10 nil))
		  (lrmref "LRM" (lrmsec 3 8 1) (lrmpar 6 nil))
		  ))))

  (def_sem_error_recovery must_have_a_parameter 
    (lambda (l)
        (sgripe `(,(format nil "The attribute call, ~A, must have an argument"
			   (car l)))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))
		  ))))

  (def_sem_error_recovery no_arg_allowed 
    (lambda (l)
        (sgripe `(,(format nil "The attribute call, ~A, cannot have an argument"
			   (car l)))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))
		  ))))

   (def_sem_error_recovery prefix_cannot_be_a_type 
    (lambda (l)
        (sgripe `(,(format nil "The attribute call, ~A, cannot have a type as a prefix "
			   (car l) ))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))
		  ))))

  (def_sem_error_recovery cant_constrain_an_access
    (lambda (l)
        (sgripe `(,(format nil "Access types cannot be constrained in a subtype indication"))
		'((lrmref "LRM" (lrmsec 3 8 3) (lrmpar 4 nil))
		  (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 8)))
		)))

  (def_sem_error_recovery not_static_choice
    (lambda (l)
        (sgripe `(,(format nil "The simple expressions or discrete ranges provided as a choice in a variant part of a record (on line ~D) were not static." (car l))) 
		'((lrmref "LRM" (lrmsec 3 7 3) (lrmpar 4 nil))
		  (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 8)))
		)))

   (def_sem_error_recovery illegal_name_for_disc
    (lambda (l)
        (sgripe `(,(format nil "An illegal name for a discriminant was used in a discriminant constraint"))
		'((lrmref "LRM" (lrmsec 3 7 2) (lrmpar 4 nil))
		  (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 8)))
		)))

  (def_sem_error_recovery non_disc_in_disc_const
    (lambda (l)
        (sgripe `(,(format nil "The non_discriminant, ~A, was specified in the discriminant constraint" (car l)))
		'((lrmref "LRM" (lrmsec 3 7 2) (lrmpar 4 nil))
		  (lrmref "LRM" (lrmsec 3 7 3) (lrmpar 6 8)))
		)))

  (def_sem_error_recovery all_or_none_of_discs_default
    (lambda (l)
        (sgripe `(,(format nil "All or none of the discriminant of a record must have a default"))
		'((lrmref "LRM" (lrmsec 3 7 1) (lrmpar 4 nil))
		  (lrmref "LRM" (lrmsec 3 7 1) (lrmpar 11 nil)))
		)))

   (def_sem_error_recovery disc_not_dscrt
    (lambda (l)
        (sgripe `(,(format nil "A discriminant of a record must be of a discrete type"))
		'((lrmref "LRM" (lrmsec 3 7 1) (lrmpar 1 nil))
		  (lrmref "LRM" (lrmsec 3 7 1) (lrmpar 11 nil)))
		)))

  (def_sem_error_recovery illegal_use_of_disc
    (lambda (l)
        (sgripe `(,(format nil "Illegal use of a discriminant variable in a record declaration"))
		'((lrmref "LRM" (lrmsec 3 7 1) (lrmpar 6 nil))
		  (lrmref "LRM" (lrmsec 3 7 1) (lrmpar 11 nil)))
		)))

  (def_sem_error_recovery arg_must_be_static
    (lambda (l)
        (sgripe `(,(format nil "In the attribute, ~A, the index range argument must be static and universal" (car l)))
		'((lrmref "LRM" (lrmsec 3 6 2) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 3 6 2) (lrmpar 13 nil)))
		)))

  (def_sem_error_recovery index_out_range
    (lambda (l)
        (cond ((> (caddr l) 0)
	       (sgripe `(,(format nil "In the attribute, ~A, the index range argument, ~D, was not in the range 1..~D" (car l) (cadr l ) (caddr l)))
		'((lrmref "LRM" (lrmsec 3 6 2) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 3 6 2) (lrmpar 13 nil)))
		)))))

  (def_sem_error_recovery empty_parens_not_allowed
    (lambda (l)
        (sgripe `(,(format nil "Empty parentheses are not allowed in aggregates, constraints or parenthesized expressions"))
		)))

   (def_sem_error_recovery warn_attr_not_implemted
    (lambda (l)
        (sgripe `(,(format nil "Warning!! The attribute call, ~A, is not yet implemented"
			   (car l)))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))
		  ))))

  (def_sem_error_recovery attribute_needs_type
    (lambda (l)
        (sgripe `(,(format nil "The attribute call, ~A, needs a prefix of ~A"
			   (car l) (cadr l)))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))
		  ))))

  (def_sem_error_recovery probably_missing_tick
    (lambda (l)
        (sgripe `(,(format nil "A quote was probably omitted in the qualified allocator"))
		'((lrmref "LRM" (lrmsec 4 8 nil) (lrmpar 2 nil))
		  (lrmref "LRM" (lrmsec 4 8 nil) (lrmpar 14 nil))
		  ))))


  (def_sem_error_recovery attribute_failure_type_nil 
    (lambda (l)
        (sgripe `(,(format nil "The attribute call was not legal for some reason"
			   ))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))
		  ))))

  (def_sem_error_recovery attribute_failure 
    (lambda (l)
        (sgripe `(,(format nil "The attribute call, ~A, was not legal for some reason"
			   (car l)))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))
		  ))))

  (def_sem_error_recovery qualify_types_not_compatible
    (lambda (l)
        (sgripe `(,(format nil "The operand of the qualified expression is type_incompatible with the qualifying type mark ~A"
			   (car l)))
		'((lrmref "LRM" (lrmsec 4 7 nil) (lrmpar 3 nil))
		  (lrmref "LRM" (lrmsec 4 7 nil) (lrmpar 4 nil))))))

  (def_sem_error_recovery not_legal_component
    (lambda (l)
        (sgripe `(,(format nil "~A is not a record component" 
			   (car l)))
		'((lrmref "LRM" (lrmsec 4 1 3) (lrmpar 7 nil))))))

  (def_sem_error_recovery cannot_take_image_of_this_type
    (lambda (l)
        (sgripe `(,(format nil "You cannot take the image attribute of a ~A type"
			   (car l)))
		'((lrmref "LRM" (lrmsec A nil nil) (lrmpar nil nil))))))

  (def_sem_error_recovery cannot_rename_an_array_element
    (lambda (l)
        (sgripe `(,(format nil "The renaming of array elements of an array (~A) is not supported."
			   (car l)))
		)))

   (def_sem_error_recovery array_index_cannot_be_a_type
    (lambda (l)
        (sgripe `(,(format nil "The type, ~A, cannot be used as a subscript to an array."
			   (car l)))
         '((lrmref "LRM" (lrmsec 4 1 1) (lrmpar 3 nil))
	   (lrmref "LRM" (lrmsec 4 1 1) (lrmpar 5 nil)))
     )))

   (def_sem_error_recovery range_in_for_must_be_a_discrete_type
    (lambda (l)
        (sgripe `(,(format nil "The expression provided cannot be used as a range."))   
         '((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 3 5 1) (lrmpar 6 nil)))
     )))

  (def_sem_error_recovery erroneous_non_range_expression
    (lambda (l)
        (sgripe `(,(format nil "The expression provided cannot be used as a range."))   
         '((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 3 5 1) (lrmpar 6 nil)))
     )))

  (def_sem_error_recovery erroneous_range
    (lambda (l)
        (sgripe `(,(format nil "The expression provided cannot be used as a range."))   
         '((lrmref "LRM" (lrmsec 3 5 nil) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 3 5 1) (lrmpar 6 nil)))
     )))

  (def_sem_error_recovery use_without_with_at_top_level
    (lambda (l)
        (sgripe `(,(format nil "It is illegal to have a !"use clause!" as a context clause without an accompanying !"with clause!"."))
         '((lrmref "LRM" (lrmsec 10 1 1) (lrmpar 2 3))
	   (lrmref "LRM" (lrmsec 10 1 1) (lrmpar 10 nil)))
     )))

   (def_sem_error_recovery missing_matching_mandatory_name
    (lambda (l)
        (sgripe `(,(format nil "The loop or block named with the simple name ~A must end with that simple name."
			   (car l)))
         '((lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 3 nil))
	   (lrmref "LRM" (lrmsec 5 5 nil) (lrmpar 12 nil)))
     )))

  (def_sem_error_recovery not_user_definable_operator
    (lambda (l)
        (sgripe `(,(format nil "The alleged function designator !"~A!" does not represent one of the allowable user redefinable operators."
			   (car l)))
         '((lrmref "LRM" (lrmsec 6 7 nil) (lrmpar 1 nil))
	   (lrmref "LRM" (lrmsec 6 7 nil) (lrmpar 7  nil)))
     )))

  (def_sem_error_recovery null_raise_not_in_exception_handler
    (lambda (l)
        (sgripe `("A 'raise' statement without an exception name is only allowed in an exception handler.")
         '((lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 3 nil))
	   (lrmref "LRM" (lrmsec 11 3 nil) (lrmpar 4 nil)))
     )))

   (def_sem_error_recovery proc_or_entry_in_exp
    (lambda (l)
        (sgripe `(,(format nil "The procedure or entry call to ~a cannot be used as an expression."
			   (car l)))
         '((lrmref "LRM" (lrmsec 4 4 nil) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 4 5 nil) (lrmpar 8 nil)))
     )))


   (def_sem_error_recovery only_packages_allowed_in_use_clauses
    (lambda (l)
        (sgripe `("The name appearing in this 'use' clause is not the name of a package.")
         '((lrmref "LRM" (lrmsec 8 4 nil) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 8 4 nil) (lrmpar 9 11)))
     )))

  (def_sem_error_recovery unconstrained_array_declaration
    (lambda (l)
        (sgripe `("An unconstrained array type cannot be used in an array object declaration") 
         '((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 5 nil))
	   (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 13)))
     )))

   (def_sem_error_recovery cant_find_matching_spec_for_package_body
    (lambda (l)
        (sgripe `("There is no package specification for this package body.") 
         '((lrmref "LRM" (lrmsec 7 1 nil) (lrmpar 1 nil))
	   (lrmref "LRM" (lrmsec 7 3 nil) (lrmpar 5 nil)))
     )))

   (def_sem_error_recovery character_literal_has_funny_length
    (lambda (l)
      (sgripe
	`(,(format
	      nil
	      "The character literal ~a is illegal: a character literal can be made up of only one character."
	     (car l)))
	'((lrmref "LRM" (lrmsec 2 5 nil) (lrmpar 1 nil))
	  (lrmref "LRM" (lrmsec 2 5 nil) (lrmpar 3 nil)))
	)))

   (def_sem_error_recovery unconvertable_types
    (lambda (l)
        (sgripe `("The operand of this type-conversion operation is type-incompatible with the operation.")
         '((lrmref "LRM" (lrmsec 4 6 nil) (lrmpar 3 nil))
	   (lrmref "LRM" (lrmsec 4 6 nil) (lrmpar 17 20)))
     )))

  (def_sem_error_recovery non_constant_unconstrained_array_type
    (lambda (l)
        (sgripe `("An unconstrained array cannot be constrained with an aggregate or a string literal.")
        '((lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 5 nil))
	   (lrmref "LRM" (lrmsec 3 6 nil) (lrmpar 11 13))) 
     )))

   (def_sem_error_recovery attempt_to_constrain_non_array_type
    (lambda (l)
        (sgripe `("Index ranges cannot be used to constrain non-array types.")
         '((lrmref "LRM" (lrmsec 3 6 1) (lrmpar 1 nil))
	   (lrmref "LRM" (lrmsec 3 6 1) (lrmpar 12 nil)))
     )))

   (def_sem_error_recovery no_return_statement_in_function
    (lambda (l)
        (sgripe `(,(format nil "There is no 'return' statement in the function ~a."
			   (car l)))
         '((lrmref "LRM" (lrmsec 4 8 nil) (lrmpar 1 2))
	   (lrmref "LRM" (lrmsec 4 8 nil) (lrmpar 14 nil)))
     )))

   (def_sem_error_recovery non_access_recipient_for_allocator
    (lambda (l)
        (sgripe `("An allocator cannot be assigned to a non-access type object.")
         '((lrmref "LRM" (lrmsec 4 8 nil) (lrmpar 1 2))
	   (lrmref "LRM" (lrmsec 4 8 nil) (lrmpar 14 nil)))
     )))

   (def_sem_error_recovery cant_mix_aggies_with_privates
    (lambda (l)
        (sgripe `("Since this variable is of a private type, it cannot be assigned an aggregate value.")
         '((lrmref "LRM" (lrmsec 7 4 2) (lrmpar 1 5))
	   (lrmref "LRM" (lrmsec 7 4 2) (lrmpar 13 nil)))
     )))

   

   (def_sem_error_recovery actual_parameter_out_formal_not_assignable
    (lambda (l)
        (sgripe `(,(format nil "The actual parameter provided for the in out or out formal parameter ~a is not a variable that may be updated."
			   (car l)))
         '((lrmref "LRM" (lrmsec 6 2 nil) (lrmpar 4 5))
	   (lrmref "LRM" (lrmsec 6 2 nil) (lrmpar 7 nil)))
     )))

   (def_sem_error_recovery def_const_must_be_private
    (lambda (l)
        (sgripe `("Since this constant is not a deferred constant, it must be initialized when it is declared.")
         '((lrmref "LRM" (lrmsec 7 4 nil) (lrmpar 4 nil))
	   (lrmref "LRM" (lrmsec 7 4 nil) (lrmpar 5 6)))
     )))

   (def_sem_error_recovery no_generic_spec
    (lambda (l)
        (sgripe `("There is no generic declaration for this generic object.")
         '((lrmref "LRM" (lrmsec 12 nil  nil) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 12 1 nil) (lrmpar 8 nil)))
     )))

   (def_sem_error_recovery func_call_on_lhs_of_assign
    (lambda (l)
        (sgripe `("Since this function call does not return an access object, it cannot be assigned a value.")
         '((lrmref "LRM" (lrmsec 5 2  nil) (lrmpar 9 nil))
	   (lrmref "LRM" (lrmsec 5 2 nil) (lrmpar 5 6)))
     )))

   (def_sem_error_recovery not_the_same_profile_in_rename
    (lambda (l)
        (sgripe `(,(format nil "In this renaming operation, the old and new profiles for ~a do not match."
		  (car l)))
         '((lrmref "LRM" (lrmsec 8 5  nil) (lrmpar 7 nil))
	   (lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 10 12)))
     )))

   (def_sem_error_recovery undeclared_proc_in_rename
    (lambda (l)
        (sgripe `("The procedure being renamed is undeclared or not visible.")
         '((lrmref "LRM" (lrmsec 8 5  nil) (lrmpar 7 nil))
	   (lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 10 12)))
     )))

   (def_sem_error_recovery undeclared_func_in_rename
    (lambda (l)
        (sgripe `("The function being renamed is undeclared or not visible.")
         '((lrmref "LRM" (lrmsec 8 5  nil) (lrmpar 7 nil))
	   (lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 10 12)))
     )))

   (def_sem_error_recovery ambiguous_func_in_rename
    (lambda (l)
        (sgripe `(,(format nil "There is more than one visible function that matches the rename for ~a." (car l)))
         '((lrmref "LRM" (lrmsec 8 5  nil) (lrmpar 7 nil))
	   (lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 10 12)))
     )))

   (def_sem_error_recovery ambiguous_proc_in_rename
    (lambda (l)
        (sgripe `(,(format nil "There is more than one visible procedure that matches the rename for ~a." (car l)))
         '((lrmref "LRM" (lrmsec 8 5  nil) (lrmpar 7 nil))
	   (lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 10 12)))
     )))

   (def_sem_error_recovery type_mark_expected
    (lambda (l)
        (sgripe `("A type mark was expected.")
         '((lrmref "LRM" (lrmsec 3 3 2) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 3 3 2) (lrmpar 10 nil)))
     )))

   (def_sem_error_recovery must_have_at_least_one_param
    (lambda (l)
        (sgripe `("There must be at least one parameter inside this subprogram call's parentheses.")
         '((lrmref "LRM" (lrmsec 6 4  nil) (lrmpar 2 nil))
	   (lrmref "LRM" (lrmsec 6 4 2) (lrmpar 3 4)))
     )))

   (def_sem_error_recovery exp_must_be_integer_type_for_size
    (lambda (l)
        (sgripe `("The 'size' expression in a length clause must be of an integer type.")
         '((lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 5 nil))
	   (lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 16 nil)))
     )))

   (def_sem_error_recovery exp_must_be_static_in_length_size_clause
    (lambda (l)
        (sgripe `("The 'size' expression in a length clause must be static.")
         '((lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 5 nil))
	   (lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 16 nil)))
     )))

   (def_sem_error_recovery exp_must_be_integer_type_for_storage_size
    (lambda (l)
        (sgripe `("The 'storage_size' expression in a length clause must be of an integer type.")
         '((lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 8 10))
	   (lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 16 nil)))
     )))

   (def_sem_error_recovery type_must_be_access_or_task_type
    (lambda (l)
        (sgripe `("The type of 'storage_size' in a length clause must be either an access or a task type.")
         '((lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 8 10))
	   (lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 16 nil)))
     )))

   (def_sem_error_recovery exp_must_be_real_type_for_small
    (lambda (l)
        (sgripe `("The 'small' expression in a length clause must be of a real type.")
         '((lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 12 nil))
	   (lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 16 nil)))
     )))

   (def_sem_error_recovery exp_must_be_static_in_length_small_clause
    (lambda (l)
        (sgripe `("The 'small' expression in a length clause must be static.")
         '((lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 12 nil))
	   (lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 16 nil)))
     )))

   (def_sem_error_recovery not_a_legal_attribute_in_length_clause
    (lambda (l)
        (sgripe `("This attribute may not be used in a length clause.")
         '((lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 3 nil))
	   (lrmref "LRM" (lrmsec 13 2 nil) (lrmpar 16 nil)))
     )))


   (def_sem_error_recovery incompat_generic_param_formal_dscrt
    (lambda (l)
        (sgripe `("The actual parameter provided for the generic formal discrete type parameter is not of a discrete type.")
         '((lrmref "LRM" (lrmsec 12 3 3) (lrmpar 1 nil)))
     )))

   (def_sem_error_recovery incompat_generic_param_formal_int
    (lambda (l)
        (sgripe `("The actual parameter provided for the generic formal integer type parameter is not of an integer type.")
         '((lrmref "LRM" (lrmsec 12 3 3) (lrmpar 1 nil)))
     )))

   (def_sem_error_recovery incompat_generic_param_formal_fixed
    (lambda (l)
        (sgripe `("The actual parameter provided for the generic formal fixed type parameter is not of a fixed type.")
         '((lrmref "LRM" (lrmsec 12 3 3) (lrmpar 1 nil)))
     )))

   (def_sem_error_recovery incompat_generic_param_formal_float
    (lambda (l)
        (sgripe `("The actual parameter provided for the generic formal float type is not of a floating-point type.")
         '((lrmref "LRM" (lrmsec 12 3 3) (lrmpar 1 nil)))
     )))
 
   (def_sem_error_recovery integer_codes_in_wrong_order
    (lambda (l)
        (sgripe `("The integer codes in this representation aggregate are in the wrong order.")
         '((lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 4 nil))
         (lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 5 nil)))
     )))

   (def_sem_error_recovery incorrect_name_in_aggregate
    (lambda (l)
        (sgripe `("One of the names in this representation aggregate does not match any name in its enumeration type.")
         '((lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 4 nil))
         (lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 5 nil)))
     )))

   (def_sem_error_recovery wrong_number_of_values_in_rep_clause
    (lambda (l)
        (sgripe `("This enumeration representation clause has the wrong number of values in its aggregate.")
         '((lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 4 nil))
         (lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 5 nil)))
     )))

   (def_sem_error_recovery cannot_disambiguate
    (lambda (l)
      (sgripe
	`(,(ct_format
	     nil
	     "The aggregate on line ~A cannot be disambiguated."
	     (source_region%linstart
	       (car l))))
	'((lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 4 nil))
	  (lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 5 nil))))))

   (def_sem_error_recovery cannot_normalize
    (lambda (l)
      (sgripe
	`(,(ct_format
	     nil
	     "The aggregate on line ~A cannot be normalized."
	     (source_region%linstart
	       (car l))))
	'((lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 4 nil))
	  (lrmref "LRM" (lrmsec 13 3 nil) (lrmpar 5 nil))))))

   (def_sem_error_recovery mix_namd_n_seq
    (lambda (l)
        (sgripe `("Array aggregates cannot use both named and positional associations.")
         '((lrmref "LRM" (lrmsec  4 3 2) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
     )))
   (def_sem_error_recovery bad_namd_aggregate
       (lambda(l)
	   (sgripe `("The type of a choice in the named aggregate does not match the type specified in its index list.")
	       '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 1 2))
		 (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 14 15))))))
    (def_sem_error_recovery illegal_assignment
    (lambda (l)
        (sgripe `("An error was encountered in an assignment statement.")
         '((lrmref "LRM" (lrmsec 5 2 nil) (lrmpar 2 nil))
         (lrmref "LRM" (lrmsec 5 2 nil ) (lrmpar 5 6)))
     )))

   (def_sem_error_recovery non_record_discriminated_type
    (lambda (l)
        (sgripe `("Discriminants can be provided only for record types.")
         '((lrmref "LRM" (lrmsec 3 7 1) (lrmpar 1 nil))
         (lrmref "LRM" (lrmsec 3 7 1 ) (lrmpar 11 nil)))
     )))

    (def_sem_error_recovery attribute_not_implemented
    (lambda (l)
        (sgripe `(,(format
		      nil
		      "The attribute ~a is not currently implemented."
		      (car l)))
         '((lrmref "LRM" (lrmsec A 1 nil) (lrmpar 1 nil))
         )
     )))

    (def_sem_error_recovery others_in_unconstrained_aggie
    (lambda (l)
        (sgripe `("The 'others' choice is not allowed in an unconstrained array aggregate.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 4 8))
         )
     )))


    (def_sem_error_recovery ret_type_not_compat
    (lambda (l)
        (sgripe `("The value computed in this 'return' statement is type-incompatible with the return type specified in the function's specification.")
         '((lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 5 nil))
         (lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 7 nil)))
     )))

    (def_sem_error_recovery ret_exp_expected
    (lambda (l)
        (sgripe `("The 'return' statement in this function does not include an expression to be returned as the value of the function.")
         '((lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 4 nil))
         (lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 7 nil)))
     )))


   (def_sem_error_recovery ret_exp_not_in_fun
    (lambda (l)
        (sgripe `("The 'return' statement in this procedure illegally includes an expression to be returned as the 'value' of the procedure.")
         '((lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 4 nil))
         (lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 7 nil)))
     )))

   (def_sem_error_recovery ret_st_in_package
    (lambda (l)
        (sgripe `("Package bodies may not contain 'return' statements.")
         '((lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 7 nil)))
     )))

   (def_sem_error_recovery ret_st_in_task
    (lambda (l)
        (sgripe `("Task bodies may not contain 'return' statements.")
         '((lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 5 8 nil) (lrmpar 7 nil)))
     )))  

   (def_sem_error_recovery unmatched_blocknames
    (lambda (l)
      (cond ((equal (car l) "")
	     (sgripe `(,(format nil "The starting name of the program block -- ~a -- does not match the name used in the block's 'end' statement -- ~a"
				(car l) (cadr l)))
		     '((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
		       (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil)))
		     ))
	    (t (sgripe `(,(format nil "The starting name of the program block does not match the name used in the block's 'end' statement -- ~a"
				  (cadr l)))
		       '((lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 2 nil))
			 (lrmref "LRM" (lrmsec 5 6 nil) (lrmpar 5 nil)))
		       )))))

  (def_sem_error_recovery ambig_subprog_ref
    (lambda (l)
        (sgripe `(,(format nil "The overloaded subprogram ~a referenced on line ~a is ambiguous."
			   (car l) (cadr l)))
         '((lrmref "LRM" (lrmsec 6 6  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 6 6 nil) (lrmpar 4 5)))
    )))					

  (def_sem_error_recovery bad_subprog_call
    (lambda (l)
        (sgripe `("This compilation unit contains incorrect subprogram calls.")
         '((lrmref "LRM" (lrmsec 6 4  nil) (lrmpar 2 nil))
         (lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 7 nil)))
    )))

  (def_sem_error_recovery body_already_spec
    (lambda (l)
        (sgripe `(,(format nil "More than one body has been specified for the subprogram ~a." (car l)))
         '((lrmref "LRM" (lrmsec 6 3  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 6 3 nil) (lrmpar 8 nil)))
    )))

  (def_sem_error_recovery mult_match_incomp_types
    (lambda (l)
        (sgripe `("No more than one type specification can be provided for an incomplete type declaration.")
         '((lrmref "LRM" (lrmsec 3 8 1) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 3 8 1) (lrmpar 6 nil)))
    )))

  (def_sem_error_recovery init_exp_wrong_type
    (lambda (l)
        (sgripe `("The type of this identifier's initializing expression is type-incompatible with the identifier.")
         '((lrmref "LRM" (lrmsec 3 2 1) (lrmpar 16 nil))
         (lrmref "LRM" (lrmsec 3 2 1) (lrmpar 19 20)))
    )))

  (def_sem_error_recovery lhs_not_assignable
    (lambda (l)
        (sgripe `("This object cannot be assigned a value.")
         '((lrmref "LRM" (lrmsec 6 6  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 6 6 nil) (lrmpar 4 5)))
    )))

  (def_sem_error_recovery types_not_assignable
    (lambda (l)
        (sgripe `("The value computed in this assignment statement is type-incompatible with the variable receiving the value." )
         '((lrmref "LRM" (lrmsec 5 2  nil) (lrmpar 1 nil))
         (lrmref "LRM" (lrmsec 5 2 nil) (lrmpar 5 nil)))
    )))

(def_sem_error_recovery not_bool_exp
    (lambda (l)
        (sgripe `("One of the expressions specifying the conditions of this conditional statement is not of a boolean type.")
         '((lrmref "LRM" (lrmsec 5 3  nil) (lrmpar 2 nil))
         (lrmref "LRM" (lrmsec 5 3 nil) (lrmpar 5 nil)))
    )))

  (def_sem_error_recovery ambig_id_ref
    (lambda (l)
        (sgripe `(,(format
		     nil
		     "The overloaded subprogram ~a is ambiguous."
		     (car l)))
         '((lrmref "LRM" (lrmsec 6 6  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 6 6 nil) (lrmpar 4 5)))
    )))

  (def_sem_error_recovery undecl_id
    (lambda (l)
        (sgripe `(,(format nil "The identifier ~a is undeclared." (car l)))
         '((lrmref "LRM" (lrmsec 8 2  nil) (lrmpar 1 nil))
         (lrmref "LRM" (lrmsec 8 2 nil) (lrmpar 1 nil)))
    )))

  (def_sem_error_recovery obj_expected
    (lambda (l)
        (sgripe `(,(format nil "A ~a was expected." (car l)))
         '((lrmref "LRM" (lrmsec 8 2 nil) (lrmpar 1 nil))
         (lrmref "LRM" (lrmsec   6 6 nil) (lrmpar 4 5)))
    )))

  (def_sem_error_recovery unmatch_keyword_param
    (lambda (l)
        (sgripe `("One of the keywords used in this subprogram call does not match a keyword in the subprogram's definition.")
         '((lrmref "LRM" (lrmsec 6 4  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 7 8)))
    )))

  (def_sem_error_recovery keyword_not_match_formal
    (lambda (l)
        (sgripe `(,(format nil "The named association ~a in this subprogram call does not match any parameter in the subprogram's specification." (car l)))
         '((lrmref "LRM" (lrmsec 5 2 nil) (lrmpar 2 nil))
         (lrmref "LRM" (lrmsec 5 2 nil) (lrmpar 5 nil)))
    )))

  (def_sem_error_recovery missing_actual
    (lambda (l)
        (sgripe `(,(format nil "This subprogram call has failed to specify an argument for the subprogram's ~a parameter." (car l)))
         '((lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 5 nil))
         (lrmref "LRM" (lrmsec 6 4 nil) (lrmpar 7 nil)))
    )))

  (def_sem_error_recovery type_mismatch_in_subprog
    (lambda (l)
        (sgripe `(,(format nil "The ~a argument passed to a subprogram is of a different type than that specified by the subprogram itself." (car l)))
         '((lrmref "LRM" (lrmsec 6 4 1) (lrmpar 1 nil))
         (lrmref "LRM" (lrmsec 6 4 2) (lrmpar 3 4)))
    )))

  (def_sem_error_recovery undecl_subprog
   (lambda (l)
    (cond ((null l)
	   (sgripe `("The subprogram is undeclared or not currently visible, or the actual parameters of the subprogram do not match any visible definition of the subprogram.")
		   '((lrmref "LRM" (lrmsec 6 3  nil) (lrmpar 3 nil))
		   (lrmref "LRM" (lrmsec 6 3 nil) (lrmpar 8 nil)))))
	  (t (sgripe `(,(format nil "The subprogram ~a is undeclared or not currently visible, or the actual parameters of the subprogram do not match any visible definition of the subprogram."
				(car l)))
		     '((lrmref "LRM" (lrmsec 6 3  nil) (lrmpar 3 nil))
		     (lrmref "LRM" (lrmsec 6 3 nil) (lrmpar 8 nil))))))))

  (def_sem_error_recovery ambig_func_ref
    (lambda (l)
        (sgripe `("The actual parameters of this subprogram do not match any visible definition of the subprogram.")
         '((lrmref "LRM" (lrmsec 6 6  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 6 6 nil) (lrmpar 4 5)))
    )))

  (def_sem_error_recovery types_not_consist_in_discrt_range
    (lambda (l)
        (sgripe `("The starting and ending bounds of a range specification must be of the same type.")
         '((lrmref "LRM" (lrmsec 3 6 1) (lrmpar 4 nil))
         (lrmref "LRM" (lrmsec 3 6 1) (lrmpar 12 14)))
    )))

  (def_sem_error_recovery no_def_block
    (lambda (l)
        (sgripe `(,(format nil "Cant find defining block of ~a." (car l)))
         '((lrmref "LRM" (lrmsec 8 3  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 8 3 nil) (lrmpar 8 nil)))
    )))

  (def_sem_error_recovery mult_def_occur
    (lambda (l)
        (sgripe `(,(format nil "There is more than one body-less specification for ~a." (car l)))
         '((lrmref "LRM" (lrmsec 6 3  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 6 3 nil) (lrmpar 8 nil)))
    )))

  (def_sem_error_recovery array_aggie_short
    (lambda (l)
        (sgripe `("This array aggregate does not define a complete array.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 11 nil))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
    )))

  (def_sem_error_recovery array_should_not_be_nested
    (lambda (l)
        (sgripe `("This array aggregate is illegally nested.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
    )))

  (def_sem_error_recovery el_out_of_order_aggie
    (lambda (l)
        (sgripe `("Named associations cannot precede positional associations in record aggregates.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 1 2))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
    )))

(def_sem_error_recovery uncon_aggie_short
    (lambda (l)
        (sgripe `("The aggregate initializing this unconstrained array has not defined the entire array.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 11 nil))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
    )))

  (def_sem_error_recovery uncon_aggie_has_others
    (lambda (l)
        (sgripe `("An aggregate for an unconstrained array cannot use the 'others' association.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 4 8))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
    )))

  (def_sem_error_recovery array_aggie_index_too_low
    (lambda (l)
        (sgripe `("One of the indices in this array aggregate is less than the lower bound of its array.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 9 nil))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
    )))

  (def_sem_error_recovery array_aggie_index_too_high
    (lambda (l)
        (sgripe `("One of the indices in this array aggregate is greater than the upper bound of its array.")
         '((lrmref "LRM" (lrmsec 4 3 2) (lrmpar 9 nil))
         (lrmref "LRM" (lrmsec 4 3 2) (lrmpar 13 16)))
    )))

  (def_sem_error_recovery rec_aggie_short
    (lambda (l)
        (sgripe `("This record aggregate does not define a complete record.")
         '((lrmref "LRM" (lrmsec 4 3 nil) (lrmpar 6 nil))
	   (lrmref "LRM" (lrmsec 4 3 1) (lrmpar 4 6)))
    )))

  (def_sem_error_recovery arg_to_scop_not_bool
    (lambda (l)
        (sgripe `("The argument to the short circuit operator in this conditional statement is not a boolean expression.")
         '((lrmref "LRM" (lrmsec 4 5  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 4 5  nil) (lrmpar 8 nil)))
    )))

  (def_sem_error_recovery unimp_pragma
    (lambda (l)
        (sgripe `(,(format nil
			  "The pragma ~A is not currently implemented."
			  (car l)))
         '((lrmref "LRM" (lrmsec 2 8  nil) (lrmpar 2 nil))
         (lrmref "LRM" (lrmsec 2 8 nil) (lrmpar 10 nil)))
    )))

  (def_sem_error_recovery rename_wrong_type
    (lambda (l)
        (sgripe `("An object of one type cannot be renamed with a name of a different, incompatible type.")
         '((lrmref "LRM" (lrmsec 8 5  nil) (lrmpar 4 nil))
         (lrmref "LRM" (lrmsec 8 5 nil) (lrmpar 10 nil)))
    )))

  (def_sem_error_recovery cant_find_mummy_in_subunit
    (lambda (l)
        (sgripe `("The parent unit specified in the 'separate' statement for this compilation unit cannot be found.")
         '((lrmref "LRM" (lrmsec 10 2  nil) (lrmpar 5 6))
         (lrmref "LRM" (lrmsec 10 2 1) (lrmpar 5 8)))
    )))

   (def_sem_error_recovery missing_label_for_goto
    (lambda (l)
        (sgripe `(,(format nil "The label ~a referenced by the 'goto' statement in line ~a is not directly in an enclosing construct for the goto."
		  (car l)
		  (source_region%linstart (cadr l))))
         '((lrmref "LRM" (lrmsec 5 9  nil) (lrmpar 1 nil))
         (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil)))		  
    )))

   (def_sem_error_recovery ambiguous_label_for_goto
    (lambda (l)
        (sgripe `(,(format nil "The label ~a in the 'goto' statement on line ~a has been used more than once."
			   (car l)
			   (source_region%linstart (cadr l))))
         '((lrmref "LRM" (lrmsec 5 9  nil) (lrmpar 1 nil))
         (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil)))		  
    )))

  (def_sem_error_recovery structure_entering_goto
    (lambda (l)
        (sgripe `(,(format nil "The goto statement on line ~a is illegally trying to transfer control into an embedded structure."
			   (car l)
			   (source_region%linstart (cadr l))))
         '((lrmref "LRM" (lrmsec 5 9  nil) (lrmpar 5 nil))
         (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil)))		  
    )))

  (def_sem_error_recovery preattribute_arg_is_of_the_wrong_type
       (lambda (l)
	       (sgripe `(,(format nil "The argument to the attribute ~a is type-incompatible with the prefix of the attribute."
				  (car l)))
		       '((lrmref "LRM" (lrmsec a nil  nil) (lrmpar nil nil))
			 )		  
		       )))

  (def_sem_error_recovery attribute_arg_is_of_the_wrong_type
       (lambda (l)
	       (sgripe `(,(format nil "The argument to the attribute ~a is type-incompatible with the attribute."
				  (car l)))
		       '((lrmref "LRM" (lrmsec a nil  nil) (lrmpar nil nil))
			 )		  
		       )))

  (def_sem_error_recovery goto_inside_a_program_unit
    (lambda (l)
        (sgripe `(,(format nil "The 'goto ~a' statement on line ~a and the label ~a are inside different compilation units: transfer of control between compilation units is illegal."
		(car l)
		(source_region%linstart (cadr l))
		(car l)))
         '((lrmref "LRM" (lrmsec 5 9  nil) (lrmpar 3 nil))
         (lrmref "LRM" (lrmsec 5 9 nil) (lrmpar 6 nil)))		  
    )))

  (def_sem_error_recovery cant_find_matching_stub_in_subunit
    (lambda (l)
        (sgripe `(,(format nil "The separate declaration ~a cannot be found."
			   (car l)))
		'((lrmref "LRM" (lrmsec 10 2 nil) (lrmpar 5 nil))
		  (lrmref "LRM" (lrmsec 10 2 1) (lrmpar 2 nil))))))

  (def_sem_error_recovery semgripe_undefined
    (lambda (l)
        (sgripe `(,(format nil "Internal error: the message ~a is undefined."
			   (car l)))
    )))

(defun semgripe (symbol &rest arglist)
  (let ((error 'semgripe_undefined))
    (cond ((get symbol 'sem_error)
	 (funcall (get symbol 'sem_error) arglist))
	(t (funcall (get error 'sem_error) (list symbol))))))

(defun semwarn (symbol &rest arglist)
  (let ((error 'semwarn_undefined))
    (cond ((get symbol 'sem_warning)
	 (funcall (get symbol 'sem_warning) arglist))
	(t (funcall (get error 'sem_warning) (list symbol)))))) 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;(init_ssemantics) sets up the error recovery routines etc.

(defun init_ssemantics()
    (%= *gripes_pending* nil)
)

;;; Checks that an identifier matches its partner at the top of the block.
;;; If the identifier is specified but does not match, an error is generated
;;; but the process of parsing and checking static semantics proceeds without
 ;;; interruption.
(defun matching_ident (defining matching) ;matches commenting names with block idents.
  (cond ((null matching) nil)			;If not specified, no problem!
	((and (consp defining)
	      (consp matching)
	      (eq (car defining) 'lex_ident)
	      (eq (car matching) 'lex_ident)
	      (equal (uplowlist (cadr defining)) (uplowlist (cadr matching))))
	 nil);If specified and matches...OK
	(t
;;;this is assistance_1
	 (let ((defname
		 (or
		   (and (consp defining)
			(eq (car defining) 'lex_ident)
			(implode (cadr defining)))
		   (and (diana_nodep defining)
			(diana_node_accepts_attributep defining 'lx_symrep)
			(implode (uplowlist
				   (cadr (diana_get defining 'lx_symrep)))))))
	       (matname
		 (or
		   (and (consp matching)
			(eq (car matching) 'lex_ident)
			(implode (cadr matching)))
		   (and (diana_nodep matching)
			(diana_node_accepts_attributep matching 'lx_symrep)
			(implode (uplowlist
				   (cadr (diana_get matching 'lx_symrep))))))))
	       (cond ((and (less-experience-than 'none 'ada) 
                (null *seen_assistance_1*))
						;Lets be kind to beginners.
;		(send interp-window ':expose-near '(:mouse))
		
		(ct_format *errout*
                  "~%If you name a block or loop~&~
                   in Ada, the closing name~&~
                   MUST MATCH   you used~&~
                   ~A~&~
                   as your name but closed~&~
                   with ~A~&~
                   which is different~&"
			defname
			matname)
		
		(setq *seen_assistance_1* t)
;		(send interp-window ':tyi)
;		(send interp-window ':bury)
               ))
	 (semgripe 'unmatched_blocknames defname
		  matname) nil))))

(def_ada_syntax pascal_brackets
    (pr_or nil oper_lbracket oper_rbracket))

(defun pascal_bracket_check () ;lookout for pascal hackers using square brackets!!!
  (let ((result nil))
    (cond ((setq result (parserd 'pascal_brackets))
;;;This is assistance_2
	   (cond ((and (greater-or-equal-experience-than 'none 'pascal)
                       (null *seen_assistance_2*))
;		  (send interp-window ':expose-near '(:mouse))
		  
		  (ct_format *errout*
			  "~%In Ada, arrays are written~&~
		   Using parentheses like this~&~
		   myarray( x , y )~&~
		   unlike the pascal~&~
                   myarray[ x , y ]~&.")
		  
		  (setq *seen_assistance_2* t)
		  (gripe '("Unlike Pascal, Ada uses parentheses for arrays.") nil)
;		  (send interp-window ':tyi)
;		  (send interp-window ':bury)
                 )
		 (t
		  (cond
		    ((greater-or-equal-experience-than 'none 'pascal)
		     (gripe
		       '("Unlike Pascal, Ada uses parentheses for arrays.") nil))
		    (t
		     (gripe
			'("A bracket was found where a parenthesis was expected.")
			`((lrmref "LRM" (lrmsec 4 1 1) (lrmpar 2 nil))
			  (lrmref "LRM" (lrmsec 4 1 1) (lrmpar 5 nil))))))))
	   (gripe '("A bracket was found where a parenthesis was expected.")
		  `((lrmref "LRM" (lrmsec 4 1 1) (lrmpar 2 nil))
		    (lrmref "LRM" (lrmsec 4 1 1) (lrmpar 5 nil))))
	   (list result)))))

(def_ada_syntax fortran_assignment
    (pr_or nil oper_equals))

(defun fortran_assignment_check () ;lookout for fortran hackers using = for :=
  (let ((result nil))
    (cond ((setq result (parserd 'fortran_assignment))
;;;This is assistance_3
	   (cond ((and (status feature tutor)
		       (greater-or-equal-experience-than 'none 'fortran) 
                       (null *seen_assistance_3*))
;                 (send interp-window ':expose-near '(:mouse))
		  
		  (ct_format *errout*
			  "~%In Ada, assignment uses~&~
                    the := operator as in ..~&~
                    A := B + C;~&~
                    unlike the fortran ..~&~
                    A=B+C~&~
                    this helps to avoid confusion~&~
                    with equality as in ..~&~
                    if A=B then ...~&.")
		  
		  (setq *seen_assistance_3* t)
		  (gripe '("Fortran assignment: in Ada assignment uses :=.") nil)
;		  (send interp-window ':tyi)
;		  (send interp-window ':bury)
                 )
		 (t
		  (cond ((greater-or-equal-experience-than 'none 'fortran)
			 (gripe '("Fortran assignment: in Ada assignment uses :=.")) nil)
			(t (gripe '("A colon was probably omitted in an assignment statement" nil))))))
	   (gripe '("A colon was probably omitted in an assignment statement.") nil)
	   (list result)))))

;;; Gripe from the lexical analyser.. treated as a parse error for now.
;;; refs is a list of possible references
       ;;;;;;;;
(defun la_gripe (m &optional refs)  ; Lexical analysis errors.
       ;;;;;;;;
  (let ((base 10.))
  (cond ((greaterp (plus *parse_errors* *semantic_errors*) *max_errors*)
	 (la_finale); print out gripes_pending and flush buffer
	 (*throw 'too_many_errors 'too_many_errors)))
  (%= *parse_errors* (add1 *_*))	  ;parse errors and lexical analyser
  (let ((errorref nil))
  (cond ((null refs))
	(t (%= errorref
	       (cons (format nil "    Description: ~A" (printref (car refs) nil))
		     (mapcar '(lambda (x)
				(format nil
					"    Example:     ~A"
					(printref x nil)))
			     (cdr refs))))))
  (%= *gripes_pending* (cons (list la_linpos (cons "Lexical Error:"
						   (append m errorref))) *_*)))))

;;; Gripe for a semantic error, increments the number of semantic errors.
       ;;;;;;
(defun sgripe(l &optional refs)		; l is an error message.
       ;;;;;;

  (cond ((greaterp (plus *parse_errors* *semantic_errors*) *max_errors*)
	 (la_finale); print out gripes_pending and flush buffer
	 (*throw 'too_many_errors 'too_many_errors)))
  (%= *semantic_errors* (add1 *_*))
  (let (( errorref nil))
  (cond ((null refs))
	(t (%= errorref
	       (cons (format nil "    Description: ~A" (printref (car refs) nil))
		     (mapcar '(lambda (x)
				(format nil
					"    Example:     ~A"
					(printref x nil)))
			     (cdr refs))))))
  (%= *gripes_pending* (cons (list la_linpos (cons "Semantic Error:"
						   (append l errorref))) *_*))))

;;; Semantic warning
(defun swarn(l &optional refs)		; l is an error message.
       ;;;;;;

  (let (( errorref nil))
  (cond ((null refs))
	(t (%= errorref
	       (cons (format nil "    Description: ~A" (printref (car refs) nil))
		     (mapcar '(lambda (x)
				(format nil
					"    Example:     ~A"
					(printref x nil)))
			     (cdr refs))))))
  (%= *gripes_pending* (cons (list la_linpos (cons "Semantic warning:"
						   (append l errorref))) *_*))))
    
;;; Gripe for a error, increments the number of parse errors.
       ;;;;;
(defun gripe(l &optional refs)			; l is an error message.
       ;;;;;

    (cond ((greaterp (plus *parse_errors* *semantic_errors*) *max_errors*)
	   (la_finale); print out gripes_pending and flush buffer
	      (*throw 'too_many_errors 'too_many_errors)))
    (%= *parse_errors* (add1 *_*))
    (let ((errorref nil))
    (cond ((null refs))
	(t (%= errorref
	       (cons (format nil "    Description: ~A" (printref (car refs) nil))
		     (mapcar '(lambda (x)
				(format nil
					"    Example:     ~A"
					(printref x nil)))
			     (cdr refs))))))
    (%= *gripes_pending* (cons (list la_linpos (cons "Syntax Error:"
						   (append l errorref))) *_*))))

#|(defun generic_gripe(l)			; l is an error message.
    (cond ((atom (car l))
	      (ct_terpri *errout*)
              (ct_princ "!"" *errout*)
	      (ct_princ *path* *errout*)
              (ct_princ "!", line " *errout*)
	      (ct_princ (1- la_psrcpos) *errout*)
	      (ct_princ ":" *errout*)
	      (ct_princ "	" *errout*)
	      (mapc '(lambda(w)
			 (cond ((listp w)	
				   ;; piece of code spared due to
				   ;; nostalgia
#+lispm 	 	           (grind-top-level w 80 *errout*)
#+franz			 	   ($prpr w)
				   (ct_terpri *errout*))
			     ((stringp w)
				 (ct_terpri *errout*)
				 (ct_princ "	" *errout*)
				 (ct_princ w *errout*))
			     (t (ct_princ w *errout*)))
			 (ct_princ " " *errout*))
		  l)))
    (cond
	((not (eq *errout* *listout*))
	    (cond ((atom (car l))
		      (ct_terpri *listout*)
                      (ct_princ "!"" *listout*)
	   	      (ct_princ *path* *listout*)
                      (ct_princ "!", line " *listout*)
		      (ct_princ la_psrcpos *listout*)
		      (ct_princ ":" *listout*)
		      (ct_princ "	" *listout*)
		      (mapc '(lambda(w)
				 (cond ((listp w)	
					   ;; piece of code spared due to
					   ;; nostalgia
#+lispm			 		   (grind-top-level w 80 *listout*)
#+franz			 		   ($prpr w)
					   (ct_terpri *listout*))
				     ((stringp w)
					 (ct_terpri *listout*)
					 (ct_princ "	" *listout*)
					 (ct_princ w *listout*))
				     (t (ct_princ w *listout*)))
				 (ct_princ " " *listout*))
			  l)))))
)
|#
(defun generic_gripe(l)			; l is an error message.
  (let ((*nopoint t)
	(right-margin 80))
    (format *errout* "~%--------------------------------------------------------------------------------")
    (cond ((atom (car l))

	   ;;Only do this first line if the first thing in the list is non-null:
	   ;;this gives an escape hatch for not printing this line.

	   (cond ((car l)
		  (ct_format *errout* "~%| !"~A!", line ~A:"
		      *path*
		      (1- la_psrcpos)))

		 (t (setq l (cdr l))))
	   (mapc
	     '(lambda(w)
		(cond ((listp w)	
		       ;; piece of code spared due to
		       ;; nostalgia
		       #+lispm
		       (grind-top-level w right-margin *errout*)
		       #+franz
		       ($prpr w)
		       (ct_terpri *errout*))
		      ((stringp w)
		       (line-break-format right-margin *errout* "~%|     ~A" w))
		      (t (ct_princ w *errout*)))
		(ct_princ " " *errout*))
	     l)))
    (format *errout* "~%--------------------------------------------------------------------------------")
    (cond
      ((not (eq *errout* *listout*))
       (format *listout* "~%--------------------------------------------------------------------------------")
       (cond ((atom (car l))
	      (cond ((car l)
		  (ct_format *listout* "~%| !"~A!", line ~A:"
		      *path*
		      (1- la_psrcpos)))

		 (t (setq l (cdr l))))
	      (mapc
		'(lambda(w)
		   (cond ((listp w)	
			  ;; piece of code spared due to
			  ;; nostalgia
			  #+lispm
			  (grind-top-level w right-margin *listout*)
			  #+franz
			  ($prpr w)
			  (ct_terpri *listout*))
			 ((stringp w)
			  (line-break-format right-margin *listout* "~%|     ~A" w))
			 (t (ct_princ w *listout*)))
		   (ct_princ " " *listout*))
		l)))
       (format *listout* "~%--------------------------------------------------------------------------------")
       )))
  )



;;;New error message printing functions: jrm, 6/20/84
;;;Takes an error message consisting of a single string and prints it,
;;;breaking the line at column *RIGHT-MARGIN* and inserting the 
;;;appropriate header.

;;;LINE-BREAK-FORMAT takes arguments similar to FORMAT; it calls FORMAT to
;;;generate the string, uses GET-ATOMS-FROM-STRING to produce a list of
;;;the elements of the string, and then prints them, resetting the line
;;;when *RIGHT-MARGIN* is exceeded.

(defun line-break-format (right-margin dest &rest args)

    ;;STRING-TO-PRINT is the formatted result of the arguments;
    ;;LIST-OF-ATOMS is a list of the atoms in the resulting string.

  (let* ((string-to-print (apply 'format (cons nil args)))
	 (list-of-atoms (get-atoms-from-string string-to-print))
	 (line-header "~%|     ")
	 (length-of-line-header (string-length line-header))
	 (column-counter 0))

	;;For each item in the list...

    (loop with itemlength = 0
	  for item in list-of-atoms
	  do

	  ;;If this ITEM pushes us past RIGHT-MARGIN, do a terpri and
	  ;;insert the header stuff, and reset COLUMN-COUNTER.

	  (setq itemlength (string-length item))
	  (cond ((> (setq column-counter (+ column-counter itemlength 1))
		    right-margin)
		 (format dest line-header)
		 (setq column-counter (+ length-of-line-header itemlength))))

	  ;;Print ITEM regardless of whether a reset has taken place.
 
	  (format dest "~a " item)
	  )))

;;;GET-ATOMS-FROM-STRING: Given a string like "foo bar baz", return the
;;;list ("foo" "bar" "baz").  Note that WITH-INPUT-FROM-STRING won't work
;;;here, since the read gets the characters in upper case.

(defun get-atoms-from-string (str)
  (loop with item = nil
	and counter = -1

	;;Collect words out of STR with GET-NEXT-WORD until COUNTER is NIL.

	do (multiple-value (item counter)
		      (get-next-word str (1+ counter)))
	collect item
	until (null counter)
	))

;;;GET-NEXT-WORD: Get the next "word" (i.e., the next substring of characters
;;;up to the next space) in this string and return the "word" and the place
;;;where the next word begins.  If we hit the end of the string on this call,
;;;return the last word in the string and NIL.

(defun get-next-word (str counter)
  (let ((end-of-word (string-search #\space str counter)))
    (cond (end-of-word
	   (values (substring str counter end-of-word)
		   end-of-word))
	  (t (values (substring str counter) nil)))))

;;; eof
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


