|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 Tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - downloadIndex: B T
Length: 12797 (0x31fd)
Types: TextFile
Names: »B«
└─⟦180fe333a⟧ Bits:30000405 8mm tape, Rational 1000, SW CATALOG, 10_20_0
└─⟦180fe333a⟧ Bits:30000537 8mm tape, Rational 1000, SW Catalog 10_20_0
└─⟦5cb1d1d7f⟧ »DATA«
└─⟦3b1ee7bd8⟧
└─⟦this⟧
with Parse_Tab_Types;
use Parse_Tab_Types;
with Parse_Tab_1;
with Parse_Tab_2;
with Parse_Tab_3;
with Parse_Tab_4;
with Parse_Tab_5;
with Parse_Tab_6;
with Parse_Tab_7;
with Parse_Tab_8;
with Parse_Tab_9;
with Parse_Tab_10;
with Parse_Tab_11;
with Parse_Tab_12;
with Parse_Tab_13;
package body Parsetables is
type Gsti_Type is
array (Grammarsymbolrange'First .. Grammarsymbolrange'Last * 2) of
Gc.Parserinteger;
Grammarsymboltableindex : constant Gsti_Type :=
Gsti_Type (Parse_Tab_1.Grammarsymboltableindex);
Grammarsymboltable : constant String := Parse_Tab_2.Grammarsymboltable;
--| Table of symbols used in the grammar.
-- NYU Reference Name: NO_SYM
type Lhs_Type is array (Lefthandsiderange) of Grammarsymbolrange;
Lefthandside : constant Lhs_Type := Lhs_Type (Parse_Tab_3.Lefthandside);
--| Map of the grammar rule number (constant array index) to
--| numeric value of left hand side symbol.
-- NYU Reference Name: LHS
type Rhs_Type is array (Righthandsiderange) of Gc.Parserinteger;
Righthandside : constant Rhs_Type := Rhs_Type (Parse_Tab_4.Righthandside);
type Ato_Type is array (Actiontableonerange) of Gc.Parserinteger;
Actiontableone : constant Ato_Type := Ato_Type (Parse_Tab_5.Actiontableone);
type Att_Type is array (Actiontabletworange) of Gc.Parserinteger;
Actiontabletwo : constant Att_Type := Att_Type (Parse_Tab_6.Actiontabletwo);
--| Hash values to check against to verify that
--| correct action has been found for this
--| parser state and input token.
-- NYU Reference Name: ACTION_TABLE2
type Dfm_Type is array (Defaultmaprange) of Gc.Parserinteger;
Defaultmap : constant Dfm_Type := Dfm_Type (Parse_Tab_7.Defaultmap);
--| Map of states (constant array index) to default reductions.
-- NYU Reference Name: DEFAULT
subtype Followsymbolindexarray is Parse_Tab_8.Followsymbolindexarray;
Followsymbolmapindex : constant Followsymbolindexarray :=
Parse_Tab_8.Followsymbolmapindex;
Followsymbolmap : constant Followsymbolarray := Parse_Tab_9.Followsymbolmap;
--| Map of states to sets of follow symbols
-- NYU Reference Name: FOLLOW
------------------------------------------------------------------
-- Action_Token_Map
------------------------------------------------------------------
subtype Action_Token_Array_Index is Parse_Tab_10.Action_Token_Array_Index;
--| For indexing the All Action Token Array.
--| Maps a given state into the lower and upper bounds of a slice
--| of the All Action Index Array.
Action_Token_Mapindex : constant Action_Token_Array_Index :=
Parse_Tab_10.Action_Token_Mapindex;
Action_Token_Map : constant Action_Token_Array :=
Parse_Tab_11.Action_Token_Map;
--| Action_Token_Map is an array that
--| maps from each state (using action index map) to a set of
--| action tokens. An action token is a terminal symbol
--| (except EOF_Token) for which in the given state an
--| explicit (non-default) shift or reduce action
--| is defined.
--| Used to cut reduce the
--| number of primary recovery candidates.
------------------------------------------------------------------
-- Shift_State_Map
------------------------------------------------------------------
subtype Shift_State_Index_Array is Parse_Tab_12.Shift_State_Index_Array;
--| For indexing the All Action Token Array.
--| Maps a given state into the lower and upper bounds of a slice
--| of the All Action Index Array.
Shift_State_Mapindex : constant Shift_State_Index_Array :=
Parse_Tab_12.Shift_State_Mapindex;
Shift_State_Map : constant Shift_State_Array :=
Parse_Tab_13.Shift_State_Map;
--| Shift_State_ is an array that
--| maps from non-terminals (using shift index map) to sets
--| of states in which
--| a shift to the non-terminal is defined.
--| Used to determine the number of trials in primary
--| error recovery.
------------------------------------------------------------------
-- Subprogram Bodies Global to Package ErrorParseTables
------------------------------------------------------------------
function Get_Action_Token_Map ( --| return the array of action tokens
--| for the state passed in.
In_Index : in Staterange
--| the state to return action tokens
--| for.
) return Action_Token_Record is
--| Returns
--| This subprogram returns the action token record for the
--| state passed in.
Result : Action_Token_Record;
Lowerbound, Upperbound : Gc.Parserinteger;
--| Lower and upper bounds of the slice of Action Token Map
begin
Lowerbound := Action_Token_Mapindex (In_Index * 2 - 1);
Upperbound := Action_Token_Mapindex (In_Index * 2);
Result.Set_Size := Upperbound - Lowerbound + 1;
Result.Set := (others => Defaultvalue);
Result.Set (Result.Set'First .. Result.Set_Size) :=
Action_Token_Map (Lowerbound .. Upperbound);
return Result;
end Get_Action_Token_Map;
------------------------------------------------------------------
function Get_Shift_State_Map
( --| return the array of shift states
--| for the grammar symbol passed in.
In_Index : in Grammarsymbolrange
--| the grammar symbol to return shifts
--| for.
)
--| Raises: This subprogram raises no exceptions.
return Shift_State_Record
--| Returns
--| This subprogram returns the array of shift states for the
--| grammar symbol passed in.
is
Result : Shift_State_Record;
Lowerbound, Upperbound : Gc.Parserinteger;
--| Lower and upper bounds of the slice of Shift State Map
begin
Lowerbound := Shift_State_Mapindex (In_Index * 2 - 1);
Upperbound := Shift_State_Mapindex (In_Index * 2);
Result.Set_Size := Upperbound - Lowerbound + 1;
Result.Set := (others => Defaultvalue);
Result.Set (Result.Set'First .. Result.Set_Size) :=
Shift_State_Map (Lowerbound .. Upperbound);
return Result;
end Get_Shift_State_Map;
function Get_Grammar_Symbol
( --| return the string representation
--| of the grammar symbol
In_Index : in Grammarsymbolrange) return String is
Lowerbound, Upperbound : Gc.Parserinteger;
--| Lower and upper bounds of the slice of Shift State Map
begin
Lowerbound := Grammarsymboltableindex (In_Index * 2 - 1);
Upperbound := Grammarsymboltableindex (In_Index * 2);
return Grammarsymboltable
(Integer (Lowerbound) .. Integer (Upperbound));
end Get_Grammar_Symbol;
------------------------------------------------------------------
function Get_Follow_Map ( --| return the array of follow symbols
--| of the grammar symbol passed in
In_Index : in Followmaprange)
-- |
-- |Raises: This subprogram raises no exceptions.
-- |
return Followsymbolrecord is
Result : Followsymbolrecord;
Lowerbound, Upperbound : Gc.Parserinteger;
Adjusted_Index : Gc.Parserinteger :=
(In_Index - Followmaprange'First) + 1;
begin
Lowerbound := Followsymbolmapindex (Adjusted_Index * 2 - 1);
Upperbound := Followsymbolmapindex (Adjusted_Index * 2);
Result.Follow_Symbol_Count := Upperbound - Lowerbound + 1;
Result.Follow_Symbol := (others => Defaultvalue);
Result.Follow_Symbol (Result.Follow_Symbol'First ..
Result.Follow_Symbol_Count) :=
Followsymbolmap (Lowerbound .. Upperbound);
return Result;
end Get_Follow_Map;
------------------------------------------------------------------
function Getaction ( -- see subprogram declaration
Instatevalue : in Staterange;
Insymbolvalue : in Grammarsymbolrange)
return Actionrange is
Unique : Gc.Parserinteger;
--| unique value to hash for Index.
Index : Gc.Parserinteger;
--| index into Action Tables.
Action : Gc.Parserinteger;
--| value from Action Tables.
Collisioncount : Natural := 0; --| Number of collisions.
begin
-- GetAction function
--| Algorithm
--|-
--| Definitions of key objects from package ParseTables:
--|
--| ActionCount: the number of actions in the action tables.
--|
--| ActionTableOne: table of action values for all combinations of
--| states and input actions.
--|
--| ActionTableTwo: hash values to check against to verify that action
--| value at same index in ActionTableOne is correct one.
--|
--| ActionTableSize: last index in ActionTableOne and ActionTableTwo
--| before the hash collision chains.
--|
--| DefaultMap: default action for each state.
--|+
--| The action to be returned is computed from parameters InStateValue
--| and InSymbolValue. First, determine the unique single value:
--|
--| Unique := (InStateValue * GrammarSymbolCountPlusOne) +
--| InSymbolValue;
--|
--| Unique is hashed by reducing modulo ActionTableSize and adding 1:
--|
--| Index := (Unique mod ActionTableSize) + 1;
--|
--| This hash value, Index, is used to index ActionTableOne to
--| obtain an Action:
--|
--| Action := ActionTableOne(Index);
--|
--| Action is then used to determine the return value:
--|
--| Action = 0:
--| return DefaultMap(InStateValue);
--|
--| Action < ActionCount:
--| if (Unique = ActionTableTwo(Index)) then
--| return Action;
--| else
--| return DefaultMap(InStateValue);
--| end if;
--|
--| Action >= ActionCount:
--| --Search the hash collision chain
--| Index := Action - ActionCount;
--| while (Action /= 0) loop
--| Index := Index + 1;
--| Action := ActionTableTwo(Index);
--| if (Action = Unique) then
--| return ActionTableOne(Index);
--| end if;
--| end loop;
--| return DefaultMap(InStateValue);
------------------------------------------------------------------
--| The actual code used folds this algorithm into a more efficient one:
Parserdecisioncount := Natural'Succ (Parserdecisioncount);
Unique := (Instatevalue * Grammarsymbolcountplusone) + Insymbolvalue;
Index := (Unique mod Actiontablesize) + 1;
Action := Actiontableone (Index);
if (Action >= Actioncount) then
Index := Action - Actioncount + 1;
while ((Actiontabletwo (Index) /= Unique) and then
(Actiontabletwo (Index) /= 0)) loop
Index := Index + 1;
Collisioncount := Natural'Succ (Collisioncount);
end loop;
Action := Actiontableone (Index);
end if;
-- Collect statistics information.
Totalcollisions := Collisioncount + Totalcollisions;
if Collisioncount > Maxcollisions then
Maxcollisions := Collisioncount;
end if;
if (Actiontabletwo (Index) /= Unique) then
return Defaultmap (Instatevalue);
else
return Action;
end if;
end Getaction; -- function
function Get_Lefthandside (Grammarrule : in Lefthandsiderange)
return Grammarsymbolrange is
begin
return Lefthandside (Grammarrule);
end Get_Lefthandside;
function Get_Righthandside
(Grammarrule : in Righthandsiderange) return Gc.Parserinteger is
begin
return Righthandside (Grammarrule);
end Get_Righthandside;
end Parsetables;
----------------------------------------------------------------------