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.
!
! PATDATA.REQ
! IDENT('253')

!++
! FACILITY:	PAT Parser
!
! ABSTRACT:
!
!	PATDATA.REQ is the specification for the PAT/BLISS interface.
!	It defines literals for grammar symbols (such as terminals)
!	and defines the interface to the parse tables and text
!	tables.  (The tables are allocated in PATDATA.BLI.)
!
!	This file is language independent for most applications
!	that use the PAT parser.  (See notes on language independence
!	that follow.)
!
!	This file should be libraried by the lexical analyzer, the
!	semantic action processor, and other modules that need to refer
!	to symbols in the grammar.
!
!	Note that all access to the parse tables and symbol text
!	tables should only be made via macros and routines defined
!	in this module.
!
! ENVIRONMENT:	VAX/VMS user mode
!
! AUTHOR:  C. Mitchell, CREATION DATE:  18-Feb-80
!
! MODIFIED BY:
!
! 	Charlie Mitchell, 02-Sep-81 : VERSION X2.001
! 001 -	Define the parse tables as an abstract data type to
!	facilitate future optimizations of the table organization.
!	Modify to use the new LALRPAT external names for terminal
!	symbols.
! 002 - Remove VMS dependencies.  C. Richardson.
!
!  253  Rename to DIUPATDATA.REQ
!       Gregory A. Scott 1-Jul-86
!--

require 'DIUPATREQPRO';				! 002

library 'BLI:XPORT';				! 002

! To define the literal definitions for grammar symbols, this file
! requires logical name 'PAT_REQUIRE_FILE' which should be defined
! as the require file output by PAT.
!
! The expansion of the macros called in PAT_REQUIRE_FILE results
! in literal definitions for terminals, non-terminals, and semantics
! actions.
!
! Example.  For the grammar
!
!	terminal
!
!	    loop,	t_loop,		= 1;	! t_loop is the external name
!	    ',',	t_comma,	= 2;
!	    goalsy,	t_goalsy,	= 3;
!
!	end;
!
!	begin
!
!	    SENTENCE	= NONSENSE goalsy /;
!
!	    NONSENSE	= loop ',' /CRAZY ;
!
!	end.
!
! the following literals are defined:
!
!	literal			! for terminals and non-terminals
!	    T_LOOP	= 1,	! external name
!	    T_COMMA	= 2,
!	    T_GOALSY	= 3,
!	    NT_SENTENCE	= 4,	! Note NT_ prefix for non-terminals
!	    NT_NONSENSE	= 5;
!
!	literal			! for semantics actions
!	    PAT$DATA_NULL_SEMACT = 0,	! no action specified
! 	    SENTENCE01	= 1,
!	    CRAZY	= 2;
!
!
! PAT_REQUIRE_FILE is required again in PATDATA.BLI to define
! (allocate and initialize) the parse tables.

!		Notes on Language Independence of PATDATA
!
! This file is generally language independent.  Modifications will
! be required for the following reasons:
!
!   1.	To obtain grammar symbol text from "foreign tables" that
!	are already defined somewhere in your code (e.g., tables
!	that are defined for your lexical analyzer so that it can
!	recognize reserved words).
!
!   2.	To change the allocation units for the parse tables.
!
!   3.	To permit multiple grammars to be parsed.  This can be
!	done by modifying references to the parse tables to be
!	done indirectly though a pointer.  This can also
!	be accomplished by combining the multiple grammars in
!	one PAT intput file and defining a special lexical token that
!	is passed to the parser as the first token.  Example:
!
!	    TERMINAL
!		parse_grammar_1	= 0;
!		parse_grammar_2 = 1;
!		goalsy		= 2;
!		...
!	    END;
!	    BEGIN
!
!		SENTENCE 	= WHOLETHING goalsy;
!
!		WHOLETHING	= parse_grammar_1 GRAMMAR_1
!				| parse_grammar_2 GRAMMAR_2;
!
!		GRAMMAR_1	= {definition of one grammar} ...
!
!		GRAMMAR_2	= {definition of another grammar} ...
!
!	    END.

! This file is divided into 6 sections:
!
!   1.	Macros for obtaining text associated with grammar symbols.
!
!   2.	Allocation units for the parse tables.
!
!   3.	Routines and macros for accessing and interpreting the parse
!	tables.
!
!   4.	Literal definitions for grammar symbols.
!
!   5.	Other literal definitions.
!
!   6.	Clean up.

!			Section 1
!
! Macros for obtaining text of terminal, non-terminal, and
! semantics action symbols.


! This macro returns the address of a string descriptor
! for the terminal or non-terminal symbol represented
! by SYMBOL_NUMBER.

%IF %BLISS (BLISS36)				! 002
%THEN						! 002
macro						! 002
PAT$DATA_SYMBOL_TEXT_TABLE	= SYTXTB %;	! 002
%FI						! 002

macro
    PAT$DATA_SYMBOL_TEXT (SYMBOL_NUMBER) =

	begin

	external
	    PAT$DATA_SYMBOL_TEXT_TABLE : blockvector	! 002 of string descriptors
		[, STR$K_F_BLN] field (					! 002
		    STR$B_CLASS,					! 002
		    STR$B_DTYPE,					! 002
		    STR$H_LENGTH,					! 002
		    STR$A_POINTER );					! 002

	PAT$DATA_SYMBOL_TEXT_TABLE [SYMBOL_NUMBER,0,0,0,0]		! 002
	end
    %;

! This macro returns the address of a string descriptor
! for the semantic action represented by ACTION_NUMBER.

%if PATBLSEXT_DEBUGGING
%then

%IF %BLISS (BLISS36)					! 002
%THEN							! 002
macro							! 002
PAT$DATA_SEMACT_TEXT_TABLE	=	SMTXTB %;	! 002
%FI							! 002

macro
    PAT$DATA_SEMACT_TEXT (ACTION_NUMBER) =

	begin

	external
	    PAT$DATA_SEMACT_TEXT_TABLE : vector [];	! 002 to string descriptors

	.PAT$DATA_SEMACT_TEXT_TABLE [ACTION_NUMBER]			! 002
	end
    %;

%fi

!			Section 2
!
! Define allocation units for parsing tables.  Note that these
! definitions are not intended for direct use outside PATDATA.

%BLISS32 (					! 002
macro
    PAT_STATE_SYMBOL_TABLE_ALLOC = 		! for state symbol table
	word %,
    PAT_STATE_ACTION_TABLE_ALLOC = 		! for state action table
	word %,
    PAT_RHS_COUNT_TABLE_ALLOC = 		! for rhs count table
	byte %,
    PAT_LHS_TABLE_ALLOC = 			! for lhs table
	word %,
    PAT_SEMACT_TABLE_ALLOC = 			! for semantics action table
	word %;
)						! 002

!			Section 3
!
! Routines and macros for accessing and interpreting the parse tables.


! Macro PAT$DATA_MOVE_ACTION
!
! FUNCTIONAL DESCRIPTION:
!
!	When called with STATE indicating the parse state and
!	SYMBOL containing an input symbol to that state, this routine
!	returns the action code for the move action that will be performed.
!	(See PAT$DATA_ACTION_IS)
!
! FORMAL PARAMETERS:
!
!	STATE		- Parse state.  Use PAT$DATA_INITIAL_STATE
!			  to start parsing.
!
!	SYMBOL		- Terminal or non-terminal symbol
!
! VALUE:
!
!	ACTION_CODE	- Action code of the action that will be performed

literal
    PAT$DATA_INITIAL_STATE = 0;			! Initial parse state

%IF %BLISS (BLISS36)					! 002
%THEN							! 002
macro							! 002
PAT$DATA_STATE_SYMBOL_TABLE	=	STSYTB %,	! 002
PAT$DATA_STATE_ACTION_TABLE	=	STACTB %;	! 002
%FI							! 002

macro
    PAT$DATA_MOVE_ACTION (STATE, SYMBOL) =
	begin

	external
	    PAT$DATA_STATE_SYMBOL_TABLE : vector [ %BLISS32 (, PAT_STATE_SYMBOL_TABLE_ALLOC)],		! 002
	    PAT$DATA_STATE_ACTION_TABLE : vector [%BLISS32 (, PAT_STATE_ACTION_TABLE_ALLOC, signed)];	! 002

	local
	    STATE_INDEX;

	STATE_INDEX = (STATE);

	while ((.PAT$DATA_STATE_SYMBOL_TABLE [.STATE_INDEX] neq (SYMBOL)) and 	!
	    (.PAT$DATA_STATE_SYMBOL_TABLE [.STATE_INDEX] neq PAT$DATA_ELSE_CODE)) do

	    if .PAT$DATA_STATE_SYMBOL_TABLE [.STATE_INDEX] eql PAT$DATA_CONT_CODE
	    then
		STATE_INDEX = .PAT$DATA_STATE_ACTION_TABLE [.STATE_INDEX]
	    else
		STATE_INDEX = .STATE_INDEX + 1;

	.PAT$DATA_STATE_ACTION_TABLE [.STATE_INDEX]
	end
    %;

! The macros that follow test and interpret the action code returned by
! PAT$DATA_MOVE_ACTION.
!
! The action to be taken (shift to state n, reduce to rule m)
! is encoded in one value.  PAT$DATA_ACTION_IS can be used
! to test if the action code represents a shift, reduction, etc,
! and then PAT$DATA_AC_TO_SHIFT_STATE, PAT$DATA_AC_TO_PRODUCTION_NO, or
! PAT$DATA_AC_TO_LA_PRODUCTION_NO can be used to obtain the shift
! state or the production number in the case of reductions.


! This macro is used to test the action code returned
! by routine PAT$DATA_MOVE_ACTION.  Note that the macros
! assume that the tests are made in a specific order:
! 'ERROR', 'SHIFT', 'LOOK_AHEAD'.
!
! CLASS is specified  by one of the following quoted strings:  
!
!	 CLASS	      meaning		assumption
!
!	'ERROR'		error
!
!	'SHIFT'		shift 		Not an ERROR
!
!	'LOOK_AHEAD'	lookahead 
!			reduction

macro
    PAT$DATA_ACTION_IS (ACTION_CODE, CLASS) =

	%if %identical (CLASS,'ERROR')
	%then					! Error
	    ((ACTION_CODE) eql PAT$DATA_ERROR_CODE)
	%else %if %identical (CLASS,'SHIFT')
	%then					! Shift
	    ((ACTION_CODE) geq 0) 
	%else %if %identical (CLASS,'LOOK_AHEAD')
	%then					! Look-ahead reduction
	    ((ACTION_CODE) leq -PAT$DATA_SCAN_CODE)
	%fi %fi %fi %;

! Return the goto state for a shift.  ACTION_CODE is
! the value returned by PAT$DATA_MOVE_ACTION.

macro
    PAT$DATA_AC_TO_SHIFT_STATE (ACTION_CODE) =

	(ACTION_CODE)
    %;

! Return the production number for a non-lookahead
! reduction.  ACTION_CODE is the value returned by
! PAT$DATA_MOVE_ACTION.

macro
    PAT$DATA_AC_TO_PRODUCTION_NO (ACTION_CODE) =

	(-(ACTION_CODE))
    %;

! Return the production number for a lookahead
! reduction.  ACTION_CODE is the value returned by
! PAT$DATA_MOVE_ACTION.

macro
    PAT$DATA_AC_TO_LA_PRODUCTION_NO (ACTION_CODE) =

	(-((ACTION_CODE) + PAT$DATA_SCAN_CODE))
    %;

external routine
    PAT$DATA_NEXT_TRANSITION : novalue;

!++
! FUNCTIONAL DESCRIPTION:
!
! This routine is called to fetch the next symbol which is
! the next legal transition from a state.  If ONLY_TERMINALS is TRUE
! the routine will only return terminals, otherwise it will return
! terminals and non-terminals.
!
! FORMAL PARAMETERS:
!
!	STATE			Parse state
!
!	ONLY_TERMINALS		Boolean--if TRUE, only terminals are
!				returned
!
!	REF_LAST_TRANSITION	Pointer to the last transition.
!				To find the first transition in
!				a state, pass PAT$DATA_FIND_FIRST_TRANSITION.
!				This is an output parameter that is
!				updated to indicate the last transition
!				returned.
!
!	REF_ACTION_CODE		Pointer to an action code.  This is
!				an output parameter that is set only
!				when this routine returns
!				PAT$DATA_NO_MORE_TRANSITIONS
!
!	REF_SYMBOL		Pointer to a location to receive a
!				symbol which is a legal transition or
!				or PAT$DATA_NO_MORE_TRANSITIONS if all
!				have been returned.
!
!--

! Define constants for PAT$DATA_NEXT_TRANSITION.

literal
    PAT$DATA_NO_MORE_TRANSITIONS = -1,		! Used as symbol to indicate
    						! no more transition in a state
    PAT$DATA_FIND_FIRST_TRANSITION = -1;	! Used to indicate desire to find
						! the first transition in a
						! state.

! Macro for accessing the parse reduction table

%IF %BLISS (BLISS36)					! 002
%THEN							! 002
macro							! 002
PAT$DATA_LHS_TABLE		=	LHSTAB %,	! 002
PAT$DATA_RHS_COUNT_TABLE	=	RHSCTB %,	! 002
PAT$DATA_SEMACT_TABLE		=	SEMTAB %;	! 002
%FI							! 002

! This macro accesses the parse reduction table for
! production PRODUCTION_NUMBER and assigns values
! to
!
!    REF_LHS		address of location to be assigned
!			the symbol number of the symbol
!			(non-terminal) on the right hand side
!			of the production.
!
!    REF_RHS_COUNT	address of location to be assigned the
!			number of symbols (terminal and non-
!			terminal) on the right hand side of
!			the production.
!
!    REF_SEMACT		address of location to be assigned the
! 			semantic action number for the
!			production.

macro
    PAT$DATA_GET_REDUCTION_INFO 		!
    (PRODUCTION_NUMBER, REF_LHS, REF_RHS_COUNT, REF_SEMACT) =

	begin

	external
	    PAT$DATA_LHS_TABLE : vector [%BLISS32 (, PAT_LHS_TABLE_ALLOC)],	! 002
	    PAT$DATA_RHS_COUNT_TABLE : vector [%BLISS32 (, PAT_RHS_COUNT_TABLE_ALLOC)],	! 002
	    PAT$DATA_SEMACT_TABLE : vector [%BLISS32 (, PAT_SEMACT_TABLE_ALLOC)];	! 002

	(REF_LHS) = .PAT$DATA_LHS_TABLE [PRODUCTION_NUMBER];
	(REF_RHS_COUNT) = .PAT$DATA_RHS_COUNT_TABLE [PRODUCTION_NUMBER];
	(REF_SEMACT) = .PAT$DATA_SEMACT_TABLE [PRODUCTION_NUMBER]
	end
    %;

!			Section 4
!
! Literal definitions for grammar symbols.
!
! This section requires PAT_REQUIRE_FILE which is the require file output
! by PAT and which contains:
!
!   1.	Symbolic definitions (using macro calls) for all terminals,
!	non-terminals, and semantics actions.
!
!   2.	Symbolic definitions of the parsing tables.
!
! Definitions in the require file PAT_REQUIRE_FILE have the form:
!
!	PAT_DECTRMDEF('ABORT', T_ABORT, 0)
!	PAT_DECTRMDEF('ACCEPT', T_ACCEPT, 1)
!		... for terminals
!
!	PAT_NONTRMDEF('PROGRAM',106)
!		... for non-terminals
!
!	PAT_SEMACTDEF('XXX',7)
!		... for semantics actions
!
! The expansion of these macros results in literal definitions for
! each terminal and non-terminal symbol and each semantics action.


! Define general macros


! Expand an argument list with comma separators

macro
    EXPAND_ARG_LIST (A) =
	A
	%if not %null (%remaining)
	%then
	    , EXPAND_WORKER (%remaining)
	%fi
    %;

macro
    EXPAND_WORKER [ARG] =
	ARG %;

! Define macros to define literals for terminal and
! non-terminal symbols and semantics actions

macro
    PAT_SYMBOL_DEFINITIONS (A) =
	literal
	    EXPAND_ARG_LIST (A, %remaining);
    %;

macro
    PAT_SEMACT_DEFINITIONS (A) =
	literal
	    EXPAND_ARG_LIST (A, %remaining);
    %;

macro
    PAT_INTERNAL_DEFINITIONS (A) =
	literal
	    EXPAND_ARG_LIST (A, %remaining);
    %;

! Declared terminal definition

macro
    PAT_DECTRMDEF (SYMBOL_NAME, EXT_NAME, VALUE) =
	%name (EXT_NAME) = VALUE %;

! Undeclared terminal definition

macro
    PAT_UNDTRMDEF (SYMBOL_NAME, VALUE) =
	%warn ('Undefined terminal symbol:  (It never appears on the left hand side of a production).')%name(
	EXT_NAME) = VALUE %;

! Non-terminal definition

macro
    PAT_NONTRMDEF (NAME, VALUE) =
	%name ('NT_', NAME) = VALUE %;

! Non-terminal reference

macro
    PAT_NONTRMREF (NAME) =
	%name ('NT_', NAME) %;

! Semantics action definition

macro
    PAT_SEMACTDEF (NAME, VALUE) =
	%name (NAME) = VALUE %;

! Semantics action reference

macro
    PAT_SEMACTREF (NAME, VALUE) =
	%name (NAME) %;

! Internal definition

macro
    PAT_INTRNLDEF (NAME, VALUE) =
	%name (NAME) = VALUE %;

! Unused number

macro
    PAT_UNUSEDNUM (NUM) =
	%name ('__unused_', NUM) = NUM %;

! Define macros in PAT_REQUIRE_FILE that must be defined for correct
! compilation but that aren't needed here.

macro
    PAT_DECTRMREF (EXT_NAME) =
    %,						! null
    PAT_UNDTRMREF (EXT_NAME) =
    %,
    PAT_INTRNLREF (NAME) =
    %,
    PAT_STATE_SYMBOL_TABLE (ARG_LIST) =
    %,
    PAT_STATE_ACTION_TABLE (ARG_LIST) =
    %,
    PAT_RHS_COUNT_TABLE (ARG_LIST) =
    %,
    PAT_LHS_TABLE (ARG_LIST) =
    %,
    PAT_SEMACT_TABLE (ARG_LIST) =
    %;

! Require PAT_REQUIRE_FILE to define the literals.  Don't define the parsing tables
! here though.

literal
    PAT_DFS = 1;				! Declare PAT_DFS so that see definitions

literal
    PAT_NO_TABLES = 1;			! Declare PAT_NO_TABLES so that don't define the parsing tables

require 'DIUDDL';

!			Section 5
!
! Define misc. literals


! Define exported literals.

literal
    ! null action code
    PAT$DATA_NULL_SEMACT = PAT_SEMACTREF ('PAT_NULL'),
    ! first terminal symbol
    PAT$DATA_FIRST_TERM = PAT_FIRST_TERM,
    ! last terminal symbol
    PAT$DATA_LAST_TERM = PAT_LAST_TERM,
    ! number of terminals
    PAT$DATA_NUM_TERM = (PAT_LAST_TERM - PAT_FIRST_TERM) + 1,
    ! number of terminal and non-terminal symbols
    PAT$DATA_MAX_TOKEN = PAT_MAX_TOKEN,
    ! number of semantics actions
    PAT$DATA_MAX_SEMACT = PAT_MAX_SEMACT,
    ! top most production (non-terminal on lhs)
    PAT$DATA_SENTENCE_CODE = PAT_SENTENCE_CD;

! Define private literals (those that should only be used by
! routines and macros defined in PATDATA).

literal
    PAT$DATA_CONT_CODE = PAT_CONT_CODE,
    PAT$DATA_ELSE_CODE = PAT_ELSE_CODE,
    PAT$DATA_SCAN_CODE = PAT_SCAN_CODE,
    PAT$DATA_ERROR_CODE = PAT_ERROR_CODE;

!			Section 6
!
! Clean up.
!
! Undeclare the macros and names that aren't used outside of PATDATA.

undeclare
    PAT_DFS,
    PAT_NO_TABLES,
    PAT_CONT_CODE,
    PAT_ELSE_CODE,
    PAT_SCAN_CODE,
    PAT_ERROR_CODE,
    PAT_MAX_TOKEN,
    PAT_MAX_POP,
    PAT_MAX_REDUCT,
    PAT_MAX_TRANS,
    PAT_MAX_SEMACT,
    PAT_FIRST_TERM,
    PAT_LAST_TERM,
    PAT_SENTENCE_CD,
    %quote PAT_DECTRMDEF,
    %quote PAT_UNDTRMDEF,
    %quote PAT_NONTRMDEF,
    %quote PAT_SEMACTDEF,
    %quote PAT_INTRNLDEF,
    %quote PAT_DECTRMREF,
    %quote PAT_UNDTRMREF,
    %quote PAT_NONTRMREF,
    %quote PAT_SEMACTREF,
    %quote PAT_INTRNLREF,
    %quote PAT_UNUSEDNUM,
    %quote PAT_SYMBOL_DEFINITIONS,
    %quote PAT_SEMACT_DEFINITIONS,
    %quote PAT_INTERNAL_DEFINITIONS,
    %quote PAT_STATE_SYMBOL_TABLE,
    %quote PAT_STATE_ACTION_TABLE,
    %quote PAT_RHS_COUNT_TABLE,
    %quote PAT_LHS_TABLE,
    %quote PAT_SEMACT_TABLE,
    %quote EXPAND_ARG_LIST,
    %quote EXPAND_WORKER;

! End of PATDATA.REQ