Enter your search terms Submit search form
	Web pdp-10.trailing-edge.com

!	COPYRIGHT (C) DIGITAL EQUIPMENT CORPORATION 1986.
!	ALL RIGHTS RESERVED.
!
!	THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY  BE  USED  AND
!	COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH
!	THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE.   THIS  SOFTWARE  OR
!	ANY  OTHER  COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE
!	AVAILABLE TO ANY OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE
!	SOFTWARE IS HEREBY TRANSFERRED.
!
!	THE INFORMATION IN THIS SOFTWARE IS  SUBJECT  TO  CHANGE  WITHOUT
!	NOTICE  AND  SHOULD  NOT  BE CONSTRUED AS A COMMITMENT BY DIGITAL
!	EQUIPMENT CORPORATION.
!
!	DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF
!	ITS SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL.
!
! PATLANGSP.REQ

!++
! FACILITY:	PAT Parser
!
! ABSTRACT:
!
!	PATLANGSP.REQ defines the interface between the user of the
!	PAT Parser and the language independent portion of the parser.
!	This file is provided with the PAT parser package and provides
!	an example of a particular implementation of the interface
!	specification.
!
!	This file defines all of the language specific
!	interfaces needed by the language independent portion
!	of the parser.
!
!	Note everything in PATLANGSP.BLI is referenced via macros
!	in PATLANGSP.REQ.  As a result it is possible to redefine
!	the macros in this file to refer to routines in a number of
!	language specific modules.
!
!
!	THIS FILE MUST BE ALTERED TO USE WITH OTHER COMPILERS !
!
! ENVIRONMENT:	VAX/VMS user mode
!
! AUTHOR:  Harvey Alcabes, CREATION DATE:  18-Nov-80
!
! MODIFIED BY:
!
!	Charlie Mitchell, 12-Nov-1981 : VERSION X2-001
! 001 -	Use new PAT/BLISS interface.  Add misc. new interface macros.
!	Reorganize and document.  Move local recovery tuning to
!	PATLRTUNE.REQ.
!
! 002 - C. Richardson 25-May-84 Remove VMS dependencies.
!
!  253  Rename to DIUPATLANGSP.
!       Gregory A. Scott 1-Jul-86
!--

!
! INCLUDE FILES
!

require 'DIUPATREQPRO';

library 'BLI:XPORT';					! 002

library 'DIUPATDATA';

! 			IMPORTANT NOTE
!
! This file is language specific.  It defines an interface that must
! be implemented to use the language independent portion of the parser.
! Naming conventions have been adopted to help identify those declarations
! that define the interface:
!
!    o	Macros and literals that define the interface begin with
!	the prefix "LS_".  You must define these appropriately.
!
!    o	Macros and literals that do not define the interface begin
!	with "LSLOCAL_" or "TKN_".  There is no direct reference to them
!	in the language independent portion of the parser.  Thus, you
!	are free to delete them if you wish.
!
!    o	Global routines in PATLANGSP.REQ are prefixed with "PAT$LSLOCAL_".
!	They are not part of the interface, and they are not referenced
!	directly in the language independent portion of the parser.

! This file is divided into six sections, all of which are
! ***LANGUAGE SPECIFIC***
!
!   1.	Interface to lexical analyzer and lexical tokens.
!
!   2.	Terminal and non-terminal symbol interpretation.
!
!   3.	Action routine interface.
!
!   4.	Error message interface (local and scope recovery).
!
!   5.	Error message interface (global recovery).
!
!   6.  Other definitions.

!				Section 1
!
! Interface to lexical analyer and lexical tokens:
!
!   -	Call to lexical analyzer.
!
!   -	Obtain the text for a lexical token.
!
!   -	Dump a lexical token (debugging).
!
!   -	Lexical token interpretation.
!
!   -	Translation of source locator to line number and column
!	position.

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAR_GET_TOKEN			=	GETTOK %;		! 002
%FI								! 002

macro
    LS_GET_LEX_TOKEN =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LS_GET_LEX_TOKEN gets the next lexical token.
!	The lexical analyzer which it calls is expected to
!	store tokens in separate locations so that the parser
!	can manipulate several tokens at once.
!	Because only a few tokens are considered at once,
!	it is acceptable for the lexical analyzer to keep
!	a ring buffer of LS_LEX_RING_BUFFER_SIZE tokens 
!	(see below) and to reuse storage for old tokens.  
!
! FORMAL PARAMETERS:
!
!	NONE
!
! VALUE:
!
!	Returns a pointer to the new token.
!
!--

	begin

	external routine
	    PAR_GET_TOKEN;

	PAR_GET_TOKEN ()
	end
    %;

! 	The size of the lexical token ring buffer mentioned in
!	LS_GET_LEX_TOKEN is specified by the literal
!	LS_LEX_RING_BUFFER_SIZE.  Currently a value of 10 or
!	more is required.  (At the current time there is no
!	advantage to having the value be greater than 10.)

literal
    LS_LEX_RING_BUFFER_SIZE = 10;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_SAVE_TOKEN		=	SAVTOK %;		! 002
%FI								! 002

macro
    LS_SAVE_TOKEN (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LS_SAVE_TOKEN is used whenever an error is detected at the
!	very start of error recovery with a pointer to a 
!	lexical token.  (The current token when the error was 
!	detected.)  LS_SAVE_TOKEN must
!	save the token (including auxiliary information that is
!	associated with the token).  This is necessary because
!	the global recovery algorithm can skip an arbitrarily
!	large number of tokens (more than fit in the ring buffer
!	required by LS_GET_LEX_TOKEN).
!
!	After global error recovery has been completed but
!	before an error message is issued,
!	LS_RETURN_SAVED_TOKEN is called to return a pointer
!	to the saved token.  The saved token is then used
!	in constructing the error message:
!
!	    Found <description-of-saved-token> when expecting ...
!
!	Two consecutive calls are never made to LS_SAVE_TOKEN
!	without an intervening call to LS_RETURN_SAVED_TOKEN.
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR		pointer to token to save
!
! VALUE:
!
!	NONE
!--

	begin

	external routine
	    PAT$LSLOCAL_SAVE_TOKEN : novalue;

	PAT$LSLOCAL_SAVE_TOKEN (TOKEN_PTR);
	end
    %;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_RETURN_SAVED_TOKEN	=	RETTOK %;		! 002
%FI								! 002

macro
    LS_RETURN_SAVED_TOKEN =

!++
! FUNCTIONAL DESCRIPTION:
!
!	See LS_SAVE_TOKEN.
!	LS_RETURN_SAVED_TOKEN returns the token saved by LS_SAVE_TOKEN.
!
! FORMAL PARAMETERS:
!
!	NONE
!
! VALUE:
!
!	TOKEN_PTR
!--

	begin

	external routine
	    PAT$LSLOCAL_RETURN_SAVED_TOKEN;

	PAT$LSLOCAL_RETURN_SAVED_TOKEN ()
	end
    %;

%if PATBLSEXT_DEBUGGING
%then

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_DUMP_TOK		= DMPTOK %;			! 002
%FI								! 002

macro
    LS_DUMP_TOK (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LS_DUMP_TOK outputs the lexical token pointed to by TOKEN_PTR.
!	(Only called by debugging routines)
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Pointer to the lexical token which is to be dumped.
!
! VALUE:
!
!	NONE
!
!--

	begin

	external routine
	    PAT$LSLOCAL_DUMP_TOK : novalue;

	PAT$LSLOCAL_DUMP_TOK (TOKEN_PTR);
	end
    %;

%fi

! Interpretation of lexical tokens
!
! Given the address of a lexical token macros that follow must be
! able to return:
!
!   1.	The terminal symbol number that corresponds to the
!	terminal defined in the PAT grammar.
!
!   2.	A source locator.  This is intended to represent the
!	line number and column position of the token in the source.
!	The parser assumes that a BLISS value (32 bits on VAX,
!	16 on the -11) is allocated for a locator.  However, all
!	interpretation of the locator is done by language specific
!	macros in PATLANGSP.  Thus, the locator can be an encoded
!	value or a pointer.
!
!   3.	A string descriptor for the text (spelling) of identifiers
!	and literals.
!
!   4.	A boolean indicating a synthetic token (one created during
!	error recovery).  Note that semantics action routines should
!	be prepared to check this boolean.
!
!   5.	(optional)  A boolean indicating that a token is the first
!	one on a line.
!
! A structure definition follows for a lexical token.  Note that
! the TKN_* fields are not refered to directly in the language
! independent portion of the parser.  Rather, macros that follow
! return the values of particular fields.
!
! The structure of a lexical token is **LANGUAGE SPECIFIC**.
! Information which must be accessable for any language is indicated
! with "**" in the following comment

    $FIELD TKN_FIELDS =
    set

    TKN_BASE = [$SUB_BLOCK ()],			! Placeholder to indicate base of token--uses no storage
    TKN_TERM = [$INTEGER],			! **Terminal symbol number
    TKN_LOCATOR = [$INTEGER],			! **Encoded column and line in source
    TKN_TEXT = [$REF_DESCRIPTOR],		! 002 **Text in source - for literals
    						!   See macro LS_LEX_TEXT
    TKN_CLEAN_TEXT = [$REF_DESCRIPTOR],		! 002 Cleaned up source text - for operands
    TKN_COMMENTS = [$ADDRESS],			! List of comments that appeared between
    						! the last token (if any) and this token
    TKN_INTVALUE = [$INTEGER],			! Value (if integer)
    TKN_REALVALUE = [$ADDRESS],			! Pointer to vector containing
    						! value if (real number)
    TKN_START_LINE = [$BYTE],			! TRUE iff token is the first one on a line
    TKN_SYNTHETIC = [$BYTE]			! **TRUE if token was created by error recovery
    tes;
						! routines instead of lexical analyzer

literal
    TKN_SIZE = $FIELD_SET_SIZE*%upval;		! Size of lexical token (in BYTES)

macro
    TKN_STR =
	block [TKN_SIZE/%upval]
	field
	(TKN_FIELDS) %;

undeclare %quote
    $DESCRIPTOR;				! due to current xport problem

macro
    LS_TKN_SIZE =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Expands to the number of BYTES in a lexical token stucture
!
! FORMAL PARAMETERS:
!
!	NONE
!
!--

	TKN_SIZE %;

macro
    LS_LEX_TERM (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Returns the value of the terminal symbol number.
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	.TOKEN_PTR [TKN_TERM]
	end
    %;

macro
    LS_LEX_INTVALUE (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Returns the integer value of the terminal symbol.
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	.TOKEN_PTR [TKN_INTVALUE]
	end
    %;

macro
    LS_LEX_LOCATOR (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Returns the value of a source locator associated with a
!	lexical token.
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	.TOKEN_PTR [TKN_LOCATOR]
	end
    %;

macro
    LS_LEX_TEXT (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Returns the text (spelling) associated with a lexical token
!	(for identifiers and literals).
!
!	The parser expects to get the address of a VMS static string
!	descriptor.
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	.TOKEN_PTR [TKN_TEXT]
	end
    %;

%if PATBLSEXT_EXTRA_STACK_FIELD
%then

macro
    LS_LEX_EXTRA_INFO (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Returns extra info associated with lexical token that is
!	to be stacked on the parse stack.  (See PATBLSEXT.REQ.)
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	.TOKEN_PTR [TKN_COMMENTS]
	end
    %;

%fi

macro
    LS_LEX_START_LINE (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Returns a boolean indicating if a lexical token is the first
!	one on a line.  This macro is only used when trying to insert
!	an end-of-line token at the end of a line.
!
!	This macro should expand to FALSE for languages that don't
!	often have end-of-line tokens at the end of lines.
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	.TOKEN_PTR [TKN_START_LINE]
	end
    %;

macro
    LS_LEX_SYNTHETIC (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Returns a boolean indicating if a lexical token is synthetic
!	(was created by the error recovery routines).
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	.TOKEN_PTR [TKN_SYNTHETIC]
	end
    %;

macro
    LS_LEX_SET_TERM (TOKEN_PTR, TERMINAL) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Sets the field of TOKEN_PTR which contains its terminal symbol
!	to TERMINAL.  This is used when the parser is creating a
!	synthetic lexical token.
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!	TERMINAL	- Terminal symbol number
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	TOKEN_PTR [TKN_TERM] = TERMINAL
	end
    %;

macro
    LS_LEX_SET_SYNTHETIC (TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Sets the field of TOKEN_PTR which indicates that a lexical
!	token is synthetic to TRUE, meaning that it was created by
!	the error recovery routines.
!
!	In addition, if the locator is set to a value that indicates
!	a synthetic token, a better scope recovery error message
!	can be produced.  (See LSLOCAL_LOCATOR_IS_SYNTHETIC and
!	LS_ERROR_SCOPE_MATCH.)
!
! FORMAL PARAMETERS:
!
!	TOKEN_PTR	- Address of a pointer variable which contains
!			  the address of a lexical token.
!
!--

	begin

	map
	    TOKEN_PTR : ref TKN_STR;

	TOKEN_PTR [TKN_SYNTHETIC] = TRUE;
	TOKEN_PTR [TKN_LOCATOR] = LSLOCAL_SYNTHETIC_LOCATOR
	end
    %;

macro
    LSLOCAL_LOCATOR_IS_SYNTHETIC (SLOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LSLOCAL_LOCATOR_IS_SYNTHETIC has value TRUE if it can be
!	determined that a locator is associated with a synthetic
!	token.  (See LS_LEX_SET_SYNTHETIC and LS_ERROR_SCOPE_MATCH.)
!
! FORMAL PARAMETERS:
!
!	SLOC	- Source locator
!
! VALUE:
!
!	TRUE if synthetic; FALSE if not or if cannot determine.
!
!--

	begin
	(SLOC) eql LSLOCAL_SYNTHETIC_LOCATOR
	end
    %;


! Locator value that indicates a synthetic locator

literal

    LSLOCAL_SYNTHETIC_LOCATOR = 0;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAR_LINE_NUMBER			=	PARLNM %;		! 002
%FI								! 002

macro
    LS_LEX_LINE_NUMBER (SLOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LS_LEX_LINE_NUMBER converts a source locator to a line number.
!
! FORMAL PARAMETERS:
!
!	SLOC	- Source locator
!
! VALUE:
!
!	Line number extracted from source locator.
!
!--

	begin

	external routine
	    PAR_LINE_NUMBER;

	PAR_LINE_NUMBER (SLOC)
	end
    %;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAR_COLUMN_NUMBER		=	PARCNM %;		! 002
%FI								! 002

macro
    LS_LEX_COLUMN_NUMBER (SLOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LS_LEX_COLUMN_NUMBER converts a source locator to a column number.
!
! FORMAL PARAMETERS:
!
!	SLOC	- Source locator
!
! VALUE:
!
!	Column number extracted from source locator.
!
!--

	begin

	external routine
	    PAR_COLUMN_NUMBER;

	PAR_COLUMN_NUMBER (SLOC)
	end
    %;

!				Section 2
!
! Macros to interpret terminal and non-terminal symbols.
!
!
! LS_STOP_PARSING_NT--**LANGUAGE SPECIFIC**
!
! The parser stops when it does a reduction to the production with the
! left hand side of LS_STOP_PARSING_NT.
!
! PAT_SENTENCE_CD is automatically defined to be the first production
! in the grammar (the one containing GOALSY).

literal 					!***LANGUAGE SPECIFIC***
    LS_STOP_PARSING_NT = NT_ONE_OR_THE_OTHER;	! Stop when have seen this

macro
    LS_IS_EOF (SYMBOL_NUM) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Return TRUE if SYMBOL_NUM represents the end of a file,
!	FALSE otherwise
!
! FORMAL PARAMETERS:
!
!	SYMBOL_NUM
!
!--

	((SYMBOL_NUM) eql T_EOF) %;

macro
    LS_IS_IDENTIFIER (SYMBOL_NUM) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Return TRUE if SYMBOL_NUM represents an identifier,
!	FALSE otherwise
!
! FORMAL PARAMETERS:
!
!	SYMBOL_NUM
!
!--

	((SYMBOL_NUM) eql T_CDD_NAME) %;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_IS_RESERVED_WORD	=	RESWRD %;		! 002
%FI								! 002

macro
    LS_IS_RESERVED_WORD (SYMBOL_NUM) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Return TRUE if SYMBOL_NUM represents a terminal symbol
!	which is a reserved word, FALSE otherwise.
!
! FORMAL PARAMETERS:
!
!	SYMBOL_NUM
!
!--

	begin

	external routine
	    PAT$LSLOCAL_IS_RESERVED_WORD;

	PAT$LSLOCAL_IS_RESERVED_WORD (SYMBOL_NUM)
	end
    %;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_IS_NON_TERM		=	NONTRM %;		! 002
%FI								! 002

macro
    LS_IS_NON_TERM (SYMBOL_NUM) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Return TRUE if SYMBOL_NUM represents a non-terminal symbol,
!	FALSE otherwise
!
! FORMAL PARAMETERS:
!
!	SYMBOL_NUM
!
!--

	begin

	external routine
	    PAT$LSLOCAL_IS_NON_TERM;

	PAT$LSLOCAL_IS_NON_TERM (SYMBOL_NUM)
	end
    %;

macro
    LS_T_IDENTIFIER =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Language independent name for identifier token.
!
! FORMAL PARAMETERS:
!
!	NONE
!
!--

	T_CDD_NAME %;

macro
    LS_T_SEMICOLON =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Language independent name for end-of-line token.
!	If macro LS_LEX_START_LINE always returns false, then the value of
!	this macro is irrelevant.
!
! FORMAL PARAMETERS:
!
!	NONE
!
!--

	T_DOT %;

macro
    LS_T_ERRORMARK =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Language independent name for errormark token.
!
! FORMAL PARAMETERS:
!
!	NONE
!
!--

	T_ERRORMARK %;

!				Section 3
!
! Interface to action routines

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAR_ABST				=	PARABS %;	! 002
%FI								! 002

macro
    LS_REDUCE_ACTION (code, LEFT, RIGHT, SLOC, RIGHT_TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro is called by the parser when a reduction is
!	done for which a semantics action is specified.
!
!	The best way to understand these parameters is to run
!	the sample parser provided with the PAT package.  In the
!	sample parser, calls to this macro result in a display
!	of the parse stack and of the actual parameters of this
!	macro.
!
! FORMAL PARAMETERS:
!
!	CODE 		- A code indicating which action is to be performed
!			  (the action specified in the input to PAT).
!
!	LEFT		- The index into the parse stack corresponding
!			  to the left hand end of the "handle", i.e. the string
!			  of terminals and non-terminals corresponding to the
!			  right hand side of a production.
!
!			  Note that this stack index can be used to
!			  index a parallel semantics stack maintained
!			  by the semantics action routine.
!
!	RIGHT		- Similar to LEFT, but corresponding to the right hand
!			  end of the handle.
!
!	SLOC		- Source locator
!
!	RIGHT_TOKEN_PTR	- If the last symbol in the reduction is a terminal,
!			  this is a pointer to the token containing that
!			  symbol.  If it is a non-terminal then this value
!			  is undefined.
!
! VALUE:
!
!	MAY_BACKUP	- Boolean value; if TRUE, error recovery will
!			  be allowed to backup over this reduction
!
!--

	begin

	external routine
	    ACTION_RTN;		! Comment out when not using
!	    PAR_ABST;		! Comment out when not using

	local
	    status %BLISS32( : long);

! Comment out next line when not using sample semantics routine PAR_ABST.
!	status = PAR_ABST (code, LEFT, RIGHT, SLOC, RIGHT_TOKEN_PTR);
! Comment out next section when not using semantics action routines.
	IF .syntax_only
	    THEN status = TRUE
	    ELSE status = action_rtn (code, left, right, sloc,
		right_token_ptr, .result);
	.status
	end
    %;

macro
    LS_REDUCE_NO_ACTION (LEFT, RIGHT) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro is called by the parser when a production has
!	been recognized which does not have a semantics action
!	associated with it.
!
! FORMAL PARAMETERS:
!
!	LEFT	   	- Left stack position of handle
!
!	RIGHT	   	- Right stack position of handle
!
!
! VALUE:
!
!	MAY_BACKUP	- Boolean value; if TRUE, error recovery will
!			  be allowed to backup over this reduction
!
!--

	begin
	TRUE
	end
    %;

macro
    LS_LOCAL_RECOVERY_INFORM (BACKED_OVER_TOKEN, MAY_HAVE_BACKED_OVER_REDUCTIONS, POPPED_STACK,
	STACK_INDEX_AFTER, STACK_INDEX_BEFORE) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro is called by the parser when local error
!	recovery (which includes scope recovery) has been successfully
!	completed.  It provides information that the action routines can
!	use to compensate for the behavior of the error recovery.
!
! FORMAL PARAMETERS:
!
!	BACKED_OVER_TOKEN		- Boolean indicating whether or not the
!					  error recovery backed up over a
!					  lexical token
!
!	MAY_HAVE_BACKED_OVER_REDUCTION	- Boolean indicating whether the error
!					  recovery could have backed up over
!					  a reduction
!
!	POPPED_STACK			- Boolean indicating whether or not the
!					  parse stack was popped by error
!					  recovery
!
!	STACK_INDEX_AFTER		- Size of parse stack after error
!					  recovery.
!					  INVALID IF POPPED_STACK IS FALSE
!
!	STACK_INDEX_BEFORE		- Size of parse stack before error
!					  recovery.
!					  INVALID IF POPPED_STACK IS FALSE
!
! VALUE:
!
!	NONE
!
!--

	begin
	0
	end
    %;

macro
    LS_GLOBAL_RECOVERY_INFORM (STACK_INDEX_AFTER, STACK_INDEX_BEFORE) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro is called by the parser when global error
!	recovery has been performed.  It provides information that
!	the action routines can use to compensate for the behavior
!	of the error recovery.
!
! FORMAL PARAMETERS:
!
!	STACK_INDEX_AFTER	- Size of parse stack after error recovery
!
!
!	STACK_INDEX_BEFORE	- Size of parse stack before error recovery
!
!
! VALUE:
!
!	NONE
!
!--

	begin
	0
	end
    %;

!				Section 4
!
! Error message interface (internal errors, local and scope recovery
! errors)


macro
    LS_ERROR_PARSE_STACK_OVERFLOW (ERROR_LOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro is called if a parse stack overflow occurs.
!	(See later definition of LS_PARSE_STACK_SIZE.)
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator when overflow occured.
!

!++
	begin
	DEB_ASSERT (FALSE, 'Parse stack overflow')
	end
    %;

!   The next group of macros are used to specify the format of the
!   error messages for local and scope recovery.
!   They may be left intact or changed.


macro
    LS_ERROR_EOL (ERROR_LOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing an end-of-line
!	correction.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!--

	begin
	LSLOCAL_SYNTAX_ERRORM (ERROR_LOC, 'Inserted "." at the end of the previous line');
	end
    %;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_OUTPUT_TERM		=	OUTTRM %,		! 002
PAT$LSLOCAL_OUTPUT_TOKEN	=	OUTTOK %;		! 002
%FI								! 002

macro
    LS_ERROR_MERGE (ERROR_LOC, FIRST_TOKEN_PTR, SECOND_TOKEN_PTR, NEW_TERMINAL) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing a token merge correction.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	FIRST_TOKEN_PTR		- Pointer to first of the two merged tokens.
!
!	SECOND_TOKEN_PTR	- Pointer to second of the two merged tokens.
!
!	NEW_TERMINAL		- Terminal formed by merging the two tokens.
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TERM,
	    PAT$LSLOCAL_OUTPUT_TOKEN;

	LSLOCAL_SYNTAX_ERROR_START (ERROR_LOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, 'Merged ', PAT$LSLOCAL_OUTPUT_TOKEN (FIRST_TOKEN_PTR, 0));
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' and ', PAT$LSLOCAL_OUTPUT_TOKEN (SECOND_TOKEN_PTR, 1));
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' to form ', PAT$LSLOCAL_OUTPUT_TERM (NEW_TERMINAL, TRUE, 2));
	LSLOCAL_SYNTAX_ERROR_END (ERROR_LOC);
	end
    %;

macro
    LS_ERROR_ABBREV (ERROR_LOC, ID_TOKEN_PTR, RW_TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing an abbreviation
!	correction (a form of spelling correction).
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	ID_TOKEN_PTR		- Pointer to token containing identifier
!				  (which is the abbreviated reserved word).
!
!	RW_TOKEN_PTR		- Pointer to token containing reserved word
!				  (which had been abbreviated).
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TOKEN;

	local
	    ID_TOKEN;

	ID_TOKEN = ID_TOKEN_PTR;
	LSLOCAL_SYNTAX_ERROR_START (ERROR_LOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, 'Spelling corrector replaced abbreviation ');
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, LS_LEX_TEXT (ID_TOKEN));
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' with ', PAT$LSLOCAL_OUTPUT_TOKEN (RW_TOKEN_PTR, 0));
	LSLOCAL_SYNTAX_ERROR_END (ERROR_LOC);
	end
    %;

macro
    LS_ERROR_SPELL (ERROR_LOC, ID_TOKEN_PTR, RW_TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing a spelling correction.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	ID_TOKEN_PTR		- Pointer to token containing identifier
!				  (which is the misspelled reserved word).
!
!	RW_TOKEN_PTR		- Pointer to token containing the reserved word
!				  (which had been misspelled).
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TOKEN;

	LSLOCAL_SYNTAX_ERROR_START (ERROR_LOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, 'Spelling corrector replaced ');
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, PAT$LSLOCAL_OUTPUT_TOKEN (ID_TOKEN_PTR, 0));
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' with ', PAT$LSLOCAL_OUTPUT_TOKEN (RW_TOKEN_PTR, 1));
	LSLOCAL_SYNTAX_ERROR_END (ERROR_LOC);
	end
    %;

macro
    LS_ERROR_SUBST (ERROR_LOC, INIT_TOKEN_PTR, NEW_TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing a token
!	substitution correction.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	INIT_TOKEN_PTR		- Pointer to token containing initial token
!				  (which is being replaced).
!
!	NEW_TOKEN_PTR		- Pointer to token containing new token
!				  (which is being inserted in place of
!				  INIT_TOKEN_PTR).
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TERM,
	    PAT$LSLOCAL_OUTPUT_TOKEN;

	local
	    NEW;				! Need pointer variable to call LS_LEX_TERM

	NEW = NEW_TOKEN_PTR;
	LSLOCAL_SYNTAX_ERROR_START (ERROR_LOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, 'Replaced ', PAT$LSLOCAL_OUTPUT_TOKEN (INIT_TOKEN_PTR, 0));
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' with ', PAT$LSLOCAL_OUTPUT_TERM (LS_LEX_TERM (NEW), TRUE, 1))
	;
	LSLOCAL_SYNTAX_ERROR_END (ERROR_LOC);
	end
    %;

macro
    LS_ERROR_INSERT (ERROR_LOC, INSERTED_TOKEN_PTR, FOLLOWING_TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing an insertion correction.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	INSERTED_TOKEN_PTR	- Pointer to token containing inserted token.
!
!	FOLLOWING_TOKEN_PTR	- Pointer to token containing token following
!				  inserted token.
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TERM,
	    PAT$LSLOCAL_OUTPUT_TOKEN;

	local
	    INSERTED;				! Need pointer variable to call LS_LEX_TERM

	INSERTED = INSERTED_TOKEN_PTR;
	LSLOCAL_SYNTAX_ERROR_START (ERROR_LOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, 'Inserted ',
	    PAT$LSLOCAL_OUTPUT_TERM (LS_LEX_TERM (INSERTED),
		TRUE, 0));
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' before ', PAT$LSLOCAL_OUTPUT_TOKEN (FOLLOWING_TOKEN_PTR, 1));
	LSLOCAL_SYNTAX_ERROR_END (ERROR_LOC);
	end
    %;

macro
    LS_ERROR_DELETED (ERROR_LOC, DELETED_TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing an deletion correction.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	DELETED_TOKEN_PTR	- Pointer to token containing deleted token.
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TOKEN;

	local
	    DELETED;				! Need pointer variable to call LS_LEX_LOCATOR

	DELETED = DELETED_TOKEN_PTR;
	LSLOCAL_SYNTAX_ERRORM (LS_LEX_LOCATOR (DELETED), 'Unexpected ',
	    PAT$LSLOCAL_OUTPUT_TOKEN (DELETED_TOKEN_PTR, 0), ' deleted');
	end
    %;

macro
    LS_ERROR_SCOPE_NO_MATCH (ERROR_LOC, CLOSER_TEXT, FOLLOWING_TOKEN_PTR) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing a scope recovery
!	correction for which no matching symbol was provided for the closer.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	CLOSER_TEXT		- String descriptor to text describing the
!				  inserted scope closer.
!
!	FOLLOWING_TOKEN_PTR	- Pointer to token containing token following
!				  inserted closer.
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TOKEN;

	LSLOCAL_SYNTAX_ERROR_START (ERROR_LOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, 'Inserted ', CLOSER_TEXT);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' before ', PAT$LSLOCAL_OUTPUT_TOKEN (FOLLOWING_TOKEN_PTR, 0));
	LSLOCAL_SYNTAX_ERROR_END (ERROR_LOC);
	end
    %;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_LOC_TEXT		=	LOCTXT %;		! 002
%FI								! 002

macro
    LS_ERROR_SCOPE_MATCH (ERROR_LOC, CLOSER_TEXT, MATCHING_SYMBOL, MATCH_LOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro writes an error message describing a scope recovery
!	correction for which a matching symbol was provided for the closer.
!
! FORMAL PARAMETERS:
!
!	ERROR_LOC		- Source locator of error.
!
!	CLOSER_TEXT		- String descriptor to text describing the
!				  inserted scope closer.
!
!	MATCHING_SYMBOL		- Symbol number of the terminal symbol which
!				  opens the scope being closed.
!
!	MATCH_LOC		- Source locator of the token containing the
!				  matching symbol which opened the scope being
!				  closed.
!
!--

	begin

	external routine
	    PAT$LSLOCAL_OUTPUT_TERM,
	    PAT$LSLOCAL_LOC_TEXT;

	LSLOCAL_SYNTAX_ERROR_START (ERROR_LOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, 'Inserted ');
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, CLOSER_TEXT);
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' to match ');
	LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, PAT$LSLOCAL_OUTPUT_TERM (MATCHING_SYMBOL, FALSE, 0));

	if LSLOCAL_LOCATOR_IS_SYNTHETIC (MATCH_LOC)
	then
	    LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC,
		' inserted earlier')
	else
	    LSLOCAL_SYNTAX_ERROR_TEXTM (ERROR_LOC, ' ', PAT$LSLOCAL_LOC_TEXT (MATCH_LOC));

	LSLOCAL_SYNTAX_ERROR_END (ERROR_LOC);
	end
    %;

! The next group of macros are local to PATLANGSP and are not part of
! the interface.


macro
    LSLOCAL_SYNTAX_ERROR_START (SLOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro indicates the start of a syntax or lexical error message.
!	A call to this macro must be followed by one or more calls to
!	LSLOCAL_SYNTAX_ERROR_TEXT and finally by a call to
!	LSLOCAL_SYNTAX_ERROR_END.
!
! FORMAL PARAMETERS:
!
!	SLOC		- Source locator.
!
!--

	begin
	EXTERNAL pinfile: $STR_DESCRIPTOR ();
	PUT_MSG ('Error on line ');
	PUT_NUMBER (LS_LEX_LINE_NUMBER (SLOC));
	PUT_MSG (' column ');
	PUT_NUMBER (LS_LEX_COLUMN_NUMBER (SLOC));
	PUT_MSG (' of ');
	PUT_STRING (pinfile);
	PUT_MSG (':  ');
	end
    %;

macro
    LSLOCAL_SYNTAX_ERROR_TEXT (SLOC, STRING) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	Append text to a syntax error message.
!
! FORMAL PARAMETERS:
!
!	SLOC	- Source locator.
!
!	STRING	- Address of a string descriptor.
!
!--

	begin
	bind
	    S = (STRING) : $STR_DESCRIPTOR ();				! 002

	if PUT_LINE_FULL (.S [STR$H_LENGTH])	! 002 if would overflow the line
	then
	    begin
	    PUT_EOL ();
	    PUT_MSG ('	');			! tab
	    end;

	PUT_STRING (S);
	end
    %;

macro
    LSLOCAL_SYNTAX_ERROR_END (SLOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This macro ends a syntax error message started
!	by a call to LSLOCAL_SYNTAX_ERROR_START.  It automatically ends
!	the current line.
!
! FORMAL PARAMETERS:
!
!	SLOC	- Source locator.
!
!--

	begin
	PUT_EOL ();
	end
    %;

macro
    LSLOCAL_SYNTAX_ERRORM (SLOC) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This is a macro interface that permits an syntax error
!	to be reported in a single call.
!
! FORMAL PARAMETERS:
!
!	SLOC		- Source locator.
!
!	%remaining	- list of quoted strings or expressions.  The
!			  value of each expression should be the address
!			  of a string descriptor.  The strings are
!			  appended to form the error message text.
!
!--

	begin
	LSLOCAL_SYNTAX_ERROR_START (SLOC);
	LSLOCAL_SYNTAX_ERROR_TEXTM (SLOC, %remaining);
	LSLOCAL_SYNTAX_ERROR_END (SLOC);
	end
    %;

macro
    LSLOCAL_SYNTAX_ERROR_TEXTM (SLOC, TEXT) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This is a macro interface to LSLOCAL_SYNTAX_ERROR_TEXT and has the same
!	effect as a sequence of calls to LSLOCAL_SYNTAX_ERROR_TEXT.
!
! FORMAL PARAMETERS:
!
!	SLOC		- Source locator.
!
!	%remaining	- list of quoted strings or expressions.  The
!			  value of each expression should be the address
!			  of a string descriptor.
!
!--
	begin
        
	LSLOCAL_SYNTAX_ERROR_TEXTM2 (SLOC,
	    TEXT

	    %if not %null (%remaining)
	    %then
	    ,
		%remaining
	    %fi

	)
	end
    %;

!   This macro is only called by LSLOCAL_SYNTAX_ERROR_TEXTM

macro
    LSLOCAL_SYNTAX_ERROR_TEXTM2 (SLOC, TEXT) [] =

    begin

	    %if %isstring (TEXT)
	    %then
                   LOCAL lstemp_desc : $STR_DESCRIPTOR(STRING=text);
	    %else
	    	   BIND  lstemp_desc = text;
	    %fi


	LSLOCAL_SYNTAX_ERROR_TEXT (SLOC,lstemp_desc);

	LSLOCAL_SYNTAX_ERROR_TEXTM2(SLOC, %remaining)

    end%;

!				Section 5
!
! 		Error message interface (global recovery)
!
! 	In preparation for issuing a global recovery message,
!	LS_EXPECTED_SYMBOL is called for each terminal and non-
!	terminal symbol that could have led to a correct parse
!	instead of an error.  A bit vector is set to indicate
!	those terminals that were expected, and another bit
!	vector can be used to remember special non-terminal
!	symbols that were expected.
!
!	LS_GLOBAL_ERROR_MSG is called to issue the error message.
!	Addresses of the bit vectors set in LS_EXPECTED_SYMBOL are
!	passed as parameters.  Information in the two bit vectors
!	can be used to improve the error message.  For example,
!	information in the terminals expected vector can be used to
!	produce an error message of the form
!
!	    Found ... when expecting {arithmetic operator}
!
!	instead of
!
!	    Found ... when expecting {"rem", "mod", "+", "-", ...}
!
!
!	Information in the non-terminals expected vector can be
!	used to "edit" the terminals expected vector and produce
!	errors such as
!
!	    Found ... when expecting {statement}
!
!	instead of
!
!	    Found ... when expecting {"if", "loop", "begin", ...}

! The parser allocates the bit vector used to remember special
! non-terminal symbols.  LS_NUM_GROUP_NONTERMS specifies the number
! of bits in this vector.  This bit vector is cleared by the parser,
! but otherwise it is up to language specific routines to set and
! interpret the bits.  LS_NUM_GROUP_NONTERMS must have a value of 1
! or greater even if the user does not wish to use this bit vector.

literal
    LS_NUM_GROUP_NONTERMS = 9;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_EXPECTED_SYMBOL	=	EXPSYM %;		! 002
%FI								! 002

macro
    LS_EXPECTED_SYMBOL (SYM, REF_GROUP_NONTERMS_SEEN, REF_TERMS_TO_PRINT) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LS_EXPECTED_SYMBOL adds the symbol SYM to the set of
!	symbols to be listed as expected in a global recovery
!	error message by setting fields in GR_GROUP_NONTERMS_SEEN
!	and GR_TERMS_TO_PRINT appropriately.
!
! FORMAL PARAMETERS:
!
!	SYM			- Terminal or non-terminal symbol
!
!	REF_GROUP_NONTERMS_SEEN	- Pointer to table of important grouping
!				  non-terminals, indicating which have
!				  been seen
!
!	REF_TERMS_TO_PRINT	- Pointer to table of terminals, indicating
!				  which were expected.
!
! VALUE:
!
!	NONE
!
!--

	begin

	external routine
	    PAT$LSLOCAL_EXPECTED_SYMBOL : novalue;

	PAT$LSLOCAL_EXPECTED_SYMBOL (SYM, REF_GROUP_NONTERMS_SEEN, REF_TERMS_TO_PRINT);

	end
    %;

%IF %BLISS (BLISS36)						! 002
%THEN								! 002
macro								! 002
PAT$LSLOCAL_GLOBAL_ERROR_MSG	=	GLBERM %;		! 002
%FI								! 002

macro
    LS_GLOBAL_ERROR_MSG (BAD_NON_TERM, ERROR_TOKEN_PTR, REF_GROUP_NONTERMS_SEEN, REF_TERMS_TO_PRINT,
	BYTES_FOR_TERMS) =

!++
! FUNCTIONAL DESCRIPTION:
!
!	LS_GLOBAL_ERROR_MESSAGE outputs an error message for global
!	error recovery.
!
!	The global error recovery that has been done will eventually
!	result in the recognition of some production containing an
!	errormark:
!
!	    LHS_NON_TERMINAL_NAME = ... errormark ... ;
!
!	where ... indicates a sequence of terminal/non-terminal
!	symbols.  The symbol number of the non-terminal on the
!	left hand side (LHS_NON_TERMINAL_NAME above) will be passed
!	as parameter BAD_NON_TERM if it can be determined easily.
!	(It can be determined easily if the "..." on the right
!	of the errormark consists of a single terminal
!	symbol.)  Otherwise LS_UNAVAILABLE_NT will be passed.
!
!	This information permits error of the form
!
!	    Invalid statement--Found ... when expecting ...
!
!	instead of
!
!	    Found ... when expecting ...
!
!
! FORMAL PARAMETERS:
!
!	BAD_NON_TERM		- Number of non-terminal symbol (see above)
!
!	ERROR_TOKEN_PTR		- Pointer to token at which error was
!				  encountered
!
!	REF_GROUP_NONTERMS_SEEN	- Pointer to bit vector indicating which
!				  important group non-terminal symbol
!				  were expected.  (See LS_EXPECTED_SYMBOL.)
!				  Note that this vector can be modified.
!
!	REF_TERMS_TO_PRINT	- Pointer to bit vector which indicating which
!				  terminal symbols were expected.  (See
!				  LS_EXPECTED_SYMBOL.)  Note that this vector
!				  can be modified.
!
!	BYTES_FOR_TERMS		- Number of bytes used by TERMS_TO_PRINT
!
! VALUE:
!
!	NONE
!
!--

	begin

	external routine
	    PAT$LSLOCAL_GLOBAL_ERROR_MSG;

	PAT$LSLOCAL_GLOBAL_ERROR_MSG (BAD_NON_TERM, ERROR_TOKEN_PTR, REF_GROUP_NONTERMS_SEEN,
	    REF_TERMS_TO_PRINT, BYTES_FOR_TERMS);
	end
    %;


! LS_UNAVAILABLE_NT is sometimes passed as the value of parameter 
! BAD_NON_TERM.  (See description of LS_GLOBAL_ERROR_MSG.)

literal
    LS_UNAVAILABLE_NT = -2;

!				Section 6
!
!   Other definitions


! LS_PARSE_STACK_SIZE--**LANGUAGE SPECIFIC**
!
! This constant specifies the size (number of elements) in the parse
! stack.

literal
    LS_PARSE_STACK_SIZE = 256;


macro
    LS_PARSE_STACK_DECL =

!++
! FUNCTIONAL DESCRIPTION
!
!
!	NOTE:  Probably you do not need any more about this macro.
!	Just leave it the way it is and everything will be fine.
!
!	This is a special macro for a PDP-11 user of the
!	PAT parser.  This macro usually expands to LOCAL meaning
!	that the parse stack is declared as a local variable.  This macro
!	generally does not need to be changed for other implementations.
!--

	local %;



! End of PATLANGSP.REQ