repo_name
stringlengths 9
74
| language
stringclasses 1
value | length_bytes
int64 11
9.34M
| extension
stringclasses 2
values | content
stringlengths 11
9.34M
|
|---|---|---|---|---|
stcarrez/atlas | Ada | 2,823 | ads | -----------------------------------------------------------------------
-- atlas-microblog-beans -- Beans for module microblog
-- Copyright (C) 2012, 2017 Stephane Carrez
-- Written by Stephane Carrez ([email protected])
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Ada.Strings.Unbounded;
with Util.Beans.Basic;
with Util.Beans.Objects;
with Util.Beans.Methods;
with AWA.Events;
with Atlas.Microblog.Modules;
with Atlas.Microblog.Models;
package Atlas.Microblog.Beans is
type Microblog_Bean is new Util.Beans.Basic.Bean
and Util.Beans.Methods.Method_Bean with record
Module : Atlas.Microblog.Modules.Microblog_Module_Access := null;
Post : Atlas.Microblog.Models.Mblog_Ref;
end record;
type Microblog_Bean_Access is access all Microblog_Bean'Class;
-- Get the value identified by the name.
overriding
function Get_Value (From : in Microblog_Bean;
Name : in String) return Util.Beans.Objects.Object;
-- Set the value identified by the name.
overriding
procedure Set_Value (From : in out Microblog_Bean;
Name : in String;
Value : in Util.Beans.Objects.Object);
-- This bean provides some methods that can be used in a Method_Expression
overriding
function Get_Method_Bindings (From : in Microblog_Bean)
return Util.Beans.Methods.Method_Binding_Array_Access;
-- Post the microblog
procedure Post (Bean : in out Microblog_Bean;
Outcome : in out Ada.Strings.Unbounded.Unbounded_String);
-- Post a message when some event is received.
procedure Post (Bean : in out Microblog_Bean;
Event : in AWA.Events.Module_Event'Class);
-- Create the Microblog_Bean bean instance.
function Create_Microblog_Bean (Module : in Atlas.Microblog.Modules.Microblog_Module_Access)
return Util.Beans.Basic.Readonly_Bean_Access;
-- Create the a bean to display the list of microblog posts.
function Create_List_Bean (Module : in Atlas.Microblog.Modules.Microblog_Module_Access)
return Util.Beans.Basic.Readonly_Bean_Access;
end Atlas.Microblog.Beans;
|
AdaDoom3/wayland_ada_binding | Ada | 22,027 | ads | ------------------------------------------------------------------------------
-- Copyright (C) 2015-2016, AdaCore --
-- --
-- This library is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 3, or (at your option) any later --
-- version. This library is distributed in the hope that it will be useful, --
-- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
------------------------------------------------------------------------------
-- Implementation details for the vector container.
-- This package takes the same formal arguments as Conts.Vectors.Generics
-- and provides the internal implementation as well as annotations for
-- all the primitive operations.
pragma Ada_2012;
with Conts.Vectors.Storage;
with Conts.Functional.Sequences;
generic
type Index_Type is (<>);
with package Storage is new Conts.Vectors.Storage.Traits (<>);
package Conts.Vectors.Impl with SPARK_Mode is
pragma Assertion_Policy
(Pre => Suppressible, Ghost => Suppressible, Post => Ignore);
subtype Extended_Index is Index_Type'Base range
Index_Type'Pred (Index_Type'First) .. Index_Type'Last;
No_Index : constant Extended_Index := Extended_Index'First;
-- Index_Type with one more element to the left, used to represent
-- invalid indexes
subtype Element_Type is Storage.Elements.Element_Type;
subtype Returned_Type is Storage.Elements.Returned_Type;
subtype Constant_Returned_Type is Storage.Elements.Constant_Returned_Type;
subtype Stored_Type is Storage.Elements.Stored_Type;
use type Storage.Elements.Element_Type;
use type Storage.Elements.Constant_Returned_Type;
use type Storage.Elements.Returned_Type;
type Base_Vector is new Storage.Container with private with
Default_Initial_Condition => Length (Base_Vector) = 0;
-- Define the iterable aspect later, since this is not allowed when the
-- parent type is a generic formal.
subtype Cursor is Extended_Index;
No_Element : constant Cursor := No_Index;
Last_Count : constant Count_Type :=
(if Index_Type'Pos (Index_Type'Last) < Index_Type'Pos (Index_Type'First)
then 0
elsif Index_Type'Pos (Index_Type'Last) < -1
or else Index_Type'Pos (Index_Type'First) >
Index_Type'Pos (Index_Type'Last) - Count_Type'Last
then Index_Type'Pos (Index_Type'Last) -
Index_Type'Pos (Index_Type'First) + 1
else Count_Type'Last);
-- Maximal capacity of any vector. It is the minimum of the size of the
-- index range and the last possible Count_Type.
function Max_Capacity (Self : Base_Vector'Class) return Count_Type
is (Count_Type'Min (Last_Count, Storage.Max_Capacity (Self)));
-- Maximal capacity of Self. It cannot be modified. It is the maximal
-- number of elements a vector may contain.
function Length (Self : Base_Vector'Class) return Count_Type
-- The length of a vector is always smaller than Max_Capacity.
with
Inline,
Global => null,
Post => Length'Result <= Max_Capacity (Self);
function Last (Self : Base_Vector'Class) return Extended_Index
-- On an empty vector, Last returns Extended_Index'First.
with
Inline,
Global => null,
Post => Last'Result =
Index_Type'Val ((Index_Type'Pos (Index_Type'First) - 1)
+ Length (Self));
function To_Index (Position : Count_Type) return Extended_Index
-- Converts from index into the actual array back to the index type
with
Global => null,
Pre => Position in 0 .. Last_Count,
Post => To_Index'Result = Index_Type'Val
(Position - Conts.Vectors.Storage.Min_Index
+ Count_Type'Base (Index_Type'Pos (Index_Type'First)));
function To_Count (Idx : Index_Type) return Count_Type
-- Converts from an index type to an index into the actual underlying
-- array.
with
Inline,
Global => null,
Pre => Idx in Index_Type'First .. To_Index (Last_Count),
Post => To_Count'Result = Count_Type
(Conts.Vectors.Storage.Min_Index
+ Count_Type'Base (Index_Type'Pos (Idx))
- Count_Type'Base (Index_Type'Pos (Index_Type'First)));
------------------
-- Formal Model --
------------------
pragma Unevaluated_Use_Of_Old (Allow);
package M is new Conts.Functional.Sequences
(Index_Type => Index_Type,
Element_Type => Element_Type);
-- This instance should be ghost but it is not currently allowed by the RM.
-- See P523-006
function Model (Self : Base_Vector'Class) return M.Sequence
with
Ghost,
Global => null,
Post => M.Length (Model'Result) = Length (Self);
use type M.Sequence;
function Element
(S : M.Sequence; I : Index_Type) return Element_Type
renames M.Get;
-- ??? Do we need this subprogram, could we use M.Get everywhere instead ?
-----------------
-- Subprograms --
-----------------
function Element
(Self : Base_Vector'Class; Position : Index_Type)
return Constant_Returned_Type
-- See documentation in conts-vectors-generics.ads
with
Inline,
Global => null,
Pre => Position <= Last (Self),
Post => Storage.Elements.To_Element (Element'Result) =
Element (Model (Self), Position);
function Reference
(Self : Base_Vector'Class; Position : Index_Type)
return Returned_Type
-- See documentation in conts-vectors-generics.ads
with
Inline,
Global => null,
Pre => Position <= Last (Self);
function Last_Element
(Self : Base_Vector'Class) return Constant_Returned_Type
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Pre => Length (Self) > 0,
Post => Last_Element'Result = Element (Self, Last (Self));
function First (Self : Base_Vector'Class) return Cursor
-- See documentation in conts-vectors-generics.ads
with
Inline,
Global => null,
Contract_Cases =>
(Length (Self) = 0 => First'Result = No_Element,
others => First'Result = Index_Type'First
and then Has_Element (Self, First'Result));
function Has_Element
(Self : Base_Vector'Class; Position : Cursor) return Boolean
is (Position >= Index_Type'First and then Position <= Self.Last)
-- See documentation in conts-vectors-generics.ads
with
Inline,
Global => null,
Post => Has_Element'Result =
(Position in Index_Type'First .. Self.Last);
pragma Annotate (GNATprove, Inline_For_Proof, Entity => Has_Element);
function Next
(Self : Base_Vector'Class; Position : Cursor) return Cursor
-- See documentation in conts-vectors-generics.ads
with
Inline,
Global => null,
Pre => Has_Element (Self, Position),
Contract_Cases =>
(Position < Last (Self) => Next'Result = Index_Type'Succ (Position)
and then Has_Element (Self, Next'Result),
others => Next'Result = No_Element);
procedure Next (Self : Base_Vector'Class; Position : in out Cursor)
-- See documentation in conts-vectors-generics.ads
with
Inline,
Global => null,
Pre => Has_Element (Self, Position),
Contract_Cases =>
(Position < Last (Self) => Position = Index_Type'Succ (Position'Old)
and then Has_Element (Self, Position),
others => Position = No_Element);
function Previous
(Self : Base_Vector'Class; Position : Cursor) return Cursor
-- See documentation in conts-vectors-generics.ads
with
Inline,
Global => null,
Pre => Has_Element (Self, Position),
Contract_Cases =>
(Position > Index_Type'First =>
Previous'Result = Index_Type'Pred (Position)
and then Has_Element (Self, Previous'Result),
others => Previous'Result = No_Element);
procedure Reserve_Capacity
(Self : in out Base_Vector'Class; Capacity : Count_Type)
-- Make sure there is enough space for at least Count_Type elements in
-- Self.
with
Global => null,
Pre => Capacity <= Max_Capacity (Self),
Post => Length (Self) = Length (Self)'Old
and then Model (Self) = Model (Self)'Old;
procedure Shrink_To_Fit (Self : in out Base_Vector'Class)
-- Resize the vector to fit its number of elements.
-- This has no effect on models.
with
Global => null,
Post => Length (Self) = Length (Self)'Old
and then Model (Self) = Model (Self)'Old;
function M_Elements_Equal
(S1, S2 : M.Sequence;
Fst : Index_Type;
Lst : Extended_Index)
return Boolean
-- The slice from Fst to Lst contains the same values in S1 and S2.
with Ghost,
Pre => Lst <= M.Last (S1) and Lst <= M.Last (S2),
Post => M_Elements_Equal'Result =
(for all I in Fst .. Lst => Element (S1, I) = Element (S2, I));
pragma Annotate (GNATprove, Inline_For_Proof, M_Elements_Equal);
function M_Elements_Consts
(S : M.Sequence;
Fst : Index_Type;
Lst : Extended_Index;
E : Storage.Elements.Element_Type)
return Boolean
-- The slice from Fst to Lst contains only the value E.
with Ghost,
Pre => Lst <= M.Last (S),
Post => M_Elements_Consts'Result =
(for all I in Fst .. Lst => Element (S, I) = E);
pragma Annotate (GNATprove, Inline_For_Proof, M_Elements_Consts);
procedure Resize
(Self : in out Base_Vector'Class;
Length : Count_Type;
Element : Storage.Elements.Element_Type)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Pre => Length <= Max_Capacity (Self),
Post =>
Impl.Length (Self) = Length
-- Elements of Self that were located before the index Length are
-- preserved.
and then M_Elements_Equal
(S1 => Model (Self),
S2 => Model (Self)'Old,
Fst => Index_Type'First,
Lst => Index_Type'Min
(To_Index (Length),
Last (Self)'Old))
-- If elements were appended to Self then they are equal to Element.
and then
(if To_Index (Length) > Last (Self)'Old then
M_Elements_Consts (S => Model (Self),
Fst => Index_Type'Succ (Last (Self)'Old),
Lst => Last (Self),
E => Element));
procedure Clear (Self : in out Base_Vector'Class)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Post => Length (Self) = 0;
procedure Append
(Self : in out Base_Vector'Class;
Element : Element_Type;
Count : Count_Type := 1)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Pre => Length (Self) <= Max_Capacity (Self) - Count,
Post => Length (Self) = Length (Self)'Old + Count
-- Elements that were already in Self are preserved.
and then M_Elements_Equal
(S1 => Model (Self),
S2 => Model (Self)'Old,
Fst => Index_Type'First,
Lst => Last (Self)'Old)
-- Appended elements are equal to Element.
and then M_Elements_Consts (S => Model (Self),
Fst => Index_Type'Succ (Last (Self)'Old),
Lst => Last (Self),
E => Element);
procedure Insert
(Self : in out Base_Vector'Class;
Before : Extended_Index;
Element : Element_Type;
Count : Count_Type := 1)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Pre => Length (Self) <= Max_Capacity (Self) - Count
and then (Before = No_Element or else Has_Element (Self, Before)),
Post =>
Length (Self) = Length (Self)'Old + Count
-- Elements before Before have not been modified
and M_Elements_Equal
(S1 => Model (Self),
S2 => Model (Self)'Old,
Fst => Index_Type'First,
Lst => Index_Type'Pred (Before))
-- Then the new elements
and M_Elements_Consts
(Model (Self),
Fst => Before,
Lst => Index_Type'Val (Index_Type'Pos (Before) + Count - 1),
E => Element)
-- Elements after are unchanged
and M_Elements_Shifted
(S1 => Model (Self)'Old,
S2 => Model (Self),
Fst => Before,
Lst => Last (Self)'Old,
Offset => Count);
procedure Assign
(Self : in out Base_Vector'Class; Source : Base_Vector'Class)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Post => Model (Self) = Model (Source);
function Is_Empty (Self : Base_Vector'Class) return Boolean
is (Length (Self) = 0)
with Inline;
-- See documentation in conts-vectors-generics.ads
procedure Replace_Element
(Self : in out Base_Vector'Class;
Index : Index_Type;
New_Item : Element_Type)
-- Replace the element at the given position.
-- Nothing is done if Index is not a valid index in the container.
with
Global => null,
Pre => Index <= Last (Self),
Post => Length (Self) = Length (Self)'Old
and then
(if Index <= Last (Self)
then M.Is_Set (Model (Self)'Old, Index, New_Item, Model (Self))
else Model (Self) = Model (Self)'Old);
function M_Elements_Shifted
(S1, S2 : M.Sequence;
Fst, Lst : Index_Type;
Offset : Count_Type := 1)
return Boolean
-- The slice from Fst to Lst of S1 has been shifted by Offset in S2.
with Ghost,
Pre => Lst <= M.Last (S1) and Lst < M.Last (S2),
Post =>
M_Elements_Shifted'Result =
(for all I in Fst .. Lst => Element (S1, I) =
Element (S2, Index_Type'Val (Index_Type'Pos (I) + Offset)));
pragma Annotate (GNATprove, Inline_For_Proof, M_Elements_Shifted);
procedure Delete
(Self : in out Base_Vector'Class;
Index : Index_Type;
Count : Count_Type := 1)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Pre => Index <= Last (Self),
Post =>
-- Elements located before Index are preserved.
M_Elements_Equal
(S1 => Model (Self),
S2 => Model (Self)'Old,
Fst => Index_Type'First,
Lst => Index_Type'Pred (Index)),
-- If there are less than Count elements after Index, they are all
-- erased.
Contract_Cases =>
(Count - 1 >= Index_Type'Pos (Last (Self)) - Index_Type'Pos (Index) =>
Length (Self) =
Index_Type'Pos (Index) - Index_Type'Pos (Index_Type'First),
-- Otherwise, Count elements are removed
others =>
Length (Self) = Length (Self)'Old - Count
-- Elements located after Index are shifted.
and M_Elements_Shifted
(S1 => Model (Self),
S2 => Model (Self)'Old,
Fst => Index,
Lst => Last (Self),
Offset => Count));
procedure Delete_Last (Self : in out Base_Vector'Class)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Pre => Length (Self) > 0,
Post => Length (Self) = Length (Self)'Old - 1
and then M_Elements_Equal
(S1 => Model (Self),
S2 => Model (Self)'Old,
Fst => Index_Type'First,
Lst => Last (Self));
function M_Elements_Equal_Except
(S1, S2 : M.Sequence;
X, Y : Index_Type)
return Boolean
-- Whether S1 and S2 coincide except on X and Y.
with
Ghost,
Pre => M.Last (S1) = M.Last (S2),
Post =>
M_Elements_Equal_Except'Result =
(for all I in Index_Type'First .. M.Last (S1) =>
(if I /= X and I /= Y then
Element (S1, I) = Element (S2, I)));
pragma Annotate (GNATprove, Inline_For_Proof, M_Elements_Equal_Except);
procedure Swap
(Self : in out Base_Vector'Class;
Left, Right : Index_Type)
-- See documentation in conts-vectors-generics.ads
with
Global => null,
Pre => Left <= Last (Self) and then Right <= Last (Self),
Post => Length (Self) = Length (Self)'Old
and then Element (Model (Self), Left) =
Element (Model (Self)'Old, Right)
and then Element (Model (Self), Right) =
Element (Model (Self)'Old, Left)
-- Elements that have not been swapped are preserved.
and then M_Elements_Equal_Except
(S1 => Model (Self),
S2 => Model (Self)'Old,
X => Left,
Y => Right);
function First_Primitive (Self : Base_Vector) return Cursor
-- See documentation in conts-vectors-generics.ads
is (First (Self))
with Inline;
function Element_Primitive
(Self : Base_Vector; Position : Cursor) return Constant_Returned_Type
-- See documentation in conts-vectors-generics.ads
is (Element (Self, Position))
with
Inline,
Pre'Class => Has_Element (Self, Position),
Post => Storage.Elements.To_Element (Element_Primitive'Result) =
Element (Model (Self), Position);
function Has_Element_Primitive
(Self : Base_Vector; Position : Cursor) return Boolean
-- See documentation in conts-vectors-generics.ads
is (Has_Element (Self, Position))
with
Inline,
Post => Has_Element_Primitive'Result =
(Position in Index_Type'First .. Self.Last);
pragma Annotate (GNATprove, Inline_For_Proof, Has_Element_Primitive);
function Next_Primitive
(Self : Base_Vector; Position : Cursor) return Cursor
-- These are only needed because the Iterable aspect expects a parameter
-- of type List instead of List'Class. But then it means that the loop
-- is doing a lot of dynamic dispatching, and is twice as slow as a loop
-- using an explicit cursor.
is (Next (Self, Position))
with
Inline,
Pre'Class => Has_Element (Self, Position);
private
pragma SPARK_Mode (Off);
procedure Adjust (Self : in out Base_Vector);
procedure Finalize (Self : in out Base_Vector);
-- In case the list is a controlled type, but irrelevant when Self
-- is not controlled.
No_Last : constant Count_Type := Conts.Vectors.Storage.Min_Index - 1;
-- Indicates that the vector is empty, when its Last index is No_Last
type Base_Vector is new Storage.Container with record
Last : Count_Type := No_Last;
-- Last assigned element
end record;
function Last (Self : Base_Vector'Class) return Extended_Index
is (To_Index (Self.Last));
function To_Index (Position : Count_Type) return Extended_Index
is (Index_Type'Val
(Position - Conts.Vectors.Storage.Min_Index
+ Count_Type'Base (Index_Type'Pos (Index_Type'First))));
function To_Count (Idx : Index_Type) return Count_Type
is (Count_Type
(Conts.Vectors.Storage.Min_Index
+ Count_Type'Base (Index_Type'Pos (Idx))
- Count_Type'Base (Index_Type'Pos (Index_Type'First))));
------------------
-- Formal Model --
------------------
function M_Elements_Consts
(S : M.Sequence;
Fst : Index_Type;
Lst : Extended_Index;
E : Storage.Elements.Element_Type)
return Boolean
is (for all I in Fst .. Lst => Element (S, I) = E);
function M_Elements_Equal
(S1, S2 : M.Sequence;
Fst : Index_Type;
Lst : Extended_Index)
return Boolean
is (for all I in Fst .. Lst => Element (S1, I) = Element (S2, I));
function M_Elements_Equal_Except
(S1, S2 : M.Sequence;
X, Y : Index_Type)
return Boolean
is (for all I in Index_Type'First .. M.Last (S1) =>
(if I /= X and I /= Y then Element (S1, I) = Element (S2, I)));
function M_Elements_Shifted
(S1, S2 : M.Sequence;
Fst, Lst : Index_Type;
Offset : Count_Type := 1)
return Boolean
is (for all I in Fst .. Lst => Element (S1, I) =
Element (S2, Index_Type'Val (Index_Type'Pos (I) + Offset)));
end Conts.Vectors.Impl;
|
reznikmm/matreshka | Ada | 11,767 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Ada Modeling Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2012-2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Ada.Unchecked_Deallocation;
with XML.SAX.Input_Sources;
with XML.SAX.Parse_Exceptions.Internals;
with XML.SAX.Simple_Readers;
with AMF.CMOF.Associations;
with AMF.CMOF.Properties.Collections;
pragma Unreferenced (AMF.CMOF.Properties.Collections);
-- XXX GNAT Pro 7.1.0w (20120405) reports unused package.
with AMF.Internals.XMI_Entity_Resolvers;
with AMF.Internals.XMI_Handlers;
package body AMF.Internals.XMI_Readers is
-------------------
-- Error_Handler --
-------------------
function Error_Handler
(Self : XMI_Reader'Class)
return AMF.XMI.Error_Handlers.XMI_Error_Handler_Access is
begin
return Self.Error_Handler;
end Error_Handler;
--------------------
-- Establish_Link --
--------------------
procedure Establish_Link
(Extent : not null AMF.URI_Stores.URI_Store_Access;
Attribute : not null AMF.CMOF.Properties.CMOF_Property_Access;
One_Element : not null AMF.Elements.Element_Access;
Other_Element : not null AMF.Elements.Element_Access)
is
use type AMF.CMOF.Properties.CMOF_Property_Access;
Association : constant AMF.CMOF.Associations.CMOF_Association_Access
:= Attribute.Get_Association;
begin
-- This subprograms take in sense constraint of MOF meta models to
-- handle potentially duplicated links:
--
-- "[12] An Association has exactly 2 memberEnds, may never have a
-- navigableOwnedEnd (they will always be owned by Classes) and may have
-- at most one ownedEnd."
if Association.Get_Owned_End.Length = 1 then
-- One of the ends is owned by association, link must be created
-- even when order of ends is reversed.
if Association.Get_Member_End.Element (1) = Attribute then
Extent.Create_Link (Association, One_Element, Other_Element);
else
Extent.Create_Link (Association, Other_Element, One_Element);
end if;
else
-- None of ends are owned by association, link is created when
-- specified attribute is a first end of the association to prevent
-- duplicate links.
if Association.Get_Member_End.Element (1) = Attribute then
Extent.Create_Link (Association, One_Element, Other_Element);
end if;
end if;
end Establish_Link;
-------------------------------
-- Load_Referenced_Documents --
-------------------------------
function Load
(Self : in out XMI_Reader'Class;
Document_URI : League.Strings.Universal_String)
return AMF.URI_Stores.URI_Store_Access
is
use type AMF.Elements.Element_Access;
use type AMF.URI_Stores.URI_Store_Access;
use type League.Strings.Universal_String;
procedure Free is
new Ada.Unchecked_Deallocation
(XML.SAX.Input_Sources.SAX_Input_Source'Class,
XML.SAX.Input_Sources.SAX_Input_Source_Access);
Result : AMF.URI_Stores.URI_Store_Access;
begin
-- Insert requested document into the queue.
Self.URI_Queue.Include (Document_URI);
-- Load all referenced documents.
declare
Position : Universal_String_Sets.Cursor;
URI : League.Strings.Universal_String;
begin
while not Self.URI_Queue.Is_Empty loop
Position := Self.URI_Queue.First;
URI := Universal_String_Sets.Element (Position);
Self.URI_Queue.Delete (Position);
-- Load document only when it is not loaded already. Some
-- documents with circular dependencies can register loading of
-- document when its loading was started but not completed yet.
--
-- XXX This need to be reviewed for new architecture of XMI
-- reader.
declare
Source : XML.SAX.Input_Sources.SAX_Input_Source_Access;
Resolver : aliased
AMF.Internals.XMI_Entity_Resolvers.XMI_Entity_Resolver;
Reader : aliased XML.SAX.Simple_Readers.Simple_Reader;
Handler : aliased
AMF.Internals.XMI_Handlers.XMI_Handler (Self'Access);
Success : Boolean := True;
begin
-- Resolve XMI document.
Self.Resolver.Resolve_Document (URI, Source, Success);
-- Load document when it was resolved successfuly.
--
-- XXX It can be reasonable to report error here.
if Success then
Reader.Set_Content_Handler (Handler'Unchecked_Access);
Reader.Set_Error_Handler (Handler'Unchecked_Access);
Reader.Set_Entity_Resolver (Resolver'Unchecked_Access);
Reader.Parse (Source);
-- Register loaded extent.
Documents.Insert (Source.System_Id, Handler.Extent);
if Result = null then
Result := Handler.Extent;
end if;
end if;
-- Deallocate input source.
Free (Source);
end;
end loop;
end;
-- Resolve cross-document links.
declare
Link : Cross_Document_Link;
Element : AMF.Elements.Element_Access;
Success : Boolean;
Position : Cross_Document_Link_Vectors.Cursor
:= Self.Cross_Links.First;
begin
while Cross_Document_Link_Vectors.Has_Element (Position) loop
Link := Cross_Document_Link_Vectors.Element (Position);
Element := null;
Success := True;
-- Lookup for document and element in the document.
declare
Position : constant Universal_String_Extent_Maps.Cursor
:= Documents.Find (Link.Document_URI);
begin
if Universal_String_Extent_Maps.Has_Element (Position) then
Element :=
Universal_String_Extent_Maps.Element
(Position).Element (Link.Element_Id);
end if;
end;
-- Establish link when element was resolved, otherwise report
-- error.
if Element /= null then
Establish_Link
(Link.Extent, Link.Attribute, Link.Element, Element);
else
Self.Error_Handler.Error
(XML.SAX.Parse_Exceptions.Internals.Create
(Public_Id => Link.Public_Id,
System_Id => Link.System_Id,
Line => Link.Line,
Column => Link.Column,
Message =>
"Unknown element '"
& Link.Document_URI
& '#'
& Link.Element_Id
& "'"),
Success);
if not Success then
-- Error handling is not implemented.
raise Program_Error;
end if;
end if;
Cross_Document_Link_Vectors.Next (Position);
end loop;
end;
return Result;
end Load;
----------------------------------
-- Postpone_Cross_Document_Link --
----------------------------------
procedure Postpone_Cross_Document_Link
(Self : in out XMI_Reader'Class;
Element : AMF.Elements.Element_Access;
Attribute : AMF.CMOF.Properties.CMOF_Property_Access;
Extent : AMF.URI_Stores.URI_Store_Access;
Document_URI : League.Strings.Universal_String;
Element_Id : League.Strings.Universal_String;
Public_Id : League.Strings.Universal_String;
System_Id : League.Strings.Universal_String;
Line : Natural;
Column : Natural) is
begin
-- Include document into the document queue.
Self.URI_Queue.Include (Document_URI);
Self.Cross_Links.Append
((Element => Element,
Attribute => Attribute,
Extent => Extent,
Document_URI => Document_URI,
Element_Id => Element_Id,
Public_Id => Public_Id,
System_Id => System_Id,
Line => Line,
Column => Column));
end Postpone_Cross_Document_Link;
end AMF.Internals.XMI_Readers;
|
MinimSecure/unum-sdk | Ada | 787 | adb | -- Copyright 2011-2019 Free Software Foundation, Inc.
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program. If not, see <http://www.gnu.org/licenses/>.
with Pck; use Pck;
procedure Foo is
begin
Dummy_Task.Start;
end Foo;
|
optikos/oasis | Ada | 1,418 | ads | -- Copyright (c) 2019 Maxim Reznik <[email protected]>
--
-- SPDX-License-Identifier: MIT
-- License-Filename: LICENSE
-------------------------------------------------------------
with Program.Elements.Statements;
with Program.Lexical_Elements;
with Program.Elements.Expressions;
package Program.Elements.Abort_Statements is
pragma Pure (Program.Elements.Abort_Statements);
type Abort_Statement is
limited interface and Program.Elements.Statements.Statement;
type Abort_Statement_Access is access all Abort_Statement'Class
with Storage_Size => 0;
not overriding function Aborted_Tasks
(Self : Abort_Statement)
return not null Program.Elements.Expressions.Expression_Vector_Access
is abstract;
type Abort_Statement_Text is limited interface;
type Abort_Statement_Text_Access is access all Abort_Statement_Text'Class
with Storage_Size => 0;
not overriding function To_Abort_Statement_Text
(Self : aliased in out Abort_Statement)
return Abort_Statement_Text_Access is abstract;
not overriding function Abort_Token
(Self : Abort_Statement_Text)
return not null Program.Lexical_Elements.Lexical_Element_Access
is abstract;
not overriding function Semicolon_Token
(Self : Abort_Statement_Text)
return not null Program.Lexical_Elements.Lexical_Element_Access
is abstract;
end Program.Elements.Abort_Statements;
|
Heziode/lsystem-editor | Ada | 1,941 | ads | -------------------------------------------------------------------------------
-- LSE -- L-System Editor
-- Author: Heziode
--
-- License:
-- MIT License
--
-- Copyright (c) 2018 Quentin Dauprat (Heziode) <[email protected]>
--
-- Permission is hereby granted, free of charge, to any person obtaining a
-- copy of this software and associated documentation files (the "Software"),
-- to deal in the Software without restriction, including without limitation
-- the rights to use, copy, modify, merge, publish, distribute, sublicense,
-- and/or sell copies of the Software, and to permit persons to whom the
-- Software is furnished to do so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in
-- all copies or substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-- DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
with Ada.Containers.Indefinite_Holders;
with Ada.Containers.Indefinite_Doubly_Linked_Lists;
with LSE.Model.Grammar.Symbol;
use LSE.Model.Grammar.Symbol;
-- @description
-- This package provide a pointer and a list of Symbol.
--
package LSE.Model.Grammar.Symbol_Utils is
package Ptr is new Ada.Containers.Indefinite_Holders
(Instance'Class);
use Ptr;
package P_List is
new Ada.Containers.Indefinite_Doubly_Linked_Lists
(
Element_Type => Ptr.Holder
);
end LSE.Model.Grammar.Symbol_Utils;
|
coopht/axmpp | Ada | 8,078 | adb | ------------------------------------------------------------------------------
-- --
-- AXMPP Project --
-- --
-- XMPP Library for Ada --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2011-2016, Alexander Basov <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Alexander Basov, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with XML.SAX.Attributes;
with XMPP.Logger;
package body XMPP.IQS is
use League.Strings;
--------------
-- End_IQ --
--------------
not overriding procedure End_IQ
(Self : XMPP_IQ;
Writer : in out XML.SAX.Pretty_Writers.XML_Pretty_Writer'Class) is
pragma Unreferenced (Self);
begin
Writer.End_Element (Qualified_Name => IQ_Element);
end End_IQ;
----------------
-- Get_From --
----------------
function Get_From (Self : XMPP_IQ) return League.Strings.Universal_String is
begin
return Self.From;
end Get_From;
--------------
-- Get_Id --
--------------
function Get_Id (Self : XMPP_IQ) return League.Strings.Universal_String is
begin
return Self.Id;
end Get_Id;
-------------------
-- Get_IQ_Kind --
-------------------
function Get_IQ_Kind (Self : XMPP_IQ) return IQ_Kind is
begin
return Self.Kind_Of_IQ;
end Get_IQ_Kind;
----------------
-- Get_Kind --
----------------
overriding function Get_Kind (Self : XMPP_IQ) return Object_Kind is
pragma Unreferenced (Self);
begin
return XMPP.IQ;
end Get_Kind;
--------------
-- Get_To --
--------------
function Get_To (Self : XMPP_IQ) return League.Strings.Universal_String is
begin
return Self.To;
end Get_To;
-------------------
-- Set_Content --
-------------------
overriding procedure Set_Content
(Self : in out XMPP_IQ;
Parameter : League.Strings.Universal_String;
Value : League.Strings.Universal_String) is
begin
if Parameter.To_Wide_Wide_String = "type" then
if Value.To_Wide_Wide_String = "set" then
Self.Kind_Of_IQ := Set;
elsif Value.To_Wide_Wide_String = "get" then
Self.Kind_Of_IQ := Get;
elsif Value.To_Wide_Wide_String = "result" then
Self.Kind_Of_IQ := Result;
elsif Value.To_Wide_Wide_String = "error" then
Self.Kind_Of_IQ := Error;
end if;
elsif Parameter.To_Wide_Wide_String = "id" then
Self.Id := Value;
elsif Parameter.To_Wide_Wide_String = "to" then
Self.To := Value;
elsif Parameter.To_Wide_Wide_String = "from" then
Self.From := Value;
elsif Parameter.To_Wide_Wide_String = "iq" then
null;
else
XMPP.Logger.Log ("XMPP_IQ : Unknown parameter : " & Parameter);
end if;
end Set_Content;
----------------
-- Set_From --
----------------
procedure Set_From (Self : in out XMPP_IQ;
Val : League.Strings.Universal_String) is
begin
Self.From := Val;
end Set_From;
--------------
-- Set_Id --
--------------
procedure Set_Id (Self : in out XMPP_IQ;
Val : League.Strings.Universal_String) is
begin
Self.Id := Val;
end Set_Id;
-------------------
-- Set_IQ_Kind --
-------------------
procedure Set_IQ_Kind (Self : in out XMPP_IQ; Val : IQ_Kind) is
begin
Self.Kind_Of_IQ := Val;
end Set_IQ_Kind;
--------------
-- Set_To --
--------------
procedure Set_To (Self : in out XMPP_IQ;
Val : League.Strings.Universal_String) is
begin
Self.To := Val;
end Set_To;
----------------
-- Start_IQ --
----------------
not overriding procedure Start_IQ
(Self : XMPP_IQ;
Writer : in out XML.SAX.Pretty_Writers.XML_Pretty_Writer'Class) is
Attrs : XML.SAX.Attributes.SAX_Attributes;
begin
-- Generating IQ container xml
case Self.Kind_Of_IQ is
when Set =>
Attrs.Set_Value
(Qualified_Name => IQ_Type_Attribute,
Value => To_Universal_String ("set"));
when Get =>
Attrs.Set_Value
(Qualified_Name => IQ_Type_Attribute,
Value => To_Universal_String ("get"));
when Result =>
Attrs.Set_Value
(Qualified_Name => IQ_Type_Attribute,
Value => To_Universal_String ("result"));
when Error =>
Attrs.Set_Value
(Qualified_Name => IQ_Type_Attribute,
Value => To_Universal_String ("error"));
end case;
Attrs.Set_Value
(Qualified_Name => IQ_Id_Attribute,
Value => Self.Get_Id);
if not Self.To.Is_Empty then
Attrs.Set_Value
(Qualified_Name => IQ_To_Attribute,
Value => Self.To);
end if;
if not Self.From.Is_Empty then
Attrs.Set_Value
(Qualified_Name => IQ_From_Attribute,
Value => Self.From);
end if;
Writer.Start_Element (Qualified_Name => IQ_Element,
Attributes => Attrs);
end Start_IQ;
end XMPP.IQS;
|
ResonanceGamez/Chrysalis | Ada | 2,707 | adb | <AnimDB FragDef="objects/characters/human/female/human_female_fragment_ids.xml" TagDef="objects/characters/human/female/human_female_tags.xml">
<FragmentList>
<Idle>
<Fragment BlendOutDuration="0.2" Tags="Unaware">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="stand_relaxed_idle" flags="Loop"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="Alerted">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="stand_relaxed_idle" flags="Loop"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="Crouching">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="crouch_idle"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="Crouching">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="crouch_idle_v2"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="stand_relaxed_idle" flags="Loop"/>
</AnimLayer>
</Fragment>
</Idle>
<Move>
<Fragment BlendOutDuration="0.2" Tags="Crouching">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="bspace_2d_move_strafe_crouch" flags="Loop"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="bspace_2d_move_strafe" flags="Loop"/>
</AnimLayer>
</Fragment>
</Move>
<Interaction>
<Fragment BlendOutDuration="0.2" Tags="ScopeSlave">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="crouchwalk_l"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="stand_relaxed_r_45"/>
</AnimLayer>
</Fragment>
</Interaction>
<Emote>
<Fragment BlendOutDuration="0.2" Tags="Awe">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="crouch_r_90"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="Apathy">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="crouch_l_135"/>
</AnimLayer>
</Fragment>
<Fragment BlendOutDuration="0.2" Tags="">
<AnimLayer>
<Blend ExitTime="0" StartTime="0" Duration="0.2"/>
<Animation name="crouch_to_crouchwalk_b"/>
</AnimLayer>
</Fragment>
</Emote>
</FragmentList>
</AnimDB>
|
reznikmm/matreshka | Ada | 4,631 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Matreshka.DOM_Documents;
with Matreshka.ODF_String_Constants;
with ODF.DOM.Iterators;
with ODF.DOM.Visitors;
package body Matreshka.ODF_Text.Key2_Phonetic_Attributes is
------------
-- Create --
------------
overriding function Create
(Parameters : not null access Matreshka.DOM_Attributes.Attribute_L2_Parameters)
return Text_Key2_Phonetic_Attribute_Node is
begin
return Self : Text_Key2_Phonetic_Attribute_Node do
Matreshka.ODF_Text.Constructors.Initialize
(Self'Unchecked_Access,
Parameters.Document,
Matreshka.ODF_String_Constants.Text_Prefix);
end return;
end Create;
--------------------
-- Get_Local_Name --
--------------------
overriding function Get_Local_Name
(Self : not null access constant Text_Key2_Phonetic_Attribute_Node)
return League.Strings.Universal_String
is
pragma Unreferenced (Self);
begin
return Matreshka.ODF_String_Constants.Key2_Phonetic_Attribute;
end Get_Local_Name;
begin
Matreshka.DOM_Documents.Register_Attribute
(Matreshka.ODF_String_Constants.Text_URI,
Matreshka.ODF_String_Constants.Key2_Phonetic_Attribute,
Text_Key2_Phonetic_Attribute_Node'Tag);
end Matreshka.ODF_Text.Key2_Phonetic_Attributes;
|
reznikmm/matreshka | Ada | 3,764 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with XML.DOM.Attributes;
package ODF.DOM.Table_Parse_Sql_Statement_Attributes is
pragma Preelaborate;
type ODF_Table_Parse_Sql_Statement_Attribute is limited interface
and XML.DOM.Attributes.DOM_Attribute;
type ODF_Table_Parse_Sql_Statement_Attribute_Access is
access all ODF_Table_Parse_Sql_Statement_Attribute'Class
with Storage_Size => 0;
end ODF.DOM.Table_Parse_Sql_Statement_Attributes;
|
Heziode/lsystem-editor | Ada | 2,214 | ads | -------------------------------------------------------------------------------
-- LSE -- L-System Editor
-- Author: Heziode
--
-- License:
-- MIT License
--
-- Copyright (c) 2018 Quentin Dauprat (Heziode) <[email protected]>
--
-- Permission is hereby granted, free of charge, to any person obtaining a
-- copy of this software and associated documentation files (the "Software"),
-- to deal in the Software without restriction, including without limitation
-- the rights to use, copy, modify, merge, publish, distribute, sublicense,
-- and/or sell copies of the Software, and to permit persons to whom the
-- Software is furnished to do so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in
-- all copies or substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-- DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
with Ada.Containers.Indefinite_Vectors;
-- @description
-- This package provides an Angle type
--
package LSE.Utils.Angle is
-- Define max range of cycle in degree
Degrees_Cycle : constant Float := 360.00;
-- Type angle in range [0.00;359.99]
subtype Angle is Float range 0.00 .. 359.99;
package List is new Ada.Containers.Indefinite_Vectors (Natural, Angle);
-- Check if value passing in parameter is an angle
--
-- @param Value The value to check
-- @return Return True if the value is an angle, False otherwise
function Is_Angle (Value : String) return Boolean;
-- Convert a Float value in valid Angle
--
-- @param Value The to convert
-- @return Return the value in Angle
function To_Angle (Value : Float) return Angle;
end LSE.Utils.Angle;
|
sungyeon/drake | Ada | 1,916 | adb | with Ada;
with System.Stack;
with System.Storage_Elements.Formatting;
procedure stackoverflow is
package SSEF renames System.Storage_Elements.Formatting;
procedure Put_Stack_Range is
Stack_Top, Stack_Bottom : System.Address;
begin
System.Stack.Get (Top => Stack_Top, Bottom => Stack_Bottom);
Ada.Debug.Put ("top = " & SSEF.Image (Stack_Top));
Ada.Debug.Put ("here = " & SSEF.Image (Stack_Top'Address));
Ada.Debug.Put ("bottom = " & SSEF.Image (Stack_Bottom));
end Put_Stack_Range;
Count : Natural;
procedure Do_Overflow is
Big_Local : String (1 .. 1024 * 1024);
begin
Ada.Debug.Put ("enter");
Count := Count + 1;
-- begin jamming optimization before recursive
Big_Local (1 .. 3) := Integer'Image (-99);
-- end jamming optimization before recursive
Do_Overflow;
-- begin jamming optimization after recursive
if Integer'Value (Big_Local (1 .. 3)) /= -99 then
raise Program_Error;
end if;
-- end jamming optimization after recursive
Ada.Debug.Put ("leave");
end Do_Overflow;
Count_1, Count_2 : Natural;
begin
Put_Stack_Range;
Ada.Debug.Put ("**** try 1 ****");
Try_1 : begin
Count := 0;
Do_Overflow;
raise Program_Error;
exception
when Storage_Error =>
Ada.Debug.Put ("Storage_Error has raised on try 1");
Count_1 := Count;
end Try_1;
Ada.Debug.Put ("**** try 2 ****");
Try_2 : begin
Count := 0;
Do_Overflow;
raise Program_Error;
exception
when Storage_Error =>
Ada.Debug.Put ("Storage_Error has raised on try 2");
Count_2 := Count;
end Try_2;
pragma Assert (Count_1 = Count_2);
Ada.Debug.Put ("**** in task ****");
Try_Task : declare
task T;
task body T is
begin
Put_Stack_Range;
Ada.Debug.Put ("here is in task");
Do_Overflow;
exception
when Storage_Error =>
Ada.Debug.Put ("Storage_Error has raised in task");
end T;
begin
null;
end Try_Task;
pragma Debug (Ada.Debug.Put ("OK"));
end stackoverflow;
|
reznikmm/matreshka | Ada | 4,246 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Ada Modeling Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2011-2012, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
-- This file is generated, don't edit it.
------------------------------------------------------------------------------
-- Realization is a specialized abstraction relationship between two sets of
-- model elements, one representing a specification (the supplier) and the
-- other represents an implementation of the latter (the client). Realization
-- can be used to model stepwise refinement, optimizations, transformations,
-- templates, model synthesis, framework composition, etc.
------------------------------------------------------------------------------
with AMF.UML.Abstractions;
package AMF.UML.Realizations is
pragma Preelaborate;
type UML_Realization is limited interface
and AMF.UML.Abstractions.UML_Abstraction;
type UML_Realization_Access is
access all UML_Realization'Class;
for UML_Realization_Access'Storage_Size use 0;
end AMF.UML.Realizations;
|
tum-ei-rcs/StratoX | Ada | 3,177 | ads | -- This spec has been automatically generated from STM32F40x.svd
pragma Restrictions (No_Elaboration_Code);
pragma Ada_2012;
with HAL;
with System;
package STM32_SVD.IWDG is
pragma Preelaborate;
---------------
-- Registers --
---------------
-----------------
-- KR_Register --
-----------------
subtype KR_KEY_Field is HAL.Short;
-- Key register
type KR_Register is record
-- Write-only. Key value (write only, read 0000h)
KEY : KR_KEY_Field := 16#0#;
-- unspecified
Reserved_16_31 : HAL.Short := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for KR_Register use record
KEY at 0 range 0 .. 15;
Reserved_16_31 at 0 range 16 .. 31;
end record;
-----------------
-- PR_Register --
-----------------
subtype PR_PR_Field is HAL.UInt3;
-- Prescaler register
type PR_Register is record
-- Prescaler divider
PR : PR_PR_Field := 16#0#;
-- unspecified
Reserved_3_31 : HAL.UInt29 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for PR_Register use record
PR at 0 range 0 .. 2;
Reserved_3_31 at 0 range 3 .. 31;
end record;
------------------
-- RLR_Register --
------------------
subtype RLR_RL_Field is HAL.UInt12;
-- Reload register
type RLR_Register is record
-- Watchdog counter reload value
RL : RLR_RL_Field := 16#FFF#;
-- unspecified
Reserved_12_31 : HAL.UInt20 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for RLR_Register use record
RL at 0 range 0 .. 11;
Reserved_12_31 at 0 range 12 .. 31;
end record;
-----------------
-- SR_Register --
-----------------
-- Status register
type SR_Register is record
-- Read-only. Watchdog prescaler value update
PVU : Boolean;
-- Read-only. Watchdog counter reload value update
RVU : Boolean;
-- unspecified
Reserved_2_31 : HAL.UInt30;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for SR_Register use record
PVU at 0 range 0 .. 0;
RVU at 0 range 1 .. 1;
Reserved_2_31 at 0 range 2 .. 31;
end record;
-----------------
-- Peripherals --
-----------------
-- Independent watchdog
type IWDG_Peripheral is record
-- Key register
KR : KR_Register;
-- Prescaler register
PR : PR_Register;
-- Reload register
RLR : RLR_Register;
-- Status register
SR : SR_Register;
end record
with Volatile;
for IWDG_Peripheral use record
KR at 0 range 0 .. 31;
PR at 4 range 0 .. 31;
RLR at 8 range 0 .. 31;
SR at 12 range 0 .. 31;
end record;
-- Independent watchdog
IWDG_Periph : aliased IWDG_Peripheral
with Import, Address => IWDG_Base;
end STM32_SVD.IWDG;
|
zhmu/ananas | Ada | 381 | adb | with Loop_Optimization8_Pkg2;
package body Loop_Optimization8_Pkg1 is
Data : Loop_Optimization8_Pkg2.T
:= new Loop_Optimization8_Pkg2.Obj_T'(Length =>1, Elements => (1 => 1));
procedure Iter is
begin
for I in 1 .. Loop_Optimization8_Pkg2.Length (Data) loop
Action (Loop_Optimization8_Pkg2.Index (Data, I));
end loop;
end;
end Loop_Optimization8_Pkg1;
|
AdaCore/libadalang | Ada | 1,500 | ads | -- Check the handling of record variant parts in basic cases
package Pkg is
type Enum_Type is (A, B, C, D);
type Rec_1 (Disc : Enum_Type) is record
X1 : Boolean;
case Disc is
when A =>
X2 : Integer;
X3 : Character;
when B | C =>
X4 : Character;
case Disc is
when A =>
X5 : Integer;
when B =>
X6 : Character;
when C | D =>
X7 : Boolean;
end case;
when D =>
X8 : Integer;
end case;
end record;
pragma Test (A);
pragma Test (B);
pragma Test (C);
pragma Test (D);
type Rec_2 (N1, N2 : Natural) is record
S1 : String (1 .. N1);
S2 : String (1 .. N2);
end record;
pragma Test (0, 0);
pragma Test (10, 20);
pragma Test (-10, -20);
type Rec_3 (N : Natural) is record
case N is
when 0 .. 9 | 90 .. 99 =>
X1 : Integer;
when 900 | 902 .. 999 =>
X2 : Integer;
when others =>
null;
end case;
end record;
pragma Test (0);
pragma Test (9);
pragma Test (10);
pragma Test (89);
pragma Test (90);
pragma Test (91);
pragma Test (99);
pragma Test (100);
pragma Test (899);
pragma Test (900);
pragma Test (901);
pragma Test (902);
pragma Test (903);
pragma Test (998);
pragma Test (999);
pragma Test (1000);
end Pkg;
|
AdaCore/langkit | Ada | 9,234 | ads | --
-- Copyright (C) 2014-2022, AdaCore
-- SPDX-License-Identifier: Apache-2.0
--
with Ada.Containers; use Ada.Containers;
with Ada.Containers.Hashed_Maps;
with Ada.Unchecked_Deallocation;
with System;
with GNATCOLL.Traces;
with Langkit_Support.Hashes; use Langkit_Support.Hashes;
with Langkit_Support.Types; use Langkit_Support.Types;
with Langkit_Support.Vectors;
package Langkit_Support.Lexical_Envs is
type Lookup_Cache_Kind is (Disabled, Toplevel_Only, Full);
Lookup_Cache_Mode : Lookup_Cache_Kind := Full;
-- Lookup cache mode for the lexical envs.
--
-- ``Full`` means that every env.get request, including intermediate ones
-- happening as part of a user requested env.get, will be cached.
--
-- ``Toplevel_Only`` means that only top level requests, directly requested
-- by the user of the Lexical_Envs API, will be cached.
--
-- ``Disabled`` means no caching will happen.
--
-- This setting is for debugging: caching all requests is the normal mode
-- (maximum optimization), and the other modes reduce the amount of caching
-- done (less optimization, thus taking longer to run) to ease the
-- investigation of env caching bugs.
-------------
-- Traces --
-------------
-- Traces to debug lexical envs. Those traces are meant to be activated on
-- demand, when the client of lexical env wants more information about
-- this specific lookup.
Me : constant GNATCOLL.Traces.Trace_Handle :=
GNATCOLL.Traces.Create
("LANGKIT.LEXICAL_ENV", GNATCOLL.Traces.From_Config);
-- This is the main trace for lexical environments, providing a basic level
-- of logging for env.get requests.
Rec : constant GNATCOLL.Traces.Trace_Handle :=
GNATCOLL.Traces.Create
("LANGKIT.LEXICAL_ENV.RECURSIVE", GNATCOLL.Traces.From_Config);
-- This is the recursive trace, providing info about recursive internal
-- calls to env.get.
Caches_Trace : constant GNATCOLL.Traces.Trace_Handle :=
GNATCOLL.Traces.Create
("LANGKIT.LEXICAL_ENV.CACHES", GNATCOLL.Traces.From_Config);
-- This a trace to show caching information
Min : constant GNATCOLL.Traces.Trace_Handle :=
GNATCOLL.Traces.Create
("LANGKIT.LEXICAL_ENV_MINIMAL", GNATCOLL.Traces.From_Config);
-- This is a trace independent from the three last traces, that you can
-- activate separately, and that will provide you the most basic level of
-- logging for toplevel env.get requests.
function Has_Trace return Boolean is (Me.Active);
-----------------
-- Lexical_Env --
-----------------
type Lexical_Env_Kind is
(Static_Primary, Dynamic_Primary, Orphaned, Grouped, Rebound);
-- Kind of lexical environment. Tells how a lexical environment was
-- created.
--
-- Static_Primary ones are not ref-counted. Except for the special
-- Empty_Env and each context's root scope, they are created by lexical
-- environment population.
--
-- Dynamic_Primary are not ref-counted neither. They are created on-demand
-- during semantic analysis, but their life cycle is tied to their owning
-- analysis unit, just like Static_Primary envs. They carry no map, but
-- instead use a property reference to dynamically compute environment
-- associations (an array of Inner_Env_Assoc).
--
-- Orphaned ones are copies whose parents have been stripped.
--
-- Grouped ones are just a collection of environments glued together as if
-- they were only one environment.
--
-- Rebound ones are copies annotated with environment rebindings.
subtype Primary_Kind is
Lexical_Env_Kind range Static_Primary .. Dynamic_Primary;
type Base_Lexical_Env_Record is abstract tagged null record;
-- Root class of the lexical env type for all languages
type Generic_Lexical_Env_Ptr is access all Base_Lexical_Env_Record'Class;
-- Generic access to lexical environment records. The actual record type
-- depends on each language, hence the generic pointer.
No_Lexical_Env : constant Generic_Lexical_Env_Ptr := null;
type Generic_Unit_Ptr is new System.Address;
-- Likewise for analysis units
No_Generic_Unit : constant Generic_Unit_Ptr :=
Generic_Unit_Ptr (System.Null_Address);
type Lexical_Env is record
Env : Generic_Lexical_Env_Ptr;
-- Referenced lexical environment
Hash : Hash_Type;
-- Env's hash. We need to pre-compute it so that the value is available
-- even after Env is deallocated. This makes it possible to destroy a
-- hash table that contains references to deallocated environments.
Kind : Lexical_Env_Kind;
-- The kind of Env. When it is Primary, we can avoid calling Dec_Ref at
-- destruction time. This is useful because at analysis unit destruction
-- time, this may be a dangling access to an environment from another
-- unit.
Owner : Generic_Unit_Ptr := No_Generic_Unit;
-- Unit that owns this lexical environment. Only Primary and Rebound
-- lexical env will have a non-null value for this field.
Version : Version_Number := 0;
-- Version of the unit when this reference was made. Used to determine
-- whether this reference is valid or not.
end record;
-- Reference to a lexical environment. This is the type that shall be used.
Null_Lexical_Env : constant Lexical_Env :=
(No_Lexical_Env, 0, Static_Primary, No_Generic_Unit, 0);
type Lexical_Env_Array is array (Positive range <>) of Lexical_Env;
type Lexical_Env_Array_Access is access all Lexical_Env_Array;
procedure Destroy is new Ada.Unchecked_Deallocation
(Lexical_Env_Array, Lexical_Env_Array_Access);
function Is_Primary (Self : Lexical_Env) return Boolean
is (Self.Kind in Primary_Kind);
-- Return whether Self is a primary lexical environment
function Has_Lookup_Cache (Self : Lexical_Env) return Boolean
is
(Self.Kind = Static_Primary);
-- Whether lookup cache is available/enabled for the given lexical
-- environment.
function Hash (Env : Lexical_Env) return Hash_Type is (Env.Hash);
type Lookup_Kind_Type is (Recursive, Flat, Minimal);
--------------------
-- Env_Rebindings --
--------------------
type Env_Rebindings_Type;
type Env_Rebindings is access all Env_Rebindings_Type;
-- Set of mappings from one lexical environment to another. This is used to
-- temporarily substitute lexical environment during symbol lookup.
package Env_Rebindings_Vectors is new Langkit_Support.Vectors
(Env_Rebindings);
type Env_Rebindings_Type is record
-- Start of ABI area. In order to perform fast checks from foreign
-- languages, we maintain minimal ABI for env rebindings records: this
-- allows us in language bindings to directly peek in this record rather
-- than rely on (slow) calls to getters.
Version : Version_Number;
-- Allocated Env_Rebindings_Type records can be used multiple times
-- for a given analysis context. Each time we re-use one, we bump its
-- version number, so that we can reject the use of stale references.
-- End of ABI area
Parent : Env_Rebindings;
Old_Env, New_Env : Lexical_Env;
Children : Env_Rebindings_Vectors.Vector;
end record
with Convention => C;
-- Tree of remappings from one lexical environment (Old_Env) to another
-- (New_Env). Note that both referenced environments must be primary and
-- env rebindings are supposed to be destroyed when one of their
-- dependencies (Parent, Old_Env or New_Env) is destroyed, so there is no
-- need for ref-counting primitives.
function Hash is new Hashes.Hash_Access
(Env_Rebindings_Type, Env_Rebindings);
package Env_Rebindings_Pools is new Ada.Containers.Hashed_Maps
(Key_Type => Lexical_Env,
Element_Type => Env_Rebindings,
Hash => Hash,
Equivalent_Keys => "=",
"=" => "=");
type Env_Rebindings_Pool is access all Env_Rebindings_Pools.Map;
-- Pool of env rebindings to be stored in a lexical environment
procedure Destroy is new Ada.Unchecked_Deallocation
(Env_Rebindings_Pools.Map, Env_Rebindings_Pool);
-----------------------------
-- Referenced environments --
-----------------------------
type Ref_Kind is (Transitive, Prioritary, Normal);
-- Kind for a referenced env. Can be any of:
--
-- * Transitive: The reference is transitive, e.g. it will be explored in
-- every case (whether the lookup is recursive or not). It will be
-- explored *before* parent environments.
--
-- * Prioritary: The reference is non transitive, e.g. it will be
-- explored only if the lookup on the env is recursive. It will be
-- explored *before* parent environments.
--
-- * Normal: The reference is non transitive, e.g. it will be explored
-- only if the lookup on the env is recursive. It will be explored
-- *after* parent environments.
type Refd_Env_State is (Active, Inactive);
end Langkit_Support.Lexical_Envs;
|
johnperry-math/hac | Ada | 17,988 | adb | with HAC_Sys.Compiler;
with Ada.Strings.Fixed; use Ada.Strings, Ada.Strings.Fixed;
with Ada.Text_IO;
package body HAC_Sys.UErrors is
function Error_String (code : HAC_Sys.Defs.Compile_Error; hint : String := "") return String is
begin
case code is
when err_undefined_identifier =>
return "undefined identifier";
when err_duplicate_identifier =>
return "multiple definition of an identifier";
when err_identifier_missing =>
return "missing an identifier";
when err_missing_a_procedure_declaration =>
return "missing a procedure declaration";
when err_closing_parenthesis_missing =>
return "missing closing parenthesis "")""";
when err_colon_missing =>
return "missing a colon "":""";
when err_colon_missing_for_named_statement =>
return
"undefined identifier;" &
" if a named statement is meant, a colon "":"" would be expected here";
when err_incorrectly_used_symbol =>
return "incorrectly used symbol [" & hint & ']';
when err_missing_OF =>
return "missing ""of""";
when err_missing_an_opening_parenthesis =>
return "missing an opening parenthesis ""(""";
when err_left_bracket_instead_of_parenthesis =>
return "found '[' instead of '('";
when err_right_bracket_instead_of_parenthesis =>
return "found ']' instead of ')'";
when err_missing_ARRAY_RECORD_or_ident =>
return "missing identifer, ""array"" or ""record""";
when err_expecting_double_dot =>
return "expecting double dot symbol: ""..""";
when err_semicolon_missing =>
return "missing a semicolon "";""";
when err_extra_semicolon_ignored =>
return "extra "";"" ignored";
when err_bad_result_type_for_a_function =>
return "bad result type for a function";
when err_type_of_return_statement_doesnt_match =>
return "type of expression in return statement doesn't match: " & hint;
when err_illegal_statement_start_symbol =>
return "statement cannot start with a " & hint;
when err_expecting_a_boolean_expression =>
return "expecting a Boolean expression";
when err_control_variable_of_the_wrong_type =>
return "control variable of the wrong type: must be discrete";
when err_first_and_last_must_have_matching_types =>
return "first and last must have matching types";
when err_IS_missing =>
return "missing ""is""";
when err_number_too_large =>
return "number is too large: total actual exponent is " & hint;
when err_illegal_character_in_number =>
return "illegal character in number" & hint;
when err_negative_exponent_for_integer_literal =>
return "integer literal with negative exponent; suggestion: a float with "".0"" such as" & hint;
when err_incorrect_block_name =>
return """end " & hint & ";"" expected here";
when err_bad_type_for_a_case_statement =>
return "bad type for a case statement";
when err_illegal_character =>
return "illegal character";
when err_illegal_constant_or_constant_identifier =>
return "illegal constant or constant identifier";
when err_illegal_array_subscript =>
return "type mismatch in array subscript: " & hint;
when err_illegal_array_bounds =>
return "illegal bounds for an array index: " & hint;
when err_indexed_variable_must_be_an_array =>
return "indexed variable must be an array";
when err_missing_a_type_identifier =>
return "identifier is not a type";
when err_undefined_type =>
return "undefined type";
when err_var_with_field_selector_must_be_record =>
return "var with field selector must be record";
when err_resulting_type_should_be_Boolean =>
return "resulting type should be Boolean";
when err_illegal_type_for_arithmetic_expression =>
return "illegal type for arithmetic expression";
when err_mod_requires_integer_arguments =>
return """mod"" requires integer arguments";
when err_incompatible_types_for_comparison =>
return "incompatible types for comparison: " & hint;
when err_parameter_types_do_not_match =>
return "parameter types do not match: " & hint;
when err_variable_missing =>
return "missing a variable";
when err_character_zero_chars =>
return "a character literal is of the form 'x'; " &
"strings are delimited by double quote character";
when err_number_of_parameters_do_not_match =>
return "number of parameters do not match" & hint;
when err_illegal_parameters_to_Get =>
return "illegal parameters to ""Get""";
when err_illegal_parameters_to_Put =>
return "illegal parameters to ""Put""";
when err_parameter_must_be_of_type_Float =>
return "parameter must be of type Float";
when err_parameter_must_be_Integer =>
return "parameter must be of type Integer";
when err_expected_constant_function_variable_or_subtype =>
return "expected a constant, function, variable or subtype name";
when err_illegal_return_statement_from_main =>
return "ILLEGAL RETURN STATEMENT FROM MAIN";
when err_types_of_assignment_must_match =>
return "types must match in an assignment: " & hint;
when err_case_label_not_same_type_as_case_clause =>
return "case label not of same type as case clause";
when err_duplicate_case_choice_value =>
return "duplicate choice value in ""case"" instruction";
when err_argument_to_std_function_of_wrong_type =>
return "wrong type of argument to standard function: " & hint;
when err_stack_size =>
return "the program requires too much storage";
when err_illegal_symbol_for_a_number_declaration =>
return "illegal symbol for a number declaration or a literal";
when err_BECOMES_missing =>
return "missing "":=""";
when err_THEN_missing =>
return "missing ""then""";
when err_IN_missing =>
return "missing ""in""";
when err_closing_LOOP_missing =>
return "missing closing ""loop""";
when err_BEGIN_missing =>
return "missing ""begin""";
when err_END_missing =>
return "missing ""end""";
when err_factor_unexpected_symbol =>
return "factor: expecting an id, a constant, ""not"" or ""(""";
when err_RETURN_missing =>
return "missing ""return""";
when err_control_character =>
return "control character present in source ";
when err_RECORD_missing =>
return "missing ""record""";
when err_missing_closing_IF =>
return "missing closing ""if""";
when err_WHEN_missing =>
return "missing ""when"" (must have at least one alternative)";
when err_FINGER_missing =>
return "missing the finger ""=>""";
when err_missing_closing_CASE =>
return "missing closing ""case""";
when err_character_delimeter_used_for_string =>
return "character delimeter used for string; " &
"strings are delimited by double quote character";
when err_Ada_reserved_word =>
return "Ada reserved word; not supported";
when err_functions_must_return_a_value =>
return "functions must return a value";
when err_procedures_cannot_return_a_value =>
return "procedures cannot return a value (use functions instead)";
when err_WITH_Small_Sp =>
return "must specify ""with hac_pack;"" here";
when err_use_Small_Sp =>
return "must specify ""use hac_pack;"" here";
when err_missing_an_entry =>
return "expecting an entry";
when err_missing_expression_for_delay =>
return "missing expression for ""delay""";
when err_wrong_type_in_DELAY =>
return "delay time must be type Float";
when err_COMMA_missing =>
return "comma expected";
when err_expecting_accept_when_or_entry_id =>
return "expecting ""accept"", ""when"", or entry id";
when err_expecting_task_entry =>
return "expecting Task.Entry";
when err_expecting_OR_or_ELSE_in_SELECT =>
return "expecting ""or"" or ""else"" in select";
when err_expecting_DELAY =>
return "expecting ""delay""";
when err_SELECT_missing =>
return "missing ""select""";
when err_program_incomplete =>
return "program incomplete";
when err_OF_instead_of_IS =>
return "found ""of"", should be ""is""";
when err_THEN_instead_of_Arrow =>
return "found ""then"", should be ""=>""";
when err_EQUALS_instead_of_BECOMES =>
return "found ""="", should be "":=""";
when err_numeric_constant_expected =>
return "numeric constant expected";
when err_identifier_too_long =>
return "identifier """ & hint & "..."" is too long";
when err_identifier_cannot_end_with_underline =>
return "identifier cannot end with underline";
when err_double_underline_not_permitted =>
return "double underline not permitted";
when err_statement_expected =>
return "statement expected, can be ""null""";
when err_duplicate_label =>
return "label already defined: " & hint;
when err_invalid_power_operands =>
return "invalid operand types for the ""**"" operator";
when err_unexpected_end_of_text =>
return "unexpected end of text";
when err_not_yet_implemented =>
return "construct not yet correctly implemented or supported by HAC";
when err_type_conversion_not_supported =>
return "this type conversion is not supported: " & hint;
when err_numeric_type_coercion =>
return "numeric types don't match: " & hint & " - please use explicit conversion";
when err_numeric_type_coercion_operator =>
return "numeric types don't match (" &
hint (hint'First) & "): " & hint (hint'First + 1 .. hint'Last) &
" - please use explicit conversion";
when err_operator_not_defined_for_types =>
return "operator (" & hint (hint'First) &
") is not defined for those operand types: " &
hint (hint'First + 1 .. hint'Last);
when err_no_null_functions =>
return "a function cannot be null; only a procedure can";
when err_digit_expected =>
return "digit expected";
when err_expected_char_or_string =>
return "expected Character or String";
when err_cannot_modify_constant_or_in_parameter =>
return "cannot modify a constant or a ""in"" parameter" & hint;
when err_case_others_alone_last =>
return "the ""others"" choice must appear alone and in the last choice list (RM 5.4 (5))";
when err_END_LOOP_ident_missing =>
return """end loop " & hint & ";"" expected (RM 5.5 (5))";
when err_END_LOOP_ident_wrong =>
return "wrong loop identifier: ""end loop " & hint & ";"" expected";
when err_syntax_error =>
return "syntax error " & hint;
when err_string_to_vstring_assignment =>
return "fixed string assigned to a variable string;" &
" put a ""+"" in front of the fixed string";
when err_range_constraint_error =>
return "error in range constraint: " & hint;
end case;
end Error_String;
----------------------------------------------------------------------------
function "+" (S : String) return VString renames To_VString;
repair_table : constant array (Compile_Error) of Repair_kit :=
(
err_WITH_Small_Sp => (insert_line, +"with HAC_Pack; use HAC_Pack;"),
err_use_Small_Sp => (insert, +"use HAC_Pack; "),
err_missing_a_procedure_declaration
=> (insert, +"procedure "),
err_colon_missing => (insert, +": "),
err_semicolon_missing => (insert, +"; "),
err_RETURN_missing => (insert, +"return "),
err_statement_expected => (insert, +"null;"),
err_IN_missing => (insert, +"in "),
err_IS_missing => (insert, +"is "),
err_OF_instead_of_IS => (replace_token, +"is"),
err_THEN_instead_of_Arrow => (replace_token, +"=>"),
err_FINGER_missing => (insert, +" => "),
err_closing_LOOP_missing => (insert, +" loop"),
err_missing_closing_CASE => (insert, +" case"),
err_missing_closing_IF => (insert, +" if"),
err_closing_parenthesis_missing => (insert, +")"),
err_incorrect_block_name => (replace_token, +"[Error() puts identifier]"),
err_END_LOOP_ident_missing => (insert, +"[Error() puts identifier]"),
err_END_LOOP_ident_wrong => (replace_token, +"[Error() puts identifier]"),
err_EQUALS_instead_of_BECOMES => (replace_token, +":="),
others => nothing_to_repair
);
procedure Error (
CD : in out Compiler_Data;
code : Compile_Error;
hint : String := "";
stop : Boolean := False
)
is
use Ada.Text_IO;
--
procedure Show_to_comp_dump (
srcNumber, charStart, charEnd, objNumber : Integer;
hint_for_dump : String
)
is
begin
if CD.comp_dump_requested then
Put_Line
(CD.comp_dump,
" Error code = " &
Compile_Error'Image (code) &
" (" &
Error_String (code, hint_for_dump) &
") " &
" srcNumber=" &
Integer'Image (srcNumber) &
" charStart=" &
Integer'Image (charStart) &
" charEnd=" &
Integer'Image (charEnd) &
" objNumber=" &
Integer'Image (objNumber));
end if;
end Show_to_comp_dump;
--
updated_repair_kit : Repair_kit := repair_table (code);
ub_hint : constant VString := To_VString (hint);
use VStrings_Pkg;
begin
Show_to_comp_dump (CD.Line_Count, CD.syStart, CD.syEnd, -1, hint);
CD.Errs (code) := True;
CD.Err_Count := CD.Err_Count + 1;
if CD.error_pipe = null then
Put_Line (
Current_Error,
-- !! Ada "file" name here
Trim (Integer'Image (CD.Line_Count), Left) & ':' &
Trim (Integer'Image (CD.syStart), Left) & '-' &
Trim (Integer'Image (CD.syEnd), Left) & ": " &
Error_String (code, hint)
);
else
case code is
when err_incorrect_block_name =>
if hint = "" then
updated_repair_kit.kind := none;
else
updated_repair_kit.text := ub_hint;
end if;
when err_END_LOOP_ident_missing =>
updated_repair_kit.text := ' ' & ub_hint;
when err_END_LOOP_ident_wrong =>
updated_repair_kit.text := ub_hint;
when others =>
null;
end case;
CD.error_pipe (
message => Error_String (code, hint),
file_name => Compiler.Get_Current_Source_Name (CD),
line => CD.Line_Count,
column_a => CD.syStart,
column_z => CD.syEnd,
kind => error,
repair => updated_repair_kit
);
end if;
-- Uncomment the next line for getting a nice trace-back of 1st error.
-- raise Constraint_Error;
if stop then
raise Compilation_abandoned;
end if;
end Error;
----------------------------------------------------------------------------
procedure Fatal (N : Table_OverFlow_Error; Current_Error_Output : Boolean := False) is
use Ada.Text_IO;
begin
if Current_Error_Output then
Put (Current_Error, "The Compiler TABLE for: *");
case N is
when FLOAT_CONSTANTS => Put (Current_Error, "Float Constants");
when STRING_CONSTANTS => Put (Current_Error, "Strings Constants");
when Object_Code => Put (Current_Error, "Object Code");
when PATCHING => Put (Current_Error, "ObjCode PATCHING");
when others => Put (Current_Error, Table_OverFlow_Error'Image (N));
end case;
Put_Line (Current_Error, "* is too SMALL");
New_Line (Current_Error);
Put_Line (Current_Error, " Please take this output to the maintainers of ");
Put_Line (Current_Error, " HAC for your installation ");
New_Line (Current_Error);
Put_Line (Current_Error, " Fatal termination of HAC");
end if;
--
raise Failure_1_0 with
"HAC.UErrors.Fatal:" &
" internal HAC compiler error." &
" The table for " &
Table_OverFlow_Error'Image (N) &
" is too small. More details with qDebug=True";
end Fatal;
----------------------------------------------------------------------------
procedure Compilation_Errors_Summary (CD : Compiler_Data) is
use Ada.Text_IO;
begin
if CD.comp_dump_requested then
New_Line (CD.comp_dump);
Put_Line (CD.comp_dump, "==== Error MESSAGE(S) ====");
end if;
if CD.listing_requested then
New_Line (CD.listing);
Put_Line (CD.listing, "==== Error MESSAGE(S) ====");
end if;
for K in CD.Errs'Range loop
if CD.Errs (K) then
if CD.comp_dump_requested then
Put_Line (Compile_Error'Image (K) & ": " & Error_String (K, ""));
-- Should be Error_hint(K,n) !!
end if;
if CD.listing_requested then
Put_Line (CD.listing, Compile_Error'Image (K) & " " & Error_String (K, ""));
-- Should be Error_hint(K,n) !!
end if;
end if;
end loop;
end Compilation_Errors_Summary;
end HAC_Sys.UErrors;
|
zhmu/ananas | Ada | 135 | ads | package Array29 is
type Matrix is array (Integer range <>, Integer range <>) of Long_Float;
procedure Proc;
end Array29;
|
MinimSecure/unum-sdk | Ada | 1,039 | adb | -- Copyright 2015-2016 Free Software Foundation, Inc.
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program. If not, see <http://www.gnu.org/licenses/>.
with Pck; use Pck;
procedure Bar_O203_012 is
type Int_Access is access Integer;
type Record_Type is record
IA : Int_Access;
end record;
R : Record_Type;
IA : Int_Access;
begin
R.IA := new Integer'(3); -- STOP
IA := R.IA;
Do_Nothing (R'Address);
Do_Nothing (IA'Address);
end Bar_O203_012;
|
AdaCore/libadalang | Ada | 291 | adb | package body Test is
task body T is
type S;
type P is access S;
type S is null record;
procedure H (X : P) is
TS : P := X;
pragma Test_Statement;
begin
null;
end H;
begin
null;
end T;
end Test;
|
Rodeo-McCabe/orka | Ada | 1,233 | adb | -- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2017 onox <[email protected]>
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
package body Orka.Atomics is
protected body Counter is
procedure Add (Addition : Natural) is
begin
Value := Value + Addition;
end Add;
procedure Increment is
begin
Value := Value + 1;
end Increment;
procedure Decrement (Zero : out Boolean) is
begin
Value := Value - 1;
Zero := Value = 0;
end Decrement;
procedure Reset is
begin
Value := Initial_Value;
end Reset;
function Count return Natural is (Value);
end Counter;
end Orka.Atomics;
|
kontena/ruby-packer | Ada | 3,080 | ads | ------------------------------------------------------------------------------
-- --
-- GNAT ncurses Binding Samples --
-- --
-- ncurses --
-- --
-- B O D Y --
-- --
------------------------------------------------------------------------------
-- Copyright (c) 2000 Free Software Foundation, Inc. --
-- --
-- Permission is hereby granted, free of charge, to any person obtaining a --
-- copy of this software and associated documentation files (the --
-- "Software"), to deal in the Software without restriction, including --
-- without limitation the rights to use, copy, modify, merge, publish, --
-- distribute, distribute with modifications, sublicense, and/or sell --
-- copies of the Software, and to permit persons to whom the Software is --
-- furnished to do so, subject to the following conditions: --
-- --
-- The above copyright notice and this permission notice shall be included --
-- in all copies or substantial portions of the Software. --
-- --
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS --
-- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF --
-- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. --
-- IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, --
-- DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR --
-- OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR --
-- THE USE OR OTHER DEALINGS IN THE SOFTWARE. --
-- --
-- Except as contained in this notice, the name(s) of the above copyright --
-- holders shall not be used in advertising or otherwise to promote the --
-- sale, use or other dealings in this Software without prior written --
-- authorization. --
------------------------------------------------------------------------------
-- Author: Eugene V. Melaragno <[email protected]> 2000
-- Version Control
-- $Revision: 1.1 $
-- Binding Version 01.00
------------------------------------------------------------------------------
with Terminal_Interface.Curses;
procedure ncurses2.flushinp_test (win : Terminal_Interface.Curses.Window);
|
Rodeo-McCabe/orka | Ada | 8,449 | ads | -- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2020 onox <[email protected]>
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-- Based on Jonathan Dupuy's C++ LEB demo [1]. GLSL shaders of LEB library
-- and shaders for rendering of terrain are licensed under the MIT license.
--
-- Contributions:
--
-- * Initialize LEB buffers in a compute shader instead of on the CPU
--
-- * Avoid C implementation of LEB library and reuse the LEB GLSL code
-- to create a static meshlet on the GPU when rendering the terrain
--
-- * Update and render multiple terrain tiles. Use heuristics to
-- determine on the CPU which tiles need to be updated and rendered.
--
-- * Support flattened spheroids with warping to reduce RMSE when
-- projecting cubes on spheres.
--
-- [1] https://github.com/jdupuy/LongestEdgeBisectionDemos
with GL.Objects.Textures;
with GL.Types;
with Orka.Cameras;
with Orka.Rendering.Buffers;
with Orka.Rendering.Programs.Modules;
with Orka.Resources.Locations;
with Orka.Timers;
private with GL.Low_Level.Enums;
private with GL.Objects.Samplers;
private with Orka.Rendering.Programs.Uniforms;
private with Orka.Types;
package Orka.Features.Terrain is
pragma Preelaborate;
type Subdivision_Depth is range 0 .. 29;
type Meshlet_Subdivision_Depth is range 0 .. 3;
type Length_Target is range 2 .. 32;
type LoD_Deviation is digits 4 range 0.0 .. 1.0;
type Height_Scale is digits 4 range 0.0 .. 1.0;
type Subdivision_Parameters is record
Meshlet_Subdivision : Meshlet_Subdivision_Depth;
Edge_Length_Target : Length_Target;
Min_LoD_Standard_Dev : LoD_Deviation;
end record;
type Spheroid_Parameters is array (Positive range 1 .. 4) of GL.Types.Single;
type Visible_Tile_Array is array (Positive range <>) of Boolean;
-----------------------------------------------------------------------------
type Terrain (Count : Positive) is tagged limited private;
function Create_Terrain
(Count : Positive;
Min_Depth, Max_Depth : Subdivision_Depth;
Scale : Height_Scale;
Wireframe : Boolean;
Location : Resources.Locations.Location_Ptr;
Render_Modules : Rendering.Programs.Modules.Module_Array;
Initialize_Render : access procedure
(Program : Rendering.Programs.Program)) return Terrain
with Pre => Min_Depth <= Max_Depth and Max_Depth >= 5;
-- Create and return a Terrain object that can generate
-- one or more terrain tiles
--
-- If Wireframe is True, then optionally a wireframe can be displayed
-- when rendering the terrain. In production, this parameter should
-- be set to False to avoid invoking a geometry shader.
--
-- One of the shaders in the module array must contain the following
-- function:
--
-- vec4 ShadeFragment(vec2 texCoord, vec4 worldPos);
procedure Render
(Object : in out Terrain;
Transforms, Spheres : Rendering.Buffers.Bindable_Buffer'Class;
Center : Cameras.Transforms.Matrix4;
Camera : Cameras.Camera_Ptr;
Parameters : Subdivision_Parameters;
Visible_Tiles : Visible_Tile_Array;
Update_Render : access procedure (Program : Rendering.Programs.Program);
Height_Map : GL.Objects.Textures.Texture;
Freeze, Wires : Boolean;
Timer_Update, Timer_Render : in out Orka.Timers.Timer)
with Pre => Transforms.Length = Object.Count
and Spheres.Length in Spheroid_Parameters'Length | Spheroid_Parameters'Length * Object.Count
and Visible_Tiles'Length = Object.Count;
-- Generate and render the terrain tiles
--
-- Buffer Transforms should contain matrices which transform the
-- terrain tiles.
--
-- Buffer Spheres should contain n spheroid parameters (each containing
-- 4 singles) for n terrain tiles if the sphere is flattened or 1 spheroid
-- parameters if all the tiles are part of a non-flattened sphere.
--
-- Center should contain a translation from the camera to the center
-- of the sphere. It should be scaled if the semi-major axis in the
-- spheroid parameters in Spheres is scaled.
--
-- If Freeze is True, then the generated terrain will not be
-- modified.
--
-- If Wires is True and if parameter Wireframe of function Create_Terrain
-- was True, then a wireframe will be displayed. If Wireframe was False,
-- then Wires has no effect.
function Get_Spheroid_Parameters
(Semi_Major_Axis : GL.Types.Single;
Flattening : GL.Types.Single := 0.0;
Side : Boolean := True) return Spheroid_Parameters;
-- Return the spheroid parameters needed to project a flat
-- terrain tile on a (non-)flattened sphere.
--
-- The returned spheroid parameters should be put in a buffer that
-- is given to the procedure Render above.
--
-- If the terrain tiles are part of a non-flattened sphere, then
-- this function can be called once with Flattening = 0.0.
--
-- If the sphere is flattened, this function needs to be called twice.
-- The returned spheroid parameters must be repeated 4 times for the
-- tiles on the side and 2 times for the top and bottom tiles.
--
-- If the semi-major axis is scaled, then the translation in Center
-- in the procedure Render should be scaled as well.
private
package LE renames GL.Low_Level.Enums;
type UInt_Buffer_Array is array (Positive range <>) of
Rendering.Buffers.Buffer (Types.UInt_Type);
type Terrain (Count : Positive) is tagged limited record
Max_Depth : Subdivision_Depth;
Scale : Height_Scale;
Split_Update : Boolean;
Wireframe : Boolean;
-- Update and reduction of LEB
Program_Leb_Update : Rendering.Programs.Program;
Program_Leb_Prepass : Rendering.Programs.Program;
Program_Leb_Reduction : Rendering.Programs.Program;
-- Prepare indirect commands and render geometry
Program_Indirect : Rendering.Programs.Program;
Program_Render : Rendering.Programs.Program;
Uniform_Update_Split : Rendering.Programs.Uniforms.Uniform (LE.Bool_Type);
Uniform_Update_Freeze : Rendering.Programs.Uniforms.Uniform (LE.Bool_Type);
Uniform_Update_LoD_Var : Rendering.Programs.Uniforms.Uniform (LE.Single_Type);
Uniform_Update_LoD_Factor : Rendering.Programs.Uniforms.Uniform (LE.Single_Type);
Uniform_Update_DMap_Factor : Rendering.Programs.Uniforms.Uniform (LE.Single_Type);
Uniform_Render_DMap_Factor : Rendering.Programs.Uniforms.Uniform (LE.Single_Type);
Uniform_Update_Leb_ID : Rendering.Programs.Uniforms.Uniform (LE.Int_Type);
Uniform_Indirect_Leb_ID : Rendering.Programs.Uniforms.Uniform (LE.Int_Type);
Uniform_Render_Leb_ID : Rendering.Programs.Uniforms.Uniform (LE.Int_Type);
Uniform_Prepass_Pass_ID : Rendering.Programs.Uniforms.Uniform (LE.Int_Type);
Uniform_Reduction_Pass_ID : Rendering.Programs.Uniforms.Uniform (LE.Int_Type);
Uniform_Indirect_Subdiv : Rendering.Programs.Uniforms.Uniform (LE.Int_Type);
Uniform_Render_Subdiv : Rendering.Programs.Uniforms.Uniform (LE.Int_Type);
-- Sampler for height and slope maps
Sampler : GL.Objects.Samplers.Sampler;
-- SSBO
Buffer_Draw : Rendering.Buffers.Buffer (Types.Arrays_Command_Type);
Buffer_Dispatch : Rendering.Buffers.Buffer (Types.Dispatch_Command_Type);
Buffer_Leb : UInt_Buffer_Array (1 .. Count);
Buffer_Leb_Nodes : UInt_Buffer_Array (1 .. Count);
Buffer_Leb_Node_Counter : Rendering.Buffers.Buffer (Types.UInt_Type);
-- UBO
Buffer_Matrices : Rendering.Buffers.Buffer (Types.Single_Matrix_Type);
end record;
end Orka.Features.Terrain;
|
reznikmm/matreshka | Ada | 19,168 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Localization, Internationalization, Globalization for Ada --
-- --
-- Tools Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2010-2011, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Ada.Characters.Conversions;
with Ada.Characters.Handling;
with GNAT.Regpat;
with Asis.Declarations;
with Asis.Definitions;
with Asis.Elements;
with Asis.Expressions;
with Asis.Iterator;
with Asis.Statements;
with Asis.Text;
package body Scanner_Extractor is
type State_Information is record
States : Boolean := False;
end record;
procedure Process_Constant_Declaration
(Element : Asis.Element;
State : in out State_Information);
procedure Process_Integer_Number_Declaration (Element : Asis.Element);
procedure Process_Case_Statement (Element : Asis.Element);
procedure Pre_Operation
(Element : Asis.Element;
Control : in out Asis.Traverse_Control;
State : in out State_Information);
procedure Post_Operation
(Element : Asis.Element;
Control : in out Asis.Traverse_Control;
State : in out State_Information) is null;
procedure Iterate is new Asis.Iterator.Traverse_Element (State_Information);
function To_Upper (Item : Wide_String) return Wide_String;
-------------
-- Extract --
-------------
procedure Extract (Element : Asis.Element) is
Control : Asis.Traverse_Control := Asis.Continue;
State : State_Information;
begin
Iterate (Element, Control, State);
end Extract;
-------------------
-- Pre_Operation --
-------------------
procedure Pre_Operation
(Element : Asis.Element;
Control : in out Asis.Traverse_Control;
State : in out State_Information) is
begin
case Asis.Elements.Element_Kind (Element) is
when Asis.A_Declaration =>
case Asis.Elements.Declaration_Kind (Element) is
when Asis.A_Constant_Declaration =>
Process_Constant_Declaration (Element, State);
when Asis.An_Integer_Number_Declaration =>
Process_Integer_Number_Declaration (Element);
when others =>
null;
end case;
when Asis.A_Statement =>
case Asis.Elements.Statement_Kind (Element) is
when Asis.A_Case_Statement =>
Process_Case_Statement (Element);
when others =>
null;
end case;
when others =>
null;
end case;
end Pre_Operation;
----------------------------
-- Process_Case_Statement --
----------------------------
procedure Process_Case_Statement (Element : Asis.Element) is
use type Asis.Expression_Kinds;
procedure Process_Choice
(Choice : Asis.Element;
Line : Positive;
File : Ada.Strings.Wide_Unbounded.Unbounded_Wide_String;
Text : Unbounded_Wide_String_Vectors.Vector);
--------------------
-- Process_Choice --
--------------------
procedure Process_Choice
(Choice : Asis.Element;
Line : Positive;
File : Ada.Strings.Wide_Unbounded.Unbounded_Wide_String;
Text : Unbounded_Wide_String_Vectors.Vector)
is
use type Ada.Strings.Wide_Unbounded.Unbounded_Wide_String;
Number : Natural;
begin
case Asis.Elements.Expression_Kind (Choice) is
when Asis.An_Integer_Literal =>
Number :=
Integer'Wide_Value (Asis.Expressions.Value_Image (Choice));
when Asis.A_Function_Call =>
declare
Parameters_1 : constant Asis.Element_List :=
Asis.Expressions.Function_Call_Parameters (Choice);
Parameters_2 : constant Asis.Element_List :=
Asis.Expressions.Function_Call_Parameters
(Asis.Expressions.Actual_Parameter (Parameters_1 (1)));
Parameter_2 : constant Wide_String :=
To_Upper
(Asis.Expressions.Name_Image
(Asis.Expressions.Actual_Parameter (Parameters_2 (2))));
begin
Number := YY_End_Of_Buffer;
for J in 1 .. Natural (State_Constants.Length) loop
if State_Constants.Element (J).Name = Parameter_2 then
Number :=
Number + State_Constants.Element (J).Value + 1;
end if;
end loop;
end;
when others =>
null;
end case;
-- Skip jam state
if Number /= YY_End_Of_Buffer - 1 then
if Natural (Choices.Length) < Number then
Choices.Set_Length (Ada.Containers.Count_Type (Number));
end if;
Choices.Replace_Element
(Number, (False, Number, Line, File, Text));
end if;
end Process_Choice;
Expression : constant Asis.Element :=
Asis.Statements.Case_Expression (Element);
Paths : constant Asis.Element_List :=
Asis.Statements.Statement_Paths (Element);
begin
if Asis.Elements.Expression_Kind (Expression) = Asis.An_Identifier
and then To_Upper (Asis.Expressions.Name_Image (Expression)) = "YY_ACT"
then
for J in Paths'Range loop
declare
Choices : constant Asis.Element_List :=
Asis.Statements.Case_Statement_Alternative_Choices
(Paths (J));
Lines : constant Asis.Text.Line_List :=
Asis.Text.Lines (Paths (J));
Pattern : GNAT.Regpat.Pattern_Matcher :=
GNAT.Regpat.Compile ("--# line (\d+) ""(.*?)""");
Matched : Boolean := False;
Empty : Boolean := True;
Matches : GNAT.Regpat.Match_Array (0 .. 2);
Text : Unbounded_Wide_String_Vectors.Vector;
Line : Positive;
File : Ada.Strings.Wide_Unbounded.Unbounded_Wide_String;
begin
for J in Lines'Range loop
declare
Line_Image : constant Wide_String :=
Asis.Text.Line_Image (Lines (J));
begin
if not Matched then
GNAT.Regpat.Match
(Pattern,
Ada.Characters.Conversions.To_String (Line_Image),
Matches);
if Matches (0).First /= 0 then
Matched := True;
Line :=
Positive'Wide_Value
(Line_Image
(Matches (1).First .. Matches (1).Last));
File :=
Ada.Strings.Wide_Unbounded.To_Unbounded_Wide_String
(Line_Image
(Matches (2).First .. Matches (2).Last));
end if;
else
if Empty then
Empty := Line_Image'Length = 0;
end if;
if not Empty then
Text.Append
(Ada.Strings.Wide_Unbounded.To_Unbounded_Wide_String
(Line_Image));
end if;
end if;
end;
end loop;
if not Text.Is_Empty then
for J in Choices'Range loop
Process_Choice (Choices (J), Line, File, Text);
end loop;
end if;
end;
end loop;
end if;
end Process_Case_Statement;
----------------------------------
-- Process_Constant_Declaration --
----------------------------------
procedure Process_Constant_Declaration
(Element : Asis.Element;
State : in out State_Information)
is
Names : Asis.Element_List := Asis.Declarations.Names (Element);
procedure Process_Array
(Declaration : Asis.Element;
Expression : Asis.Element;
Values : out Integer_Vectors.Vector);
procedure Process_Plane
(Expression : Asis.Element;
Values : out Integer_Vectors.Vector);
-------------------
-- Process_Array --
-------------------
procedure Process_Array
(Declaration : Asis.Element;
Expression : Asis.Element;
Values : out Integer_Vectors.Vector)
is
Bounds : constant Asis.Element_List :=
Asis.Definitions.Discrete_Subtype_Definitions (Declaration);
Upper : constant Natural :=
Natural'Wide_Value
(Asis.Expressions.Value_Image
(Asis.Definitions.Upper_Bound (Bounds (1))));
Components : constant Asis.Element_List :=
Asis.Expressions.Array_Component_Associations (Expression);
begin
Values.Set_Length (Ada.Containers.Count_Type (Upper + 1));
for J in Components'Range loop
Values.Replace_Element
(J - 1,
Natural'Wide_Value
(Asis.Expressions.Value_Image
(Asis.Expressions.Component_Expression (Components (J)))));
end loop;
end Process_Array;
-------------------
-- Process_Plane --
-------------------
procedure Process_Plane
(Expression : Asis.Element;
Values : out Integer_Vectors.Vector)
is
Components : constant Asis.Element_List :=
Asis.Expressions.Array_Component_Associations (Expression);
begin
Values.Set_Length (256);
for J in Components'Range loop
Values.Replace_Element
(J - 1,
Natural'Wide_Value
(Asis.Expressions.Value_Image
(Asis.Expressions.Component_Expression (Components (J)))));
end loop;
end Process_Plane;
begin
for J in Names'Range loop
declare
Image : constant Wide_String :=
To_Upper (Asis.Declarations.Defining_Name_Image (Names (J)));
Declaration : constant Asis.Element :=
Asis.Declarations.Object_Declaration_View (Element);
Expression : constant Asis.Element :=
Asis.Declarations.Initialization_Expression (Element);
begin
if Image = "INITIAL" then
State.States := True;
State_Constants.Append
((Ada.Strings.Wide_Unbounded.To_Unbounded_Wide_String (Image),
Integer'Wide_Value
(Asis.Expressions.Value_Image (Expression))));
elsif Image = "YY_ACCEPT" then
State.States := False;
Process_Array (Declaration, Expression, YY_Accept);
elsif Image = "YY_META" then
Process_Array (Declaration, Expression, YY_Meta);
elsif Image = "YY_BASE" then
Process_Array (Declaration, Expression, YY_Base);
elsif Image = "YY_DEF" then
Process_Array (Declaration, Expression, YY_Def);
elsif Image = "YY_NXT" then
Process_Array (Declaration, Expression, YY_Nxt);
elsif Image = "YY_CHK" then
Process_Array (Declaration, Expression, YY_Chk);
elsif Image = "YY_EC_BASE" then
declare
Components : constant Asis.Element_List :=
Asis.Expressions.Array_Component_Associations (Expression);
begin
for J in Components'Range loop
declare
Choices : constant Asis.Element_List :=
Asis.Expressions.Array_Component_Choices
(Components (J));
Image : constant Wide_String :=
Asis.Expressions.Name_Image
(Asis.Expressions.Prefix
(Asis.Expressions.Component_Expression
(Components (J))));
Ref : Natural :=
Natural'Wide_Value (Image (7 .. Image'Last));
begin
for J in Choices'Range loop
case Asis.Elements.Expression_Kind (Choices (J)) is
when Asis.An_Integer_Literal =>
YY_EC_Base.Append
((Natural'Wide_Value
(Asis.Expressions.Value_Image
(Choices (J))),
Ref));
when others =>
null;
end case;
case Asis.Elements.Definition_Kind (Choices (J)) is
when Asis.An_Others_Choice =>
YY_EC_Base_Others := Ref;
when others =>
null;
end case;
end loop;
end;
end loop;
end;
elsif Image'Length > 6 and then Image (1 .. 6) = "YY_EC_" then
declare
Data : Plane_Information;
begin
Data.Number := Natural'Wide_Value (Image (7 .. Image'Last));
Process_Plane (Expression, Data.Values);
YY_EC_Planes.Append (Data);
end;
elsif State.States then
State_Constants.Append
((Ada.Strings.Wide_Unbounded.To_Unbounded_Wide_String (Image),
Integer'Wide_Value
(Asis.Expressions.Value_Image (Expression))));
end if;
end;
end loop;
end Process_Constant_Declaration;
----------------------------------------
-- Process_Integer_Number_Declaration --
----------------------------------------
procedure Process_Integer_Number_Declaration (Element : Asis.Element) is
Names : Asis.Element_List := Asis.Declarations.Names (Element);
begin
for J in Names'Range loop
declare
Image : constant Wide_String :=
To_Upper (Asis.Declarations.Defining_Name_Image (Names (J)));
Expression : constant Asis.Element :=
Asis.Declarations.Initialization_Expression (Element);
begin
if Image = "YY_END_OF_BUFFER" then
YY_End_Of_Buffer :=
Integer'Wide_Value
(Asis.Expressions.Value_Image (Expression));
elsif Image = "YY_JAMSTATE" then
YY_Jam_State :=
Integer'Wide_Value
(Asis.Expressions.Value_Image (Expression));
elsif Image = "YY_JAMBASE" then
YY_Jam_Base :=
Integer'Wide_Value
(Asis.Expressions.Value_Image (Expression));
elsif Image = "YY_FIRST_TEMPLATE" then
YY_First_Template :=
Integer'Wide_Value
(Asis.Expressions.Value_Image (Expression));
end if;
end;
end loop;
end Process_Integer_Number_Declaration;
--------------
-- To_Upper --
--------------
function To_Upper (Item : Wide_String) return Wide_String is
begin
return
Ada.Characters.Conversions.To_Wide_String
(Ada.Characters.Handling.To_Upper
(Ada.Characters.Conversions.To_String (Item)));
end To_Upper;
end Scanner_Extractor;
|
jscparker/math_packages | Ada | 9,608 | ads |
-- package Clenshaw
--
-- Clenshaw's formula is used to evaluate functions Q_k (X), and
-- summations over functions Q_k (X), where the functions Q_k (X)
-- are defined by recurrance relations of the sort:
--
-- Q_0 = some given function of X
-- Q_1 = Alpha(1, X) * Q_0(X)
-- Q_k = Alpha(k, X) * Q_k-1(X) + Beta(k, X) * Q_k-2(X) (k > 1)
--
-- The procedure "Sum" evaluates the sum
-- n
-- F_n(X) = SUM ( C_k * Q_k(X) )
-- k=0
--
-- where the coefficients C_k are given quantities, like Alpha, Beta, Q_0, Q_1.
-- Procedure "Evaluate_Qs" calculates the function Q_k, a special case
-- of the sum above. Clenshaw's method is usually more accurate and less
-- unstable than direct summations of F_n.
--
-- The most common application of this algorithm is in the construction
-- of orthogonal polynomials and their sums. But notice that the functions
-- functions Q_k need not be orthogonal, and they need not be polynomials.
-- In most cases, though, the Q_k are orthogonal polynomials.
-- Common cases are Hermite, Laguerre, Chebychev, Legendre,
-- and Gegenbauer polynomials.
--
-- WARNING:
--
-- These functions are not the same as the Gram-Schmidt polynomials.
-- Gram-Schmidt polys are orthogonal on a discrete set of points, and
-- form a complete for function defined on that discrete set of points.
-- The orthogonality of the following functions is respect integration on
-- an interval, not summation over a discrete set of points. So these
-- functions don't form a complete set on a discrete set of points
-- (unlike the discrete polys generated by a gram-schmidt method, or
-- the sinusoids in a discrete Fourier transform.)
--
-- EXAMPLES.
--
-- Chebychev Polynomials of the first kind:
-- Q_0(X) = 1
-- Q_1(X) = X
-- Q_k(X) = 2X*Q_k-1(X) - Q_k-2(X) (k > 1)
-- Alpha(k,X) = 2*X (k > 1)
-- Alpha(k,X) = X (k = 1)
-- Beta(k,X) = -1
-- They are orthogonal on the interval (-1,1) with
-- weight function W(X) = 1.0 / SQRT(1 - X*X).
-- Normalizing integral: Integral(Q_n(X) * Q_n(X) * W(X)) = Pi/2 for n>0
-- Normalizing integral: Integral(Q_n(X) * Q_n(X) * W(X)) = Pi for n=0
--
-- Chebychev Polynomials of the 2nd kind:
-- Q_0(X) = 1
-- Q_1(X) = 2*X
-- Q_k(X) = 2X*Q_k-1(X) - Q_k-2(X)
-- Alpha(k,X) = 2*X
-- Beta(k,X) = -1
-- They are orthogonal on the interval (-1,1) with
-- weight function W(X) = SQRT(1 - X*X).
-- Normalizing integral: Integral(Q_n(X) * Q_n(X) * W(X)) = Pi/2
--
-- Legendre: Q_0(X) = 1
-- Q_1(X) = X
-- Q_k(X) = ((2*k-1)/k)*X*Q_k-1(X) - ((k-1)/k)*Q_k-2(X)
-- Alpha(k,X) = X*(2*k-1)/k
-- Beta(k,X) = -(k-1)/k
-- They are orthogonal on the interval [-1,1] with
-- weight function W(X) = 1.
-- Normalizing integral: Integral(Q_n(X) * Q_n(X) * W(X)) = 2/(2n+1)
--
-- Associated Legendre(m, k): ( k must be greater than m-1 )
-- Q_m(X) = (-1)**m * (2m-1)!! * Sqrt(1-X*X)**m
-- Q_m+1(X) = X * (2*m + 1) * Q_m(X)
-- Q_k(X) = ((2*k-1)/(k-m))*X*Q_k-1(X) - ((k-1+m)/(k-m))*Q_k-2(X)
-- Alpha(k,X) = X*(2*k-1)/(k-m)
-- Beta(k,X) = -(k-1+m)/k
-- They are orthogonal on the interval [-1,1] with
-- weight function W(X) = 1.
-- Normalizing integral:
-- Integral(Q_n(X) * Q_n(X) * W(X)) = 2*(n+m)! / (2*n+1)*(n-m)!)
--
-- Hermite: Q_0(X) = 1
-- Q_1(X) = 2*X
-- Q_k(X) = 2*X*Q_k-1(X) - 2*(k-1)*Q_k-2(X)
-- Alpha(k,X) = 2*X
-- Beta(k,X) = -2*(k-1)
-- They are orthogonal on the interval (-infinity, infinity) with
-- weight function W(X) = Exp (-X*X).
-- Normalizing integral: Integral (Q_n(X)*Q_n(X)*W(X)) = n!(2**n)*Sqrt(Pi)
--
-- Laguerre: Q_0(X) = 1
-- Q_1(X) = 1 - X
-- Q_k(X) = (2*k - 1 - X)*Q_k-1(X) - (k-1)*(k-1)*Q_k-2(X)
-- Alpha(k,X) = 2*k - 1 - X
-- Beta(k,X) = -(k-1)*(k-1)
-- They are orthogonal on the interval (0,infinity) with
-- weight function Exp(-X).
-- Normalizing integral: Integral (Q_n(X)*Q_n(X)*W(X)) = Gamma(n+1)/n!
--
-- Generalized Laguerre:
-- Q_0(X) = 1
-- Q_1(X) = 1 - X
-- Q_k(X) = ((2*k-1+a-X)/k)*Q_k-1(X) - ((k-1+a)/k)*Q_k-2(X)
-- Alpha(k,X) = (2*k - 1 + a - X) / k
-- Beta(k,X) = -(k - 1 + a) / k
-- They are orthogonal on the interval (0,infinity) with
-- weight function W(X) = (X**a)*Exp(-X).
-- Normalizing integral: Integral (Q_n(X)*Q_n(X)*W(X)) = Gamma(n+a+1)/n!
--
--
-- procedure Evaluate_Qs
--
-- The procedure calculates the value of functions Q_k at points
-- X for each k in 0..Poly_ID. These are returned in the array
-- Q in the range 0..PolyID.
--
-- In most cases only the value of Q_k (X) at k = Poly_ID is desired. This
-- is returned as Q(k), where k = Poly_ID, the ID of the desired function.
-- The values of the other Q's are returned (in the same array
-- Q, at the appropriate index) because they are calculated along the
-- way, and may be useful also.
--
-- WARNING:
--
-- The functions Q_k generated by this routine are usually
-- *un-normalized*. Frequently, values of the normalized Q_k
-- are desired. The normalization factors are not given
-- by this package. They are given in most cases by the
-- procedures that use this package, and by standard reference
-- sources. These factors are usually k dependent, so you
-- must multiply each element of Q(1..Poly_ID) by a different
-- number to get an array of values of the normalized functions.
--
-- function Sum
--
-- This function sums the functions Q_k (at X) with coefficients given
-- by the array C. The result is returned as the function value.
-- This function is also a fast and efficient way of getting the
-- value of Q_k at X. Just let C = 0 everywhere, except at k. Let
-- the of C at k be C(k) = 1.0. then the function returns Q_k(X).
--
-- Notes on the algorithm.
--
-- We want to evaluate
-- n
-- F_n(X) = SUM ( C_k * Q_k(X) )
-- k=0
--
-- where Q is defined by
--
-- Q_k = Alpha(k, X) * Q_k-1 + Beta(k, X) * Q_k-2 (k > 1)
--
-- This package calculates F_n by the following formula
--
-- (*) F_n(X) = D_0*Q_0(X) + D_1*(Q_1(X) - Alpha(1,X)*Q_0(X)).
--
-- where the D_k are functions of X that satisfy:
--
-- D_n+2 = 0
-- D_n+1 = 0
-- D_k = C_k + Alpha(k+1,X) * D_k+1(X) + Beta(k+2,X) * D_k+2(X)
--
-- The proof of (*) is straightforward. Solve for C_k in the equation for
-- D_k above and plug it into the sum that defines F_n to get
--
-- n
-- F_n = SUM (D_k - Alpha(k+1)*D_k+1 - Beta(k+1)*D_k+2 ) * Q_k
-- k=0
-- n
-- F_n = D_0*Q_0 + D_1*Q_1 + SUM ( D_k * Q_k )
-- k=2
-- n
-- -Alpha(1)*D_1*Q_0 + SUM (-Alpha(k) * D_k * Q_k-1 )
-- k=2
-- n
-- + SUM (-Beta(k) * D_k * Q_k-2 ).
-- k=2
--
-- Now factor out D_k from the three SUM terms above, and notice
-- that what remains is just the recurrance relation that defines
-- Q_k for k > 0. It evaluates to zero, leaving
--
-- F_n(X) = D_0*Q_0(X)
--
-- (It should be clear that this process can be easily generalized
-- to recurrance relations in which Q_k depends on the previous 3 Q's.
--
-- Q_0 = some given function of X
-- Q_1 = some given function of X
-- Q_2 = some given function of X
-- Q_k = Alpha(k,X)*Q_k-1(X) + Beta(k,X)*Q_k-2(k,X) + Gamma*Q_k-3(X)
--
-- The SUM's above should start at k=3, but the derivation is identical.)
--
-- Finally notice that in special cases this simplifies further.
-- In many cases, particularly the orthogonal polynomials,
-- Q_0 is 1, so that F_n = D_0.
--
generic
type Real is digits <>;
-- Package only sums functions of real variables.
type Base_Poly_Index_Type is range <>;
Poly_Limit : Base_Poly_Index_Type;
with function Alpha
(k : Base_Poly_Index_Type;
Parameter : Real;
X : Real)
return Real;
with function Beta
(k : Base_Poly_Index_Type;
Parameter : Real;
X : Real)
return Real;
with function Q_0
(Parameter : Real;
X : Real)
return Real;
package Clenshaw is
subtype Poly_ID_Type is Base_Poly_Index_Type range 0 .. Poly_Limit;
-- The index k. k always starts a 0.
type Poly_Values is array(Poly_ID_Type) of Real;
procedure Evaluate_Qs
(X : in Real;
Q : in out Poly_Values;
Max_Poly_ID : in Poly_ID_Type;
P : in Real := 0.0;
No_Of_Iterations : in Positive := 1);
-- Get Q_0(X), Q_1(X) ... Q_m(X) where m = Max_Poly_ID.
-- P is the parameter in Alpha and Beta.
type Coefficients is array(Poly_ID_Type) of Real;
function Sum
(X : in Real;
C : in Coefficients;
Sum_Limit : in Poly_ID_Type;
P : in Real := 0.0;
No_Of_Iterations : in Positive := 1)
return Real;
-- Sum the polys Q times the Coefficients: SUM (Q_k * C_k)
-- P is the parameter in Alpha and Beta.
end Clenshaw;
|
reznikmm/matreshka | Ada | 5,036 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Web Framework --
-- --
-- Tools Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2015, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Asis.Expressions;
with Asis.Statements;
package body Properties.Statements.Assignment_Statement is
------------
-- Bounds --
------------
function Bounds
(Engine : access Engines.Contexts.Context;
Element : Asis.Expression;
Name : Engines.Text_Property) return League.Strings.Universal_String
is
Left : constant Asis.Expression :=
Asis.Statements.Assignment_Variable_Name (Element);
begin
return Engine.Text.Get_Property (Left, Name);
end Bounds;
----------
-- Code --
----------
function Code
(Engine : access Engines.Contexts.Context;
Element : Asis.Expression;
Name : Engines.Text_Property) return League.Strings.Universal_String
is
Left : constant Asis.Expression :=
Asis.Statements.Assignment_Variable_Name (Element);
Right : constant Asis.Expression :=
Asis.Statements.Assignment_Expression (Element);
Text : League.Strings.Universal_String;
Down : League.Strings.Universal_String;
Left_Type : constant Asis.Element :=
Asis.Expressions.Corresponding_Expression_Type (Left);
Is_Simple_Type : constant Boolean :=
Engine.Boolean.Get_Property (Left_Type, Engines.Is_Simple_Type);
begin
Text := Engine.Text.Get_Property (Left, Name);
Down := Engine.Text.Get_Property (Right, Name);
if Is_Simple_Type then
Text.Append (" = ");
Text.Append (Down);
else
Text.Append ("._assign(");
Text.Append (Down);
Text.Append (")");
end if;
Text.Append (";");
return Text;
end Code;
end Properties.Statements.Assignment_Statement;
|
stcarrez/ada-ado | Ada | 2,026 | adb | -----------------------------------------------------------------------
-- ado-testsuite -- Testsuite for ADO
-- Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2018, 2022 Stephane Carrez
-- Written by Stephane Carrez ([email protected])
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with ADO.Tests;
with ADO.Drivers.Tests;
with ADO.Sequences.Tests;
with ADO.Schemas.Tests;
with ADO.Objects.Tests;
with ADO.Queries.Tests;
with ADO.Parameters.Tests;
with ADO.Datasets.Tests;
with ADO.Statements.Tests;
with ADO.Audits.Tests;
with ADO.SQL.Tests;
package body ADO.Testsuite is
procedure Drivers (Suite : in Util.Tests.Access_Test_Suite);
procedure Drivers (Suite : in Util.Tests.Access_Test_Suite) is separate;
Tests : aliased Util.Tests.Test_Suite;
function Suite return Util.Tests.Access_Test_Suite is
Ret : constant Util.Tests.Access_Test_Suite := Tests'Access;
begin
ADO.Drivers.Tests.Add_Tests (Ret);
ADO.Parameters.Tests.Add_Tests (Ret);
ADO.Sequences.Tests.Add_Tests (Ret);
ADO.Objects.Tests.Add_Tests (Ret);
ADO.Statements.Tests.Add_Tests (Ret);
ADO.Tests.Add_Tests (Ret);
ADO.Schemas.Tests.Add_Tests (Ret);
Drivers (Ret);
ADO.Queries.Tests.Add_Tests (Ret);
ADO.Datasets.Tests.Add_Tests (Ret);
ADO.Audits.Tests.Add_Tests (Ret);
ADO.SQL.Tests.Add_Tests (Ret);
return Ret;
end Suite;
end ADO.Testsuite;
|
tum-ei-rcs/StratoX | Ada | 74 | adb | with Mission;
procedure main is
begin
Mission.run_Mission;
end main;
|
google-code/ada-util | Ada | 2,117 | ads | -----------------------------------------------------------------------
-- util-encodes-tests - Test for encoding
-- Copyright (C) 2009, 2010, 2011, 2012 Stephane Carrez
-- Written by Stephane Carrez ([email protected])
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Util.Tests;
package Util.Encoders.Tests is
procedure Add_Tests (Suite : in Util.Tests.Access_Test_Suite);
type Test is new Util.Tests.Test with null record;
procedure Test_Hex (T : in out Test);
procedure Test_Base64_Encode (T : in out Test);
procedure Test_Base64_Decode (T : in out Test);
procedure Test_Base64_URL_Encode (T : in out Test);
procedure Test_Base64_URL_Decode (T : in out Test);
procedure Test_Encoder (T : in out Test;
C : in out Util.Encoders.Encoder);
procedure Test_Base64_Benchmark (T : in out Test);
procedure Test_SHA1_Encode (T : in out Test);
-- Benchmark test for SHA1
procedure Test_SHA1_Benchmark (T : in out Test);
-- Test HMAC-SHA1
procedure Test_HMAC_SHA1_RFC2202_T1 (T : in out Test);
procedure Test_HMAC_SHA1_RFC2202_T2 (T : in out Test);
procedure Test_HMAC_SHA1_RFC2202_T3 (T : in out Test);
procedure Test_HMAC_SHA1_RFC2202_T4 (T : in out Test);
procedure Test_HMAC_SHA1_RFC2202_T5 (T : in out Test);
procedure Test_HMAC_SHA1_RFC2202_T6 (T : in out Test);
procedure Test_HMAC_SHA1_RFC2202_T7 (T : in out Test);
-- Test encoding leb128.
procedure Test_LEB128 (T : in out Test);
end Util.Encoders.Tests;
|
reznikmm/matreshka | Ada | 3,754 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with XML.DOM.Attributes;
package ODF.DOM.Table_Base_Cell_Address_Attributes is
pragma Preelaborate;
type ODF_Table_Base_Cell_Address_Attribute is limited interface
and XML.DOM.Attributes.DOM_Attribute;
type ODF_Table_Base_Cell_Address_Attribute_Access is
access all ODF_Table_Base_Cell_Address_Attribute'Class
with Storage_Size => 0;
end ODF.DOM.Table_Base_Cell_Address_Attributes;
|
tum-ei-rcs/StratoX | Ada | 745 | adb | with Ada.Real_Time; use Ada.Real_Time;
package body Helper with SPARK_Mode is
function addWrap(x : Numeric_Type;
inc : Numeric_Type) return Numeric_Type
is
begin
if x + inc > Numeric_Type'Last then
return x + inc - Numeric_Type'Last;
else
return x + inc;
end if;
end addWrap;
procedure delay_ms( ms : Natural) is
current_time : constant Ada.Real_Time.Time := Ada.Real_Time.Clock;
begin
delay until current_time + Ada.Real_Time.Milliseconds( ms );
end delay_ms;
subtype Balance_Type is Float range -1.0 .. 1.0;
pragma Unreferenced (Balance_Type);
--function mix( channel_a : Float; channel_b : Float; balance : Balance_Type);
end Helper;
|
sparre/Command-Line-Parser-Generator | Ada | 945 | ads | -- Copyright: JSA Research & Innovation <[email protected]>
-- License: Beer Ware
pragma License (Unrestricted);
with Ada.Containers.Hashed_Maps;
with Command_Line_Parser_Generator.Identifier_Set,
Wide_Unbounded_Equal_Case_Insensitive,
Wide_Unbounded_Hash_Case_Insensitive;
package Command_Line_Parser_Generator.Identifier_Matrix is
use type Source_Text;
use type Identifier_Set.Instance;
package Maps is new Ada.Containers.Hashed_Maps
(Key_Type => Source_Text,
Element_Type => Identifier_Set.Instance,
Hash => Wide_Unbounded_Hash_Case_Insensitive,
Equivalent_Keys => Wide_Unbounded_Equal_Case_Insensitive);
type Instance is new Maps.Map with null record;
procedure Append (Container : in out Instance;
Key : in Source_Text;
Value : in Source_Text);
end Command_Line_Parser_Generator.Identifier_Matrix;
|
shaggie76/Aristophanes | Ada | 12,824 | ads | ------------------------------------------------------------------------------
-- ZLib for Ada thick binding. --
-- --
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
-- --
-- This library is free software; you can redistribute it and/or modify --
-- it under the terms of the GNU General Public License as published by --
-- the Free Software Foundation; either version 2 of the License, or (at --
-- your option) any later version. --
-- --
-- This library is distributed in the hope that it will be useful, but --
-- WITHOUT ANY WARRANTY; without even the implied warranty of --
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU --
-- General Public License for more details. --
-- --
-- You should have received a copy of the GNU General Public License --
-- along with this library; if not, write to the Free Software Foundation, --
-- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. --
-- --
-- As a special exception, if other files instantiate generics from this --
-- unit, or you link this unit with other files to produce an executable, --
-- this unit does not by itself cause the resulting executable to be --
-- covered by the GNU General Public License. This exception does not --
-- however invalidate any other reasons why the executable file might be --
-- covered by the GNU Public License. --
------------------------------------------------------------------------------
-- $Id: zlib.ads,v 1.17 2003/08/12 13:19:07 vagul Exp $
with Ada.Streams;
with Interfaces;
package ZLib is
ZLib_Error : exception;
type Compression_Level is new Integer range -1 .. 9;
type Flush_Mode is private;
type Compression_Method is private;
type Window_Bits_Type is new Integer range 8 .. 15;
type Memory_Level_Type is new Integer range 1 .. 9;
type Unsigned_32 is new Interfaces.Unsigned_32;
type Strategy_Type is private;
type Header_Type is (None, Auto, Default, GZip);
-- Header type usage have a some limitation for inflate.
-- See comment for Inflate_Init.
subtype Count is Ada.Streams.Stream_Element_Count;
----------------------------------
-- Compression method constants --
----------------------------------
Deflated : constant Compression_Method;
-- Only one method allowed in this ZLib version.
---------------------------------
-- Compression level constants --
---------------------------------
No_Compression : constant Compression_Level := 0;
Best_Speed : constant Compression_Level := 1;
Best_Compression : constant Compression_Level := 9;
Default_Compression : constant Compression_Level := -1;
--------------------------
-- Flush mode constants --
--------------------------
No_Flush : constant Flush_Mode;
-- Regular way for compression, no flush
Partial_Flush : constant Flush_Mode;
-- will be removed, use Z_SYNC_FLUSH instead
Sync_Flush : constant Flush_Mode;
-- all pending output is flushed to the output buffer and the output
-- is aligned on a byte boundary, so that the decompressor can get all
-- input data available so far. (In particular avail_in is zero after the
-- call if enough output space has been provided before the call.)
-- Flushing may degrade compression for some compression algorithms and so
-- it should be used only when necessary.
Full_Flush : constant Flush_Mode;
-- all output is flushed as with SYNC_FLUSH, and the compression state
-- is reset so that decompression can restart from this point if previous
-- compressed data has been damaged or if random access is desired. Using
-- FULL_FLUSH too often can seriously degrade the compression.
Finish : constant Flush_Mode;
-- Just for tell the compressor that input data is complete.
------------------------------------
-- Compression strategy constants --
------------------------------------
-- RLE stategy could be used only in version 1.2.0 and later.
Filtered : constant Strategy_Type;
Huffman_Only : constant Strategy_Type;
RLE : constant Strategy_Type;
Default_Strategy : constant Strategy_Type;
Default_Buffer_Size : constant := 4096;
type Filter_Type is limited private;
-- The filter is for compression and for decompression.
-- The usage of the type is depend of its initialization.
function Version return String;
pragma Inline (Version);
-- Return string representation of the ZLib version.
procedure Deflate_Init
(Filter : in out Filter_Type;
Level : in Compression_Level := Default_Compression;
Strategy : in Strategy_Type := Default_Strategy;
Method : in Compression_Method := Deflated;
Window_Bits : in Window_Bits_Type := 15;
Memory_Level : in Memory_Level_Type := 8;
Header : in Header_Type := Default);
-- Compressor initialization.
-- When Header parameter is Auto or Default, then default zlib header
-- would be provided for compressed data.
-- When Header is GZip, then gzip header would be set instead of
-- default header.
-- When Header is None, no header would be set for compressed data.
procedure Inflate_Init
(Filter : in out Filter_Type;
Window_Bits : in Window_Bits_Type := 15;
Header : in Header_Type := Default);
-- Decompressor initialization.
-- Default header type mean that ZLib default header is expecting in the
-- input compressed stream.
-- Header type None mean that no header is expecting in the input stream.
-- GZip header type mean that GZip header is expecting in the
-- input compressed stream.
-- Auto header type mean that header type (GZip or Native) would be
-- detected automatically in the input stream.
-- Note that header types parameter values None, GZip and Auto is
-- supporting for inflate routine only in ZLib versions 1.2.0.2 and later.
-- Deflate_Init is supporting all header types.
procedure Close
(Filter : in out Filter_Type;
Ignore_Error : in Boolean := False);
-- Closing the compression or decompressor.
-- If stream is closing before the complete and Ignore_Error is False,
-- The exception would be raised.
generic
with procedure Data_In
(Item : out Ada.Streams.Stream_Element_Array;
Last : out Ada.Streams.Stream_Element_Offset);
with procedure Data_Out
(Item : in Ada.Streams.Stream_Element_Array);
procedure Generic_Translate
(Filter : in out Filter_Type;
In_Buffer_Size : in Integer := Default_Buffer_Size;
Out_Buffer_Size : in Integer := Default_Buffer_Size);
-- Compressing/decompressing data arrived from Data_In routine
-- to the Data_Out routine. User should provide Data_In and Data_Out
-- for compression/decompression data flow.
-- Compression or decompression depend on initialization of Filter.
function Total_In (Filter : in Filter_Type) return Count;
pragma Inline (Total_In);
-- Return total number of input bytes read so far.
function Total_Out (Filter : in Filter_Type) return Count;
pragma Inline (Total_Out);
-- Return total number of bytes output so far.
function CRC32
(CRC : in Unsigned_32;
Data : in Ada.Streams.Stream_Element_Array)
return Unsigned_32;
pragma Inline (CRC32);
-- Calculate CRC32, it could be necessary for make gzip format.
procedure CRC32
(CRC : in out Unsigned_32;
Data : in Ada.Streams.Stream_Element_Array);
pragma Inline (CRC32);
-- Calculate CRC32, it could be necessary for make gzip format.
-------------------------------------------------
-- Below is more complex low level routines. --
-------------------------------------------------
procedure Translate
(Filter : in out Filter_Type;
In_Data : in Ada.Streams.Stream_Element_Array;
In_Last : out Ada.Streams.Stream_Element_Offset;
Out_Data : out Ada.Streams.Stream_Element_Array;
Out_Last : out Ada.Streams.Stream_Element_Offset;
Flush : in Flush_Mode);
-- Compressing/decompressing the datas from In_Data buffer to the
-- Out_Data buffer.
-- In_Data is incoming data portion,
-- In_Last is the index of last element from In_Data accepted by the
-- Filter.
-- Out_Data is the buffer for output data from the filter.
-- Out_Last is the last element of the received data from Filter.
-- To tell the filter that incoming data is complete put the
-- Flush parameter to FINISH.
function Stream_End (Filter : in Filter_Type) return Boolean;
pragma Inline (Stream_End);
-- Return the true when the stream is complete.
procedure Flush
(Filter : in out Filter_Type;
Out_Data : out Ada.Streams.Stream_Element_Array;
Out_Last : out Ada.Streams.Stream_Element_Offset;
Flush : in Flush_Mode);
pragma Inline (Flush);
-- Flushing the data from the compressor.
generic
with procedure Write
(Item : in Ada.Streams.Stream_Element_Array);
-- User should provide this routine for accept
-- compressed/decompressed data.
Buffer_Size : in Ada.Streams.Stream_Element_Offset
:= Default_Buffer_Size;
-- Buffer size for Write user routine.
procedure Write
(Filter : in out Filter_Type;
Item : in Ada.Streams.Stream_Element_Array;
Flush : in Flush_Mode);
-- Compressing/Decompressing data from Item to the
-- generic parameter procedure Write.
-- Output buffer size could be set in Buffer_Size generic parameter.
generic
with procedure Read
(Item : out Ada.Streams.Stream_Element_Array;
Last : out Ada.Streams.Stream_Element_Offset);
-- User should provide data for compression/decompression
-- thru this routine.
Buffer : in out Ada.Streams.Stream_Element_Array;
-- Buffer for keep remaining data from the previous
-- back read.
Rest_First, Rest_Last : in out Ada.Streams.Stream_Element_Offset;
-- Rest_First have to be initialized to Buffer'Last + 1
-- before usage.
procedure Read
(Filter : in out Filter_Type;
Item : out Ada.Streams.Stream_Element_Array;
Last : out Ada.Streams.Stream_Element_Offset);
-- Compressing/Decompressing data from generic parameter
-- procedure Read to the Item.
-- User should provide Buffer for the operation
-- and Rest_First variable first time initialized to the Buffer'Last + 1.
private
use Ada.Streams;
type Flush_Mode is new Integer range 0 .. 4;
type Compression_Method is new Integer range 8 .. 8;
type Strategy_Type is new Integer range 0 .. 3;
No_Flush : constant Flush_Mode := 0;
Sync_Flush : constant Flush_Mode := 2;
Full_Flush : constant Flush_Mode := 3;
Finish : constant Flush_Mode := 4;
Partial_Flush : constant Flush_Mode := 1;
-- will be removed, use Z_SYNC_FLUSH instead
Filtered : constant Strategy_Type := 1;
Huffman_Only : constant Strategy_Type := 2;
RLE : constant Strategy_Type := 3;
Default_Strategy : constant Strategy_Type := 0;
Deflated : constant Compression_Method := 8;
type Z_Stream;
type Z_Stream_Access is access all Z_Stream;
type Filter_Type is record
Strm : Z_Stream_Access;
Compression : Boolean;
Stream_End : Boolean;
Header : Header_Type;
CRC : Unsigned_32;
Offset : Stream_Element_Offset;
-- Offset for gzip header/footer output.
Opened : Boolean := False;
end record;
end ZLib;
|
onox/dcf-ada | Ada | 7,597 | ads | -- SPDX-License-Identifier: MIT
--
-- Contributed by ITEC - NXP Semiconductors
-- June 2008
--
-- Copyright (c) 2008 - 2018 Gautier de Montmollin (maintainer)
-- SWITZERLAND
--
-- Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in
-- all copies or substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-- THE SOFTWARE.
-- The DCF.Streams package defines an abstract stream
-- type, Root_Zipstream_Type, with name, time and an index for random access.
--
-- In addition, this package provides two ready-to-use derivations:
--
-- - Array_Zipstream, for using in-memory streaming
-- - File_Zipstream, for accessing files
private with Ada.Finalization;
with Ada.Streams.Stream_IO;
with Ada.Strings.Unbounded;
use Ada.Streams;
use Ada.Strings.Unbounded;
package DCF.Streams is
pragma Preelaborate;
type Time is private;
-- We define an own Time (Ada.Calendar's body can be very time-consuming!)
-- See child package Calendar for own Split, Time_Of and Convert from/to
-- Ada.Calendar.Time.
Default_Time : constant Time; -- Some default time
------------------------------------------------------
-- Root_Zipstream_Type: root abstract stream type --
------------------------------------------------------
type Root_Zipstream_Type is abstract new Ada.Streams.Root_Stream_Type with private;
type Zipstream_Class_Access is access all Root_Zipstream_Type'Class;
subtype Zs_Size_Type is Integer_64 range 0 .. Integer_64'Last;
subtype Zs_Index_Type is Zs_Size_Type range 1 .. Zs_Size_Type'Last;
-- Set the index on the stream
procedure Set_Index (S : in out Root_Zipstream_Type; To : Zs_Index_Type) is abstract;
-- Returns the index of the stream
function Index (S : in Root_Zipstream_Type) return Zs_Index_Type is abstract;
-- Returns the Size of the stream
function Size (S : in Root_Zipstream_Type) return Zs_Size_Type is abstract;
procedure Set_Name (S : in out Root_Zipstream_Type; Name : String; UTF_8 : Boolean := False);
-- This procedure returns the name of the stream
function Get_Name (S : in Root_Zipstream_Type) return String;
function UTF_8_Encoding (S : in Root_Zipstream_Type) return Boolean;
-- This procedure sets the Modification_Time of the stream
procedure Set_Time (S : in out Root_Zipstream_Type; Modification_Time : Time);
-- This procedure returns the ModificationTime of the stream
function Get_Time (S : in Root_Zipstream_Type) return Time;
-- Returns true if the index is at the end of the stream, else false
function End_Of_Stream (S : in Root_Zipstream_Type) return Boolean is abstract;
----------------------------------------------
-- File_Zipstream: stream based on a file --
----------------------------------------------
type File_Zipstream is new Root_Zipstream_Type with private;
type File_Mode is new Ada.Streams.Stream_IO.File_Mode;
function Open (File_Name : String) return File_Zipstream;
-- Open a file for reading
function Create (File_Name : String) return File_Zipstream;
-- Create a file on the disk
--------------------------------------------------------------
-- Array_Zipstream: stream based on a Stream_Element_Array --
--------------------------------------------------------------
type Array_Zipstream
(Elements : not null access Stream_Element_Array) is new Root_Zipstream_Type with private;
-----------------------------------------------------------------------------
subtype Dos_Time is Unsigned_32;
function Convert (Date : in Dos_Time) return Time;
function Convert (Date : in Time) return Dos_Time;
private
-- Time. Currently, DOS format (pkzip appnote.txt: part V., J.), as stored
-- in Zip archives. Subject to change, this is why this type is private.
type Time is new Unsigned_32;
Default_Time : constant Time := 16789 * 65536;
type Root_Zipstream_Type is abstract new Ada.Streams.Root_Stream_Type with record
Name : Unbounded_String;
Modification_Time : Time := Default_Time;
UTF_8 : Boolean := False;
end record;
-----------------------------------------------------------------------------
type Open_File is limited new Ada.Finalization.Limited_Controlled with record
File : Ada.Streams.Stream_IO.File_Type;
Finalized : Boolean := False;
end record;
overriding
procedure Finalize (Object : in out Open_File);
-----------------------------------------------------------------------------
type File_Zipstream is new Root_Zipstream_Type with record
File : Open_File;
end record;
-- Read data from the stream
overriding
procedure Read
(Stream : in out File_Zipstream;
Item : out Stream_Element_Array;
Last : out Stream_Element_Offset);
-- Write data to the stream, starting from the current index.
-- Data will be overwritten from index if already available.
overriding
procedure Write (Stream : in out File_Zipstream; Item : Stream_Element_Array);
-- Set the index on the stream
overriding
procedure Set_Index (S : in out File_Zipstream; To : Zs_Index_Type);
-- Returns the index of the stream
overriding
function Index (S : in File_Zipstream) return Zs_Index_Type;
-- Returns the Size of the stream
overriding
function Size (S : in File_Zipstream) return Zs_Size_Type;
-- Returns true if the index is at the end of the stream
overriding
function End_Of_Stream (S : in File_Zipstream) return Boolean;
-----------------------------------------------------------------------------
type Array_Zipstream
(Elements : not null access Stream_Element_Array) is new Root_Zipstream_Type with
record
Index : Stream_Element_Offset := Elements'First;
EOF : Boolean := False;
end record;
overriding
procedure Read
(Stream : in out Array_Zipstream;
Item : out Stream_Element_Array;
Last : out Stream_Element_Offset);
overriding
procedure Write
(Stream : in out Array_Zipstream;
Item : Stream_Element_Array);
overriding
procedure Set_Index (Stream : in out Array_Zipstream; To : Zs_Index_Type);
overriding
function Index (Stream : in Array_Zipstream) return Zs_Index_Type is
(Zs_Index_Type (Stream.Index));
overriding
function Size (Stream : in Array_Zipstream) return Zs_Size_Type is
(Zs_Size_Type (Stream.Elements'Length));
overriding
function End_Of_Stream (Stream : in Array_Zipstream) return Boolean is
(Stream.Size < Index (Stream));
end DCF.Streams;
|
mikequentel/c2ada | Ada | 6,947 | adb | with Ada.Unchecked_Conversion;
with Interfaces;
package body gccs.Ops is
function "and" (I1, I2: Char) return Char is
begin
return To_Signed(To_Unsigned(I1) and To_Unsigned(I2));
end "and";
function "and" (I1, I2: Short) return Short is
begin
return To_Signed(To_Unsigned(I1) and To_Unsigned(I2));
end "and";
function "and" (I1, I2: Int) return Int is
begin
return To_Signed(To_Unsigned(I1) and To_Unsigned(I2));
end "and";
function "and" (I1, I2: Long) return Long is
begin
return To_Signed(To_Unsigned(I1) and To_Unsigned(I2));
end "and";
function "or" (I1, I2: Char) return Char is
begin
return To_Signed(To_Unsigned(I1) or To_Unsigned(I2));
end "or";
function "or" (I1, I2: Short) return Short is
begin
return To_Signed(To_Unsigned(I1) or To_Unsigned(I2));
end "or";
function "or" (I1, I2: Int) return Int is
begin
return To_Signed(To_Unsigned(I1) or To_Unsigned(I2));
end "or";
function "or" (I1, I2: Long) return Long is
begin
return To_Signed(To_Unsigned(I1) or To_Unsigned(I2));
end "or";
function "xor" (I1, I2: Char) return Char is
begin
return To_Signed(To_Unsigned(I1) xor To_Unsigned(I2));
end "xor";
function "xor" (I1, I2: Short) return Short is
begin
return To_Signed(To_Unsigned(I1) xor To_Unsigned(I2));
end "xor";
function "xor" (I1, I2: Int) return Int is
begin
return To_Signed(To_Unsigned(I1) xor To_Unsigned(I2));
end "xor";
function "xor" (I1, I2: Long) return Long is
begin
return To_Signed(To_Unsigned(I1) xor To_Unsigned(I2));
end "xor";
function "not" (I1: Char) return Char is
begin
return To_Signed(not To_Unsigned(I1));
end "not";
function "not" (I1: Short) return Short is
begin
return To_Signed(not To_Unsigned(I1));
end "not";
function "not" (I1: Int) return Int is
begin
return To_Signed(not To_Unsigned(I1));
end "not";
function "not" (I1: Long) return Long is
begin
return To_Signed(not To_Unsigned(I1));
end "not";
package I renames Interfaces;
-- this would have to change on a machine with 64 bit integers.
function U8 is new Ada.Unchecked_Conversion (Uchar, I.Unsigned_8);
function U16 is new Ada.Unchecked_Conversion (Ushort, I.Unsigned_16);
function U32 is new Ada.Unchecked_Conversion (Uint, I.Unsigned_32);
function U32 is new Ada.Unchecked_Conversion (Ulong, I.Unsigned_32);
function UC is new Ada.Unchecked_Conversion (I.Unsigned_8, Uchar);
function US is new Ada.Unchecked_Conversion (I.Unsigned_16, Ushort);
function UI is new Ada.Unchecked_Conversion (I.Unsigned_32, Uint);
function UL is new Ada.Unchecked_Conversion (I.Unsigned_32, Ulong);
function Shift_Left (Value: Uchar; Amount: Natural)
return Unsigned_Char is
begin
return UC(I.Shift_Left(U8(Value), Amount));
end Shift_Left;
function Shift_Left (Value: Ushort; Amount: Natural)
return Unsigned_Short is
begin
return US(I.Shift_Left(U16(Value), Amount));
end Shift_Left;
function Shift_Left (Value: Uint; Amount: Natural)
return Unsigned_Int is
begin
return UI(I.Shift_Left(U32(Value), Amount));
end Shift_Left;
function Shift_Left (Value: Ulong; Amount: Natural)
return Unsigned_Long is
begin
return UL(I.Shift_Left(U32(Value), Amount));
end Shift_Left;
function Shift_Right (Value: Uchar; Amount: Natural)
return Unsigned_Char is
begin
return UC(I.Shift_Right(U8(Value), Amount));
end Shift_Right;
function Shift_Right (Value: Ushort; Amount: Natural)
return Unsigned_Short is
begin
return US(I.Shift_Right(U16(Value), Amount));
end Shift_Right;
function Shift_Right (Value: Uint; Amount: Natural)
return Unsigned_Int is
begin
return UI(I.Shift_Right(U32(Value), Amount));
end Shift_Right;
function Shift_Right (Value: Ulong; Amount: Natural)
return Unsigned_Long is
begin
return UL(I.Shift_Right(U32(Value), Amount));
end Shift_Right;
function Shift_Right_Arithmetic (Value: Uchar; Amount: Natural)
return Unsigned_Char is
begin
return UC(I.Shift_Right_Arithmetic(U8(Value), Amount));
end Shift_Right_Arithmetic;
function Shift_Right_Arithmetic (Value: Ushort; Amount: Natural)
return Ushort is
begin
return US(I.Shift_Right_Arithmetic(U16(Value), Amount));
end Shift_Right_Arithmetic;
function Shift_Right_Arithmetic (Value: Uint; Amount: Natural)
return Unsigned_Int is
begin
return UI(I.Shift_Right_Arithmetic(U32(Value), Amount));
end Shift_Right_Arithmetic;
function Shift_Right_Arithmetic (Value: Ulong; Amount: Natural)
return Unsigned_Long is
begin
return UL(I.Shift_Right_Arithmetic(U32(Value), Amount));
end Shift_Right_Arithmetic;
function Shift_Left (Value: Char; Amount: Natural) return Char is
begin
return To_Signed(Shift_Left(To_Unsigned(Value), Amount));
end Shift_Left;
function Shift_Left (Value: Short; Amount: Natural) return Short is
begin
return To_Signed(Shift_Left(To_Unsigned(Value), Amount));
end Shift_Left;
function Shift_Left (Value: Int; Amount: Natural) return Int is
begin
return To_Signed(Shift_Left(To_Unsigned(Value), Amount));
end Shift_Left;
function Shift_Left (Value: Long; Amount: Natural) return Long is
begin
return To_Signed(Shift_Left(To_Unsigned(Value), Amount));
end Shift_Left;
function Shift_Right (Value: Char; Amount: Natural) return Char is
begin
return To_Signed(Shift_Right(To_Unsigned(Value), Amount));
end Shift_Right;
function Shift_Right (Value: Short; Amount: Natural) return Short is
begin
return To_Signed(Shift_Right(To_Unsigned(Value), Amount));
end Shift_Right;
function Shift_Right (Value: Int; Amount: Natural) return Int is
begin
return To_Signed(Shift_Right(To_Unsigned(Value), Amount));
end Shift_Right;
function Shift_Right (Value: Long; Amount: Natural) return Long is
begin
return To_Signed(Shift_Right(To_Unsigned(Value), Amount));
end Shift_Right;
function Shift_Right_Arithmetic (Value: Char; Amount: Natural)
return Char is
begin
return To_Signed(Shift_Right_Arithmetic(To_Unsigned(Value), Amount));
end Shift_Right_Arithmetic;
function Shift_Right_Arithmetic (Value: Short; Amount: Natural)
return Short is
begin
return To_Signed(Shift_Right_Arithmetic(To_Unsigned(Value), Amount));
end Shift_Right_Arithmetic;
function Shift_Right_Arithmetic (Value: Int; Amount: Natural)
return Int is
begin
return To_Signed(Shift_Right_Arithmetic(To_Unsigned(Value), Amount));
end Shift_Right_Arithmetic;
function Shift_Right_Arithmetic (Value: Long; Amount: Natural)
return Long is
begin
return To_Signed(Shift_Right_Arithmetic(To_Unsigned(Value), Amount));
end Shift_Right_Arithmetic;
end gccs.Ops;
|
pombredanne/ravenadm | Ada | 34,607 | adb | -- This file is covered by the Internet Software Consortium (ISC) License
-- Reference: ../License.txt
with Definitions; use Definitions;
with Ada.Characters.Latin_1;
with Ada.Directories;
with Ada.Text_IO;
with Package_Manifests;
with File_Operations;
with Utilities;
package body Port_Specification.Buildsheet is
package TIO renames Ada.Text_IO;
package DIR renames Ada.Directories;
package LAT renames Ada.Characters.Latin_1;
package MAN renames Package_Manifests;
package FOP renames File_Operations;
package UTL renames Utilities;
--------------------------------------------------------------------------------------------
-- generator
--------------------------------------------------------------------------------------------
procedure generator
(specs : Portspecs;
ravensrcdir : String;
output_file : String)
is
procedure send (data : String; use_put : Boolean := False);
procedure send (varname : String; value, default : Integer);
procedure send (varname, value : String);
procedure send (varname : String; value : HT.Text);
procedure send (varname : String; crate : string_crate.Vector; flavor : Positive);
procedure send (varname : String; crate : def_crate.Map);
procedure send (varname : String; crate : list_crate.Map; flavor : Positive);
procedure send (varname : String; value : Boolean; show_when : Boolean);
procedure send_options;
procedure send_targets;
procedure send_descriptions;
procedure send_scripts;
procedure send_manifests;
procedure send_download_groups;
procedure print_item (position : string_crate.Cursor);
procedure print_item40 (position : string_crate.Cursor);
procedure print_straight (position : string_crate.Cursor);
procedure print_adjacent (position : string_crate.Cursor);
procedure dump_vardesc (position : string_crate.Cursor);
procedure dump_vardesc2 (position : string_crate.Cursor);
procedure dump_manifest (position : string_crate.Cursor);
procedure dump_manifest2 (position : string_crate.Cursor);
procedure dump_sdesc (position : def_crate.Cursor);
procedure dump_sites (position : list_crate.Cursor);
procedure dump_optgroup (position : list_crate.Cursor);
procedure dump_distfiles (position : string_crate.Cursor);
procedure dump_targets (position : list_crate.Cursor);
procedure dump_helper (option_name : String; crate : string_crate.Vector; helper : String);
procedure expand_option_record (position : option_crate.Cursor);
procedure blank_line;
procedure send_file (filename : String);
procedure send_plist (filename : String);
procedure send_directory (dirname : String; pattern : String := "");
procedure send_catchall;
write_to_file : constant Boolean := (output_file /= "");
makefile_handle : TIO.File_Type;
varname_prefix : HT.Text;
save_variant : HT.Text;
current_len : Natural;
currently_blank : Boolean := True;
desc_prefix : constant String := "descriptions/desc.";
plist_prefix : constant String := "manifests/plist.";
distinfo : constant String := "distinfo";
temp_storage : string_crate.Vector;
procedure send (data : String; use_put : Boolean := False) is
begin
if write_to_file then
if use_put then
TIO.Put (makefile_handle, data);
else
TIO.Put_Line (makefile_handle, data);
end if;
else
if use_put then
TIO.Put (data);
else
TIO.Put_Line (data);
end if;
end if;
if data /= "" then
currently_blank := False;
end if;
end send;
procedure send (varname, value : String) is
begin
if value /= "" then
send (align24 (varname & LAT.Equals_Sign) & value);
end if;
end send;
procedure send (varname : String; value : HT.Text) is
begin
if not HT.IsBlank (value) then
send (align24 (varname & LAT.Equals_Sign) & HT.USS (value));
end if;
end send;
procedure send (varname : String; value, default : Integer) is
begin
if value /= default then
send (align24 (varname & LAT.Equals_Sign) & HT.int2str (value));
end if;
end send;
procedure send (varname : String; crate : string_crate.Vector; flavor : Positive) is
begin
if crate.Is_Empty then
return;
end if;
case flavor is
when 1 =>
send (align24 (varname & "="), True);
crate.Iterate (Process => print_item'Access);
when 2 =>
current_len := 0;
send (align24 (varname & "="), True);
crate.Iterate (Process => print_adjacent'Access);
send ("");
when 3 =>
varname_prefix := HT.SUS (varname);
crate.Iterate (Process => dump_distfiles'Access);
when others =>
null;
end case;
end send;
procedure send (varname : String; crate : def_crate.Map) is
begin
varname_prefix := HT.SUS (varname);
crate.Iterate (Process => dump_sdesc'Access);
end send;
procedure send (varname : String; crate : list_crate.Map; flavor : Positive) is
begin
varname_prefix := HT.SUS (varname);
case flavor is
when 4 =>
crate.Iterate (Process => dump_sites'Access);
when 5 =>
crate.Iterate (Process => dump_optgroup'Access);
when others =>
null;
end case;
end send;
procedure send (varname : String; value : Boolean; show_when : Boolean) is
begin
if value = show_when then
send (align24 (varname & LAT.Equals_Sign) & "yes");
end if;
end send;
procedure print_item (position : string_crate.Cursor)
is
index : Natural := string_crate.To_Index (position);
item : String := HT.USS (string_crate.Element (position));
begin
if index = 1 then
send (item);
else
send (LAT.HT & LAT.HT & LAT.HT & item);
end if;
end print_item;
procedure print_item40 (position : string_crate.Cursor)
is
index : Natural := string_crate.To_Index (position);
item : String := HT.USS (string_crate.Element (position));
begin
if index = 1 then
send (item);
else
send (LAT.HT & LAT.HT & LAT.HT & LAT.HT & LAT.HT & item);
end if;
end print_item40;
procedure print_adjacent (position : string_crate.Cursor)
is
index : Natural := string_crate.To_Index (position);
item : String := HT.USS (string_crate.Element (position));
len : Natural := item'Length;
begin
-- Try to hit 75 chars
-- 76 - 24 = 52
if current_len + len + 1 > 52 then
current_len := 0;
send ("");
send (LAT.HT & LAT.HT & LAT.HT, True);
end if;
if current_len > 0 then
send (" ", True);
current_len := current_len + 1;
end if;
send (item, True);
current_len := current_len + len;
end print_adjacent;
procedure print_straight (position : string_crate.Cursor)
is
item : String := HT.USS (string_crate.Element (position));
begin
send (item);
end print_straight;
procedure dump_sdesc (position : def_crate.Cursor)
is
varname : String := HT.USS (varname_prefix) & LAT.Left_Square_Bracket &
HT.USS (def_crate.Key (position)) & LAT.Right_Square_Bracket & LAT.Equals_Sign;
begin
send (align24 (varname) & HT.USS (def_crate.Element (position)));
end dump_sdesc;
procedure dump_sites (position : list_crate.Cursor)
is
rec : group_list renames list_crate.Element (position);
varname : String := HT.USS (varname_prefix) & LAT.Left_Square_Bracket &
HT.USS (rec.group) & LAT.Right_Square_Bracket & LAT.Equals_Sign;
begin
if not rec.list.Is_Empty then
send (align24 (varname), True);
rec.list.Iterate (Process => print_item'Access);
end if;
end dump_sites;
procedure dump_optgroup (position : list_crate.Cursor)
is
rec : group_list renames list_crate.Element (position);
varname : String := HT.USS (varname_prefix) & LAT.Left_Square_Bracket &
HT.USS (rec.group) & LAT.Right_Square_Bracket & LAT.Equals_Sign;
begin
if not rec.list.Is_Empty then
current_len := 0;
send (align24 (varname), True);
rec.list.Iterate (Process => print_adjacent'Access);
send ("");
end if;
end dump_optgroup;
procedure dump_distfiles (position : string_crate.Cursor)
is
index : Natural := string_crate.To_Index (position);
NDX : String := HT.USS (varname_prefix) & LAT.Left_Square_Bracket &
HT.int2str (index) & LAT.Right_Square_Bracket & LAT.Equals_Sign;
begin
send (align24 (NDX) & HT.USS (string_crate.Element (position)));
end dump_distfiles;
procedure blank_line is
begin
if not currently_blank then
send ("");
end if;
currently_blank := True;
end blank_line;
procedure send_targets is
begin
specs.make_targets.Iterate (Process => dump_targets'Access);
end send_targets;
procedure dump_targets (position : list_crate.Cursor)
is
rec : group_list renames list_crate.Element (position);
target : String := HT.USS (rec.group) & LAT.Colon;
begin
blank_line;
send (target);
rec.list.Iterate (Process => print_straight'Access);
end dump_targets;
procedure dump_helper (option_name : String; crate : string_crate.Vector; helper : String)
is
begin
if not crate.Is_Empty then
send (align40 (LAT.Left_Square_Bracket & option_name & "]." &
helper & LAT.Equals_Sign), True);
crate.Iterate (Process => print_item40'Access);
end if;
end dump_helper;
procedure expand_option_record (position : option_crate.Cursor)
is
rec : Option_Helper renames option_crate.Element (position);
name : String := HT.USS (rec.option_name);
begin
blank_line;
if not HT.IsBlank (rec.option_description) then
send (align40 (LAT.Left_Square_Bracket & name & "].DESCRIPTION=") &
HT.USS (rec.option_description));
end if;
if not HT.IsBlank (rec.BROKEN_ON) then
send (align40 (LAT.Left_Square_Bracket & name & "].BROKEN_ON=") &
HT.USS (rec.BROKEN_ON));
end if;
dump_helper (name, rec.BUILDRUN_DEPENDS_OFF, "BUILDRUN_DEPENDS_OFF");
dump_helper (name, rec.BUILDRUN_DEPENDS_ON, "BUILDRUN_DEPENDS_ON");
dump_helper (name, rec.BUILD_DEPENDS_OFF, "BUILD_DEPENDS_OFF");
dump_helper (name, rec.BUILD_DEPENDS_ON, "BUILD_DEPENDS_ON");
dump_helper (name, rec.BUILD_TARGET_ON, "BUILD_TARGET_ON");
dump_helper (name, rec.CFLAGS_OFF, "CFLAGS_OFF");
dump_helper (name, rec.CFLAGS_ON, "CFLAGS_ON");
dump_helper (name, rec.CMAKE_ARGS_OFF, "CMAKE_ARGS_OFF");
dump_helper (name, rec.CMAKE_ARGS_ON, "CMAKE_ARGS_ON");
dump_helper (name, rec.CMAKE_BOOL_T_BOTH, "CMAKE_BOOL_T_BOTH");
dump_helper (name, rec.CMAKE_BOOL_F_BOTH, "CMAKE_BOOL_F_BOTH");
dump_helper (name, rec.CONFIGURE_ARGS_OFF, "CONFIGURE_ARGS_OFF");
dump_helper (name, rec.CONFIGURE_ARGS_ON, "CONFIGURE_ARGS_ON");
dump_helper (name, rec.CONFIGURE_ENABLE_BOTH, "CONFIGURE_ENABLE_BOTH");
dump_helper (name, rec.CONFIGURE_ENV_ON, "CONFIGURE_ENV_ON");
dump_helper (name, rec.CONFIGURE_WITH_BOTH, "CONFIGURE_WITH_BOTH");
dump_helper (name, rec.CPPFLAGS_ON, "CPPFLAGS_ON");
dump_helper (name, rec.CXXFLAGS_ON, "CXXFLAGS_ON");
dump_helper (name, rec.DF_INDEX_OFF, "DF_INDEX_OFF");
dump_helper (name, rec.DF_INDEX_ON, "DF_INDEX_ON");
dump_helper (name, rec.EXTRA_PATCHES_ON, "EXTRA_PATCHES_ON");
dump_helper (name, rec.EXTRACT_ONLY_ON, "EXTRACT_ONLY_ON");
dump_helper (name, rec.GNOME_COMPONENTS_OFF, "GNOME_COMPONENTS_OFF");
dump_helper (name, rec.GNOME_COMPONENTS_ON, "GNOME_COMPONENTS_ON");
dump_helper (name, rec.IMPLIES_ON, "IMPLIES_ON");
dump_helper (name, rec.INFO_OFF, "INFO_OFF");
dump_helper (name, rec.INFO_ON, "INFO_ON");
dump_helper (name, rec.INSTALL_TARGET_ON, "INSTALL_TARGET_ON");
dump_helper (name, rec.KEYWORDS_ON, "KEYWORDS_ON");
dump_helper (name, rec.LDFLAGS_ON, "LDFLAGS_ON");
dump_helper (name, rec.MAKEFILE_OFF, "MAKEFILE_OFF");
dump_helper (name, rec.MAKEFILE_ON, "MAKEFILE_ON");
dump_helper (name, rec.MAKE_ARGS_OFF, "MAKE_ARGS_OFF");
dump_helper (name, rec.MAKE_ARGS_ON, "MAKE_ARGS_ON");
dump_helper (name, rec.MAKE_ENV_ON, "MAKE_ENV_ON");
dump_helper (name, rec.ONLY_FOR_OPSYS_ON, "ONLY_FOR_OPSYS_ON");
dump_helper (name, rec.PATCHFILES_ON, "PATCHFILES_ON");
dump_helper (name, rec.PLIST_SUB_ON, "PLIST_SUB_ON");
dump_helper (name, rec.PREVENTS_ON, "PREVENTS_ON");
dump_helper (name, rec.QMAKE_OFF, "QMAKE_OFF");
dump_helper (name, rec.QMAKE_ON, "QMAKE_ON");
dump_helper (name, rec.RUN_DEPENDS_OFF, "RUN_DEPENDS_OFF");
dump_helper (name, rec.RUN_DEPENDS_ON, "RUN_DEPENDS_ON");
dump_helper (name, rec.SUB_FILES_OFF, "SUB_FILES_OFF");
dump_helper (name, rec.SUB_FILES_ON, "SUB_FILES_ON");
dump_helper (name, rec.SUB_LIST_OFF, "SUB_LIST_OFF");
dump_helper (name, rec.SUB_LIST_ON, "SUB_LIST_ON");
dump_helper (name, rec.TEST_TARGET_ON, "TEST_TARGET_ON");
dump_helper (name, rec.USES_OFF, "USES_OFF");
dump_helper (name, rec.USES_ON, "USES_ON");
dump_helper (name, rec.XORG_COMPONENTS_OFF, "XORG_COMPONENTS_OFF");
dump_helper (name, rec.XORG_COMPONENTS_ON, "XORG_COMPONENTS_ON");
end expand_option_record;
procedure send_options is
begin
specs.ops_helpers.Iterate (Process => expand_option_record'Access);
end send_options;
procedure send_file (filename : String)
is
abspath : constant String := ravensrcdir & "/" & filename;
begin
if DIR.Exists (abspath) then
declare
contents : constant String := FOP.get_file_contents (abspath);
begin
blank_line;
send ("[FILE:" & HT.int2str (contents'Length) & LAT.Colon & filename &
LAT.Right_Square_Bracket);
send (contents);
end;
end if;
end send_file;
procedure send_plist (filename : String)
is
abspath : constant String := ravensrcdir & "/" & filename;
begin
if DIR.Exists (abspath) then
declare
contents : constant String := MAN.compress_manifest (MAN.Filename (abspath));
begin
blank_line;
send ("[FILE:" & HT.int2str (contents'Length) & LAT.Colon & filename &
LAT.Right_Square_Bracket);
send (contents);
end;
end if;
end send_plist;
procedure dump_vardesc2 (position : string_crate.Cursor)
is
item : HT.Text renames string_crate.Element (position);
subpkg : String := HT.USS (item);
begin
send_file (desc_prefix & subpkg & LAT.Full_Stop & HT.USS (varname_prefix));
if DIR.Exists (ravensrcdir & "/" & desc_prefix & subpkg) and then
not temp_storage.Contains (item)
then
temp_storage.Append (item);
send_file (desc_prefix & subpkg);
end if;
end dump_vardesc2;
procedure dump_vardesc (position : string_crate.Cursor) is
begin
varname_prefix := string_crate.Element (position);
specs.subpackages.Element (varname_prefix).list.Iterate (dump_vardesc2'Access);
end dump_vardesc;
procedure send_descriptions is
begin
specs.variants.Iterate (Process => dump_vardesc'Access);
temp_storage.Clear;
end send_descriptions;
procedure send_scripts
is
function get_phasestr (index : Positive) return String;
function get_prefix (index : Positive) return String;
function get_phasestr (index : Positive) return String is
begin
case index is
when 1 => return "fetch";
when 2 => return "extract";
when 3 => return "patch";
when 4 => return "configure";
when 5 => return "build";
when 6 => return "install";
when others => return "";
end case;
end get_phasestr;
function get_prefix (index : Positive) return String is
begin
case index is
when 1 => return "pre-";
when 2 => return "post-";
when others => return "";
end case;
end get_prefix;
begin
for phase in Positive range 1 .. 6 loop
for prefix in Positive range 1 .. 2 loop
declare
target : String := get_prefix (prefix) & get_phasestr (phase) & "-script";
begin
send_file ("scripts/" & target);
end;
end loop;
end loop;
end send_scripts;
procedure send_directory (dirname : String; pattern : String := "")
is
procedure dump_file (cursor : string_crate.Cursor);
Search : DIR.Search_Type;
Dir_Ent : DIR.Directory_Entry_Type;
bucket : string_crate.Vector;
abspath : constant String := ravensrcdir & "/" & dirname;
filter : constant DIR.Filter_Type := (DIR.Directory => False,
DIR.Ordinary_File => True,
DIR.Special_File => False);
procedure dump_file (cursor : string_crate.Cursor)
is
filename : String := HT.USS (string_crate.Element (cursor));
begin
send_file (dirname & "/" & filename);
end dump_file;
begin
if not DIR.Exists (abspath) then
return;
end if;
DIR.Start_Search (Search => Search,
Directory => abspath,
Pattern => pattern,
Filter => filter);
while DIR.More_Entries (Search => Search) loop
DIR.Get_Next_Entry (Search => Search, Directory_Entry => Dir_Ent);
bucket.Append (HT.SUS (DIR.Simple_Name (Dir_Ent)));
end loop;
DIR.End_Search (Search);
sorter.Sort (Container => bucket);
bucket.Iterate (Process => dump_file'Access);
end send_directory;
procedure dump_manifest2 (position : string_crate.Cursor)
is
item : HT.Text renames string_crate.Element (position);
subpkg : String := HT.USS (item);
fullkey : HT.Text;
shortlist : String := plist_prefix & subpkg;
fullplist : String := shortlist & "." & HT.USS (save_variant);
begin
if DIR.Exists (ravensrcdir & "/" & fullplist) then
fullkey := HT.SUS (subpkg & "." & HT.USS (save_variant));
if not temp_storage.Contains (fullkey) then
temp_storage.Append (fullkey);
send_plist (fullplist);
end if;
else
if DIR.Exists (ravensrcdir & "/" & shortlist) and then
not temp_storage.Contains (item)
then
temp_storage.Append (item);
send_plist (shortlist);
end if;
end if;
end dump_manifest2;
procedure dump_manifest (position : string_crate.Cursor)
is
variant : HT.Text renames string_crate.Element (position);
begin
save_variant := variant;
specs.subpackages.Element (variant).list.Iterate (dump_manifest2'Access);
end dump_manifest;
procedure send_manifests
is
-- Manifests are subpackage-based
-- Not having a subpackage manifest is ok.
-- Subpackaegs typically missing: docs, examples, complete (Metaport)
begin
specs.variants.Iterate (Process => dump_manifest'Access);
temp_storage.Clear;
end send_manifests;
procedure send_download_groups
is
-- The first group must be either "main" or "none"
procedure dump_group (position : list_crate.Cursor);
procedure dump_main (position : list_crate.Cursor);
procedure dump_main (position : list_crate.Cursor)
is
rec : group_list renames list_crate.Element (position);
begin
if HT.equivalent (rec.group, dlgroup_main) or else
HT.equivalent (rec.group, dlgroup_none)
then
send (HT.USS (rec.group), True);
end if;
end dump_main;
procedure dump_group (position : list_crate.Cursor)
is
rec : group_list renames list_crate.Element (position);
begin
if not HT.equivalent (rec.group, dlgroup_main) and then
not HT.equivalent (rec.group, dlgroup_none)
then
send (" " & HT.USS (rec.group), True);
end if;
end dump_group;
begin
send (align24 ("DOWNLOAD_GROUPS="), True);
specs.dl_sites.Iterate (Process => dump_main'Access);
specs.dl_sites.Iterate (Process => dump_group'Access);
send ("");
end send_download_groups;
procedure send_catchall
is
procedure scan (position : list_crate.Cursor);
procedure putout (position : string_crate.Cursor);
temp_storage : string_crate.Vector;
procedure scan (position : list_crate.Cursor)
is
rec : group_list renames list_crate.Element (position);
begin
temp_storage.Append (rec.group);
end scan;
procedure putout (position : string_crate.Cursor)
is
text_value : HT.Text renames string_crate.Element (position);
begin
send (align24 (HT.USS (text_value) & "="), True);
specs.catch_all.Element (text_value).list.Iterate (print_item'Access);
end putout;
begin
specs.catch_all.Iterate (scan'Access);
sorter.Sort (temp_storage);
temp_storage.Iterate (putout'Access);
end send_catchall;
begin
if write_to_file then
TIO.Create (File => makefile_handle,
Mode => TIO.Out_File,
Name => output_file);
end if;
send ("# Buildsheet autogenerated by ravenadm tool -- Do not edit." & LAT.LF);
send ("NAMEBASE", specs.namebase);
send ("VERSION", specs.version);
send ("REVISION", specs.revision, 0);
send ("EPOCH", specs.epoch, 0);
send ("KEYWORDS", specs.keywords, 2);
send ("VARIANTS", specs.variants, 2);
send ("SDESC", specs.taglines);
send ("HOMEPAGE", specs.homepage);
send ("CONTACT", specs.contacts, 1);
blank_line;
send_download_groups;
send ("SITES", specs.dl_sites, 4);
send ("DISTFILE", specs.distfiles, 3);
send ("DIST_SUBDIR", specs.dist_subdir);
send ("DF_INDEX", specs.df_index, 2);
send ("SPKGS", specs.subpackages, 4);
blank_line;
send ("OPTIONS_AVAILABLE", specs.ops_avail, 2);
send ("OPTIONS_STANDARD", specs.ops_standard, 2);
send ("OPTGROUP_RADIO", specs.opt_radio, 2);
send ("OPTGROUP_RESTRICTED", specs.opt_restrict, 2);
send ("OPTGROUP_UNLIMITED", specs.opt_unlimited, 2);
send ("OPTDESCR", specs.optgroup_desc, 4);
send ("OPTGROUP", specs.optgroups, 5);
send ("VOPTS", specs.variantopts, 5);
send ("OPT_ON", specs.options_on, 5);
blank_line;
send ("BROKEN", specs.broken, 4);
send ("BROKEN_SSL", specs.broken_ssl, 2);
send ("BROKEN_MYSQL", specs.broken_mysql, 2);
send ("BROKEN_PGSQL", specs.broken_pgsql, 2);
send ("NOT_FOR_OPSYS", specs.exc_opsys, 2);
send ("ONLY_FOR_OPSYS", specs.inc_opsys, 2);
send ("NOT_FOR_ARCH", specs.exc_arch, 2);
send ("DEPRECATED", specs.deprecated);
send ("EXPIRATION_DATE", specs.expire_date);
blank_line;
send ("BUILD_DEPENDS", specs.build_deps, 1);
send ("BUILDRUN_DEPENDS", specs.buildrun_deps, 1);
send ("RUN_DEPENDS", specs.run_deps, 1);
send ("B_DEPS", specs.opsys_b_deps, 5);
send ("BR_DEPS", specs.opsys_br_deps, 5);
send ("R_DEPS", specs.opsys_r_deps, 5);
send ("EXRUN", specs.extra_rundeps, 4);
blank_line;
send ("USERS", specs.users, 2);
send ("GROUPS", specs.groups, 2);
send ("USERGROUP_SPKG", specs.usergroup_pkg);
blank_line;
send ("USES", specs.uses, 2);
send ("GNOME_COMPONENTS", specs.gnome_comps, 2);
send ("SDL_COMPONENTS", specs.sdl_comps, 2);
send ("XORG_COMPONENTS", specs.xorg_comps, 2);
send ("PHP_EXTENSIONS", specs.php_extensions, 2);
blank_line;
send ("DISTNAME", specs.distname);
send ("EXTRACT_DIRTY", specs.extract_dirty, 2);
send ("EXTRACT_ONLY", specs.extract_only, 2);
send ("EXTRACT_WITH_UNZIP", specs.extract_zip, 2);
send ("EXTRACT_WITH_7Z", specs.extract_7z, 2);
send ("EXTRACT_WITH_LHA", specs.extract_lha, 2);
send ("EXTRACT_DEB_PACKAGE", specs.extract_deb, 2);
send ("EXTRACT_HEAD", specs.extract_head, 4);
send ("EXTRACT_TAIL", specs.extract_tail, 4);
blank_line;
send ("LICENSE", specs.licenses, 2);
send ("LICENSE_NAME", specs.lic_names, 1);
send ("LICENSE_SCHEME", specs.lic_scheme);
send ("LICENSE_FILE", specs.lic_files, 1);
blank_line;
send ("PREFIX", specs.prefix);
send ("INFO", specs.info, 1);
send_catchall;
send ("GENERATED", specs.generated, True);
send ("SKIP_CCACHE", specs.skip_ccache, True);
blank_line;
send ("PATCH_WRKSRC", specs.patch_wrksrc);
send ("PATCHFILES", specs.patchfiles, 2);
send ("EXTRA_PATCHES", specs.extra_patches, 1);
send ("PATCH_STRIP", specs.patch_strip, 2);
send ("PATCHFILES_STRIP", specs.pfiles_strip, 2);
blank_line;
send ("INVALID_RPATH", specs.fatal_rpath, False);
send ("MUST_CONFIGURE", specs.config_must);
send ("GNU_CONFIGURE_PREFIX", specs.config_prefix);
send ("CONFIGURE_OUTSOURCE", specs.config_outsrc, True);
send ("CONFIGURE_WRKSRC", specs.config_wrksrc);
send ("CONFIGURE_SCRIPT", specs.config_script);
send ("CONFIGURE_TARGET", specs.config_target);
send ("CONFIGURE_ARGS", specs.config_args, 1);
send ("CONFIGURE_ENV", specs.config_env, 1);
blank_line;
send ("SKIP_BUILD", specs.skip_build, True);
send ("BUILD_WRKSRC", specs.build_wrksrc);
send ("BUILD_TARGET", specs.build_target, 2);
send ("MAKEFILE", specs.makefile);
send ("MAKE_ARGS", specs.make_args, 1);
send ("MAKE_ENV", specs.make_env, 1);
send ("DESTDIRNAME", specs.destdirname);
send ("DESTDIR_VIA_ENV", specs.destdir_env, True);
send ("MAKE_JOBS_NUMBER_LIMIT", specs.job_limit, 0);
send ("SINGLE_JOB", specs.single_job, True);
blank_line;
send ("SKIP_INSTALL", specs.skip_install, True);
send ("INSTALL_WRKSRC", specs.install_wrksrc);
send ("INSTALL_TARGET", specs.install_tgt, 2);
send ("INSTALL_REQ_TOOLCHAIN", specs.shift_install, True);
send ("MANDIRS", specs.mandirs, 1);
send ("PLIST_SUB", specs.plist_sub, 1);
send ("RC_SUBR", specs.subr_scripts, 1);
send ("SUB_FILES", specs.sub_files, 1);
send ("SUB_LIST", specs.sub_list, 1);
blank_line;
send ("SET_DEBUGGING_ON", specs.debugging_on, True);
send ("CFLAGS", specs.cflags, 1);
send ("CXXFLAGS", specs.cxxflags, 1);
send ("CPPFLAGS", specs.cppflags, 1);
send ("LDFLAGS", specs.ldflags, 1);
send ("OPTIMIZER_LEVEL", specs.optimizer_lvl, 2);
send ("CMAKE_ARGS", specs.cmake_args, 1);
send ("TEST_TARGET", specs.test_tgt, 2);
send ("TEST_ARGS", specs.test_args, 1);
send ("TEST_ENV", specs.test_env, 1);
send ("VAR_OPSYS", specs.var_opsys, 4);
send ("VAR_ARCH", specs.var_arch, 4);
send_options;
send_targets;
send_descriptions;
send_file (distinfo);
send_manifests;
send_scripts;
send_directory ("patches", "patch-*");
send_directory ("files", "");
for opsys in supported_opsys'Range loop
send_directory (UTL.lower_opsys (opsys), "");
end loop;
if write_to_file then
TIO.Close (makefile_handle);
end if;
exception
when others =>
if TIO.Is_Open (makefile_handle) then
TIO.Close (makefile_handle);
end if;
end generator;
--------------------------------------------------------------------------------------------
-- align24
--------------------------------------------------------------------------------------------
function align24 (payload : String) return String
is
len : Natural := payload'Length;
begin
if len < 8 then
return payload & LAT.HT & LAT.HT & LAT.HT;
elsif len < 16 then
return payload & LAT.HT & LAT.HT;
elsif len < 24 then
return payload & LAT.HT;
else
return payload;
end if;
end align24;
--------------------------------------------------------------------------------------------
-- align40
--------------------------------------------------------------------------------------------
function align40 (payload : String) return String
is
len : Natural := payload'Length;
begin
if len < 8 then
return payload & LAT.HT & LAT.HT & LAT.HT & LAT.HT & LAT.HT;
elsif len < 16 then
return payload & LAT.HT & LAT.HT & LAT.HT & LAT.HT;
elsif len < 24 then
return payload & LAT.HT & LAT.HT & LAT.HT;
elsif len < 32 then
return payload & LAT.HT & LAT.HT;
elsif len < 40 then
return payload & LAT.HT;
else
return payload;
end if;
end align40;
--------------------------------------------------------------------------------------------
-- print_specification_template
--------------------------------------------------------------------------------------------
procedure print_specification_template (dump_to_file : Boolean)
is
tab : constant Character := LAT.HT;
CR : constant Character := LAT.LF;
part1 : constant String :=
"# DEF[PORTVERSION]=" & tab & "1.00" & CR &
"# ----------------------------------------------------------------------------";
part2 : constant String := CR &
"NAMEBASE=" & tab & tab & "..." & CR &
"VERSION=" & tab & tab & "${PORTVERSION}" & CR &
"KEYWORDS=" & tab & tab & "..." & CR &
"VARIANTS=" & tab & tab & "standard" & CR &
"SDESC[standard]=" & tab & "..." & CR &
"HOMEPAGE=" & tab & tab & "none" & CR &
"CONTACT=" & tab & tab & "Jay_Leno[[email protected]]" & CR & CR &
"DOWNLOAD_GROUPS=" & tab & "main" & CR &
"SITES[main]=" & tab & tab & "http://www.example.com/" & CR &
"DISTFILE[1]=" & tab & tab & "x-${PORTVERSION}.tar.gz:main" & CR & CR &
"SPKGS[standard]=" & tab & "single" & CR & CR &
"OPTIONS_AVAILABLE=" & tab & "none" & CR &
"OPTIONS_STANDARD=" & tab & "none" & CR & CR &
"FPC_EQUIVALENT=" & tab & tab & "...";
template : TIO.File_Type;
filename : constant String := "specification";
begin
if dump_to_file then
if DIR.Exists (filename) then
TIO.Put_Line ("The " & filename &
" file already exists. I wouldn't want to overwrite it!");
return;
end if;
TIO.Create (File => template,
Mode => TIO.Out_File,
Name => filename);
TIO.Put_Line (template, part1);
TIO.Put_Line (template, part2);
TIO.Close (template);
DIR.Create_Directory ("manifests");
DIR.Create_Directory ("descriptions");
else
TIO.Put_Line (part1);
TIO.Put_Line (part2);
end if;
exception
when others =>
if TIO.Is_Open (template) then
TIO.Close (template);
end if;
end print_specification_template;
end Port_Specification.Buildsheet;
|
onox/dcf-ada | Ada | 1,723 | ads | -- SPDX-License-Identifier: MIT
--
-- Copyright (c) 2019 onox <[email protected]>
--
-- Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in
-- all copies or substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-- THE SOFTWARE.
package DCF is
pragma Pure;
type Unsigned_8 is mod 2 ** 8
with Size => 8;
type Unsigned_16 is mod 2 ** 16
with Size => 16;
type Unsigned_32 is mod 2 ** 32
with Size => 32;
type Integer_64 is range -(2 ** 63) .. +(2 ** 63 - 1);
-- Based on C99 long long int
function Shift_Left (Value : Unsigned_32; Positions : Natural) return Unsigned_32 is
(Value * 2 ** Positions);
function Shift_Right (Value : Unsigned_32; Positions : Natural) return Unsigned_32 is
(Value / 2 ** Positions);
end DCF;
|
stcarrez/ada-asf | Ada | 13,723 | adb | -----------------------------------------------------------------------
-- applications -- Ada Web Application
-- Copyright (C) 2009, 2010, 2011, 2012, 2013, 2018, 2020, 2021, 2022 Stephane Carrez
-- Written by Stephane Carrez ([email protected])
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Ada.Strings.Fixed;
with ASF.Contexts.Facelets;
with ASF.Applications.Main;
with ASF.Components.Base;
with ASF.Components.Core;
with ASF.Components.Core.Views;
with ASF.Converters;
with ASF.Validators;
with EL.Objects;
package body ASF.Applications.Views is
use ASF.Components;
type Facelet_Context is new ASF.Contexts.Facelets.Facelet_Context with record
Facelets : access ASF.Views.Facelets.Facelet_Factory;
Application : access ASF.Applications.Main.Application'Class;
end record;
-- Include the definition having the given name.
overriding
procedure Include_Facelet (Context : in out Facelet_Context;
Source : in String;
Parent : in Base.UIComponent_Access);
overriding
function Get_Converter (Context : in Facelet_Context;
Name : in EL.Objects.Object)
return ASF.Converters.Converter_Access;
overriding
function Get_Validator (Context : in Facelet_Context;
Name : in EL.Objects.Object)
return ASF.Validators.Validator_Access;
-- Compose a URI path with two components. Unlike the Ada.Directories.Compose,
-- and Util.Files.Compose the path separator must be a URL path separator (ie, '/').
-- ------------------------------
function Compose (Directory : in String;
Name : in String) return String;
-- ------------------------------
-- Include the definition having the given name.
-- ------------------------------
overriding
procedure Include_Facelet (Context : in out Facelet_Context;
Source : in String;
Parent : in Base.UIComponent_Access) is
use ASF.Views;
Path : constant String := Context.Resolve_Path (Source);
Tree : Facelets.Facelet;
begin
Facelets.Find_Facelet (Factory => Context.Facelets.all,
Name => Path,
Context => Context,
Result => Tree);
Facelets.Build_View (View => Tree,
Context => Context,
Root => Parent);
end Include_Facelet;
-- ------------------------------
-- Get a converter from a name.
-- Returns the converter object or null if there is no converter.
-- ------------------------------
overriding
function Get_Converter (Context : in Facelet_Context;
Name : in EL.Objects.Object)
return ASF.Converters.Converter_Access is
begin
return Context.Application.Find (Name);
end Get_Converter;
-- ------------------------------
-- Get a validator from a name.
-- Returns the validator object or null if there is no validator.
-- ------------------------------
overriding
function Get_Validator (Context : in Facelet_Context;
Name : in EL.Objects.Object)
return ASF.Validators.Validator_Access is
begin
return Context.Application.Find_Validator (Name);
end Get_Validator;
-- ------------------------------
-- Get the facelet name from the view name.
-- ------------------------------
function Get_Facelet_Name (Handler : in View_Handler;
Name : in String) return String is
use Ada.Strings.Fixed;
use Ada.Strings.Unbounded;
Pos : constant Natural := Index (Name, ".", Ada.Strings.Backward);
begin
if Pos > 0 and then Handler.View_Ext = Name (Pos .. Name'Last) then
return Name (Name'First .. Pos - 1) & To_String (Handler.File_Ext);
elsif Pos > 0 and then Handler.File_Ext = Name (Pos .. Name'Last) then
return Name;
end if;
return Name & To_String (Handler.File_Ext);
end Get_Facelet_Name;
-- ------------------------------
-- Restore the view identified by the given name in the faces context
-- and create the component tree representing that view.
-- ------------------------------
procedure Restore_View (Handler : in out View_Handler;
Name : in String;
Context : in out ASF.Contexts.Faces.Faces_Context'Class;
View : out ASF.Components.Root.UIViewRoot;
Ignore : in Boolean := False) is
use ASF.Views;
use Util.Locales;
use type ASF.Components.Base.UIComponent_Access;
Ctx : Facelet_Context;
Tree : Facelets.Facelet;
View_Name : constant String := Handler.Get_Facelet_Name (Name);
begin
Ctx.Facelets := Handler.Facelets'Unchecked_Access;
Ctx.Application := Context.Get_Application;
Ctx.Set_ELContext (Context.Get_ELContext);
Facelets.Find_Facelet (Factory => Handler.Facelets,
Name => View_Name,
Context => Ctx,
Result => Tree,
Ignore => Ignore);
-- If the view could not be found, do not report any error yet.
-- The SC_NOT_FOUND response will be returned when rendering the response.
if Facelets.Is_Null (Tree) then
return;
end if;
-- Build the component tree for this request.
declare
Root : aliased Core.UIComponentBase;
Node : Base.UIComponent_Access;
begin
Facelets.Build_View (View => Tree,
Context => Ctx,
Root => Root'Unchecked_Access);
ASF.Components.Base.Steal_Root_Component (Root, Node);
-- If there was some error while building the view, return now.
-- The SC_NOT_FOUND response will also be returned when rendering the response.
if Node = null then
return;
end if;
ASF.Components.Root.Set_Root (View, Node, View_Name);
if Context.Get_Locale = NULL_LOCALE then
if Node.all in Core.Views.UIView'Class then
Context.Set_Locale (Core.Views.UIView'Class (Node.all).Get_Locale (Context));
else
Context.Set_Locale (Handler.Calculate_Locale (Context));
end if;
end if;
end;
end Restore_View;
-- ------------------------------
-- Create a new UIViewRoot instance initialized from the context and with
-- the view identifier. If the view is a valid view, create the component tree
-- representing that view.
-- ------------------------------
procedure Create_View (Handler : in out View_Handler;
Name : in String;
Context : in out ASF.Contexts.Faces.Faces_Context'Class;
View : out ASF.Components.Root.UIViewRoot;
Ignore : in Boolean := False) is
Pos : constant Natural := Util.Strings.Rindex (Name, '.');
begin
if Pos > 0 then
Handler.Restore_View (Name (Name'First .. Pos - 1), Context, View, Ignore);
else
Handler.Restore_View (Name, Context, View, Ignore);
end if;
end Create_View;
-- ------------------------------
-- Render the view represented by the component tree. The view is
-- rendered using the context.
-- ------------------------------
procedure Render_View (Handler : in out View_Handler;
Context : in out ASF.Contexts.Faces.Faces_Context'Class;
View : in ASF.Components.Root.UIViewRoot) is
pragma Unreferenced (Handler);
Root : constant access ASF.Components.Base.UIComponent'Class
:= ASF.Components.Root.Get_Root (View);
begin
if Root /= null then
Root.Encode_All (Context);
end if;
end Render_View;
-- ------------------------------
-- Compute the locale that must be used according to the <b>Accept-Language</b> request
-- header and the application supported locales.
-- ------------------------------
function Calculate_Locale (Handler : in View_Handler;
Context : in ASF.Contexts.Faces.Faces_Context'Class)
return Util.Locales.Locale is
pragma Unreferenced (Handler);
App : constant ASF.Contexts.Faces.Application_Access := Context.Get_Application;
begin
return App.Calculate_Locale (Context);
end Calculate_Locale;
-- ------------------------------
-- Compose a URI path with two components. Unlike the Ada.Directories.Compose,
-- and Util.Files.Compose the path separator must be a URL path separator (ie, '/').
-- ------------------------------
function Compose (Directory : in String;
Name : in String) return String is
begin
if Directory'Length = 0 then
return Name;
elsif Directory (Directory'Last) = '/' and then Name (Name'First) = '/' then
return Directory & Name (Name'First + 1 .. Name'Last);
elsif Directory (Directory'Last) = '/' or else Name (Name'First) = '/' then
return Directory & Name;
else
return Directory & "/" & Name;
end if;
end Compose;
-- ------------------------------
-- Get the URL suitable for encoding and rendering the view specified by the <b>View</b>
-- identifier.
-- ------------------------------
function Get_Action_URL (Handler : in View_Handler;
Context : in ASF.Contexts.Faces.Faces_Context'Class;
View : in String) return String is
use Ada.Strings.Unbounded;
Pos : constant Natural := Util.Strings.Rindex (View, '.');
Context_Path : constant String := Context.Get_Request.Get_Context_Path;
begin
if Pos > 0 and then View (Pos .. View'Last) = Handler.File_Ext then
return Compose (Context_Path,
View (View'First .. Pos - 1) & To_String (Handler.View_Ext));
end if;
if Pos > 0 and then View (Pos .. View'Last) = Handler.View_Ext then
return Compose (Context_Path, View);
end if;
return Compose (Context_Path, View);
end Get_Action_URL;
-- ------------------------------
-- Get the URL for redirecting the user to the specified view.
-- ------------------------------
function Get_Redirect_URL (Handler : in View_Handler;
Context : in ASF.Contexts.Faces.Faces_Context'Class;
View : in String) return String is
Pos : constant Natural := Util.Strings.Rindex (View, '?');
begin
if Pos > 0 then
return Handler.Get_Action_URL (Context, View (View'First .. Pos - 1))
& View (Pos .. View'Last);
else
return Handler.Get_Action_URL (Context, View);
end if;
end Get_Redirect_URL;
-- ------------------------------
-- Initialize the view handler.
-- ------------------------------
procedure Initialize (Handler : out View_Handler;
Components : access ASF.Factory.Component_Factory;
Conf : in Config) is
use ASF.Views;
use Ada.Strings.Unbounded;
begin
Handler.Paths := Conf.Get (VIEW_DIR_PARAM);
Handler.View_Ext := Conf.Get (VIEW_EXT_PARAM);
Handler.File_Ext := Conf.Get (VIEW_FILE_EXT_PARAM);
Facelets.Initialize (Factory => Handler.Facelets,
Components => Components,
Paths => To_String (Handler.Paths),
Ignore_White_Spaces => Conf.Get (VIEW_IGNORE_WHITE_SPACES_PARAM),
Ignore_Empty_Lines => Conf.Get (VIEW_IGNORE_EMPTY_LINES_PARAM),
Escape_Unknown_Tags => Conf.Get (VIEW_ESCAPE_UNKNOWN_TAGS_PARAM));
end Initialize;
-- ------------------------------
-- Closes the view handler
-- ------------------------------
procedure Close (Handler : in out View_Handler) is
use ASF.Views;
begin
Facelets.Clear_Cache (Handler.Facelets);
end Close;
-- ------------------------------
-- Set the extension mapping rule to find the facelet file from
-- the name.
-- ------------------------------
procedure Set_Extension_Mapping (Handler : in out View_Handler;
From : in String;
Into : in String) is
use Ada.Strings.Unbounded;
begin
Handler.View_Ext := To_Unbounded_String (From);
Handler.File_Ext := To_Unbounded_String (Into);
end Set_Extension_Mapping;
end ASF.Applications.Views;
|
stcarrez/ada-util | Ada | 2,490 | adb | -----------------------------------------------------------------------
-- util-beans-lists -- Beans implementing the List interface
-- Copyright (C) 2013 Stephane Carrez
-- Written by Stephane Carrez ([email protected])
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
package body Util.Beans.Lists.Strings is
-- ------------------------------
-- Get the number of elements in the list.
-- ------------------------------
overriding
function Get_Count (From : in List_Bean) return Natural is
begin
return Natural (From.List.Length);
end Get_Count;
-- ------------------------------
-- Set the current row index. Valid row indexes start at 1.
-- ------------------------------
overriding
procedure Set_Row_Index (From : in out List_Bean;
Index : in Natural) is
begin
From.Current := Index;
end Set_Row_Index;
-- ------------------------------
-- Get the element at the current row index.
-- ------------------------------
overriding
function Get_Row (From : in List_Bean) return Util.Beans.Objects.Object is
begin
return Util.Beans.Objects.To_Object (From.List.Element (From.Current));
end Get_Row;
-- ------------------------------
-- Get the value identified by the name.
-- If the name cannot be found, the method should return the Null object.
-- ------------------------------
overriding
function Get_Value (From : in List_Bean;
Name : in String) return Util.Beans.Objects.Object is
begin
if Name = "count" then
return Util.Beans.Objects.To_Object (Integer (From.List.Length));
elsif Name = "rowIndex" then
return Util.Beans.Objects.To_Object (From.Current);
else
return Util.Beans.Objects.Null_Object;
end if;
end Get_Value;
end Util.Beans.Lists.Strings;
|
zhmu/ananas | Ada | 130 | ads | limited with Limited_With7_Pkg;
package Limited_With7 is
procedure Proc (R : out Limited_With7_Pkg.Rec);
end Limited_With7;
|
Componolit/libsparkcrypto | Ada | 4,101 | ads | -------------------------------------------------------------------------------
-- This file is part of libsparkcrypto.
--
-- Copyright (C) 2010, Alexander Senier
-- Copyright (C) 2010, secunet Security Networks AG
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- * Redistributions of source code must retain the above copyright notice,
-- this list of conditions and the following disclaimer.
--
-- * Redistributions in binary form must reproduce the above copyright
-- notice, this list of conditions and the following disclaimer in the
-- documentation and/or other materials provided with the distribution.
--
-- * Neither the name of the nor the names of its contributors may be used
-- to endorse or promote products derived from this software without
-- specific prior written permission.
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
-- BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-- POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------
with LSC.Internal.Types;
use type LSC.Internal.Types.Word64;
use type LSC.Internal.Types.Index;
-------------------------------------------------------------------------------
-- Operations over 64-bit words
-------------------------------------------------------------------------------
package LSC.Internal.Ops64 is
pragma Pure;
-- Perform XOR on two 64-bit words @V0@ and @V1@
function XOR2 (V0, V1 : Types.Word64) return Types.Word64
with Post => XOR2'Result = (V0 xor V1);
pragma Inline (XOR2);
-- Perform XOR on two arrays of 64-bit words
--
-- @Left@ - First input array <br>
-- @Right@ - Second input array <br>
-- @Result@ - Result array <br>
procedure Block_XOR
(Left : in Types.Word64_Array_Type;
Right : in Types.Word64_Array_Type;
Result : out Types.Word64_Array_Type)
with
Depends =>
(Result =>+ (Left, Right)),
Pre =>
Left'First = Right'First and
Left'Last = Right'Last and
Right'First = Result'First and
Right'Last = Result'Last,
Post =>
(for all I in Types.Index range Left'First .. Left'Last =>
(Result (I) = XOR2 (Left (I), Right (I))));
pragma Inline (Block_XOR);
-- Convert the eight byte values @Byte0@ .. @Byte7@ to a 64-bit word
function Bytes_To_Word
(Byte0 : Types.Byte;
Byte1 : Types.Byte;
Byte2 : Types.Byte;
Byte3 : Types.Byte;
Byte4 : Types.Byte;
Byte5 : Types.Byte;
Byte6 : Types.Byte;
Byte7 : Types.Byte) return Types.Word64;
pragma Inline (Bytes_To_Word);
-- Copy all elements of @Source@ to @Dest@. Should @Source@ be shorter than
-- @Dest@, remaining elements stay unchanged.
procedure Block_Copy
(Source : in Types.Word64_Array_Type;
Dest : in out Types.Word64_Array_Type)
with
Depends =>
(Dest =>+ Source),
Pre =>
Source'First = Dest'First and
Source'Last <= Dest'Last,
Post =>
(for all P in Types.Index range Source'First .. Source'Last =>
(Dest (P) = Source (P)));
pragma Inline (Block_Copy);
end LSC.Internal.Ops64;
|
reznikmm/matreshka | Ada | 20,306 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Ada Modeling Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2012, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with AMF.CMOF.Elements;
with AMF.DI.Styles;
with AMF.Internals.UMLDI_UML_Diagrams;
with AMF.UML.Behaviors;
with AMF.UML.Comments.Collections;
with AMF.UML.Dependencies.Collections;
with AMF.UML.Elements.Collections;
with AMF.UML.Interactions;
with AMF.UML.Named_Elements;
with AMF.UML.Namespaces.Collections;
with AMF.UML.Packages.Collections;
with AMF.UML.Parameterable_Elements;
with AMF.UML.String_Expressions;
with AMF.UML.Template_Parameters;
with AMF.UMLDI.UML_Interaction_Diagrams;
with AMF.UMLDI.UML_Labels;
with AMF.UMLDI.UML_Styles;
with AMF.Visitors;
with League.Strings;
package AMF.Internals.UMLDI_UML_Interaction_Diagrams is
type UMLDI_UML_Interaction_Diagram_Proxy is
limited new AMF.Internals.UMLDI_UML_Diagrams.UMLDI_UML_Diagram_Proxy
and AMF.UMLDI.UML_Interaction_Diagrams.UMLDI_UML_Interaction_Diagram with null record;
overriding function Get_Kind
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UMLDI.UMLDI_UML_Interaction_Diagram_Kind;
-- Getter of UMLInteractionDiagram::kind.
--
-- Indicates how an Interaction shall be shown.
overriding procedure Set_Kind
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UMLDI.UMLDI_UML_Interaction_Diagram_Kind);
-- Setter of UMLInteractionDiagram::kind.
--
-- Indicates how an Interaction shall be shown.
overriding function Get_Model_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Interactions.UML_Interaction_Access;
-- Getter of UMLInteractionDiagram::modelElement.
--
-- Restricts UMLInteractionDiagrams to showing Interactions.
overriding procedure Set_Model_Element
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UML.Interactions.UML_Interaction_Access);
-- Setter of UMLInteractionDiagram::modelElement.
--
-- Restricts UMLInteractionDiagrams to showing Interactions.
overriding function Get_Model_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Behaviors.UML_Behavior_Access;
-- Getter of UMLBehaviorDiagram::modelElement.
--
-- Restricts UMLBehaviorDiagrams to showing Behaviors.
overriding procedure Set_Model_Element
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UML.Behaviors.UML_Behavior_Access);
-- Setter of UMLBehaviorDiagram::modelElement.
--
-- Restricts UMLBehaviorDiagrams to showing Behaviors.
overriding function Get_Heading
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UMLDI.UML_Labels.UMLDI_UML_Label_Access;
-- Getter of UMLDiagram::heading.
--
overriding procedure Set_Heading
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UMLDI.UML_Labels.UMLDI_UML_Label_Access);
-- Setter of UMLDiagram::heading.
--
overriding function Get_Is_Frame
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return Boolean;
-- Getter of UMLDiagram::isFrame.
--
-- Indicates when diagram frames shall be shown.
overriding procedure Set_Is_Frame
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : Boolean);
-- Setter of UMLDiagram::isFrame.
--
-- Indicates when diagram frames shall be shown.
overriding function Get_Is_Iso
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return Boolean;
-- Getter of UMLDiagram::isIso.
--
-- Indicate when ISO notation rules shall be followed.
overriding procedure Set_Is_Iso
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : Boolean);
-- Setter of UMLDiagram::isIso.
--
-- Indicate when ISO notation rules shall be followed.
overriding function Get_Is_Icon
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return Boolean;
-- Getter of UMLDiagramElement::isIcon.
--
-- For modelElements that have an option to be shown with shapes other
-- than rectangles, such as Actors, or with other identifying shapes
-- inside them, such as arrows distinguishing InputPins and OutputPins, or
-- edges that have an option to be shown with lines other than solid with
-- open arrow heads, such as Realization. A value of true for isIcon
-- indicates the alternative notation shall be shown.
overriding procedure Set_Is_Icon
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : Boolean);
-- Setter of UMLDiagramElement::isIcon.
--
-- For modelElements that have an option to be shown with shapes other
-- than rectangles, such as Actors, or with other identifying shapes
-- inside them, such as arrows distinguishing InputPins and OutputPins, or
-- edges that have an option to be shown with lines other than solid with
-- open arrow heads, such as Realization. A value of true for isIcon
-- indicates the alternative notation shall be shown.
overriding function Get_Local_Style
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UMLDI.UML_Styles.UMLDI_UML_Style_Access;
-- Getter of UMLDiagramElement::localStyle.
--
-- Restricts owned styles to UMLStyles.
overriding procedure Set_Local_Style
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UMLDI.UML_Styles.UMLDI_UML_Style_Access);
-- Setter of UMLDiagramElement::localStyle.
--
-- Restricts owned styles to UMLStyles.
overriding function Get_Model_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Elements.Collections.Set_Of_UML_Element;
-- Getter of UMLDiagramElement::modelElement.
--
-- Restricts UMLDiagramElements to show UML Elements, rather than other
-- language elements.
overriding function Get_Model_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.CMOF.Elements.CMOF_Element_Access;
-- Getter of DiagramElement::modelElement.
--
-- a reference to a depicted model element, which can be any MOF-based
-- element
overriding function Get_Local_Style
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.DI.Styles.DI_Style_Access;
-- Getter of DiagramElement::localStyle.
--
-- a reference to an optional locally-owned style for this diagram element.
overriding procedure Set_Local_Style
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.DI.Styles.DI_Style_Access);
-- Setter of DiagramElement::localStyle.
--
-- a reference to an optional locally-owned style for this diagram element.
overriding function Get_Name
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return League.Strings.Universal_String;
-- Getter of Diagram::name.
--
-- the name of the diagram.
overriding procedure Set_Name
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : League.Strings.Universal_String);
-- Setter of Diagram::name.
--
-- the name of the diagram.
overriding function Get_Documentation
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return League.Strings.Universal_String;
-- Getter of Diagram::documentation.
--
-- the documentation of the diagram.
overriding procedure Set_Documentation
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : League.Strings.Universal_String);
-- Setter of Diagram::documentation.
--
-- the documentation of the diagram.
overriding function Get_Resolution
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.Real;
-- Getter of Diagram::resolution.
--
-- the resolution of the diagram expressed in user units per inch.
overriding procedure Set_Resolution
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.Real);
-- Setter of Diagram::resolution.
--
-- the resolution of the diagram expressed in user units per inch.
overriding function Get_Client_Dependency
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Dependencies.Collections.Set_Of_UML_Dependency;
-- Getter of NamedElement::clientDependency.
--
-- Indicates the dependencies that reference the client.
overriding function Get_Name
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.Optional_String;
-- Getter of NamedElement::name.
--
-- The name of the NamedElement.
overriding procedure Set_Name
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.Optional_String);
-- Setter of NamedElement::name.
--
-- The name of the NamedElement.
overriding function Get_Name_Expression
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.String_Expressions.UML_String_Expression_Access;
-- Getter of NamedElement::nameExpression.
--
-- The string expression used to define the name of this named element.
overriding procedure Set_Name_Expression
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UML.String_Expressions.UML_String_Expression_Access);
-- Setter of NamedElement::nameExpression.
--
-- The string expression used to define the name of this named element.
overriding function Get_Namespace
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Namespaces.UML_Namespace_Access;
-- Getter of NamedElement::namespace.
--
-- Specifies the namespace that owns the NamedElement.
overriding function Get_Qualified_Name
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.Optional_String;
-- Getter of NamedElement::qualifiedName.
--
-- A name which allows the NamedElement to be identified within a
-- hierarchy of nested Namespaces. It is constructed from the names of the
-- containing namespaces starting at the root of the hierarchy and ending
-- with the name of the NamedElement itself.
overriding function Get_Owned_Comment
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Comments.Collections.Set_Of_UML_Comment;
-- Getter of Element::ownedComment.
--
-- The Comments owned by this element.
overriding function Get_Owned_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Elements.Collections.Set_Of_UML_Element;
-- Getter of Element::ownedElement.
--
-- The Elements owned by this element.
overriding function Get_Owner
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Elements.UML_Element_Access;
-- Getter of Element::owner.
--
-- The Element that owns this element.
overriding function Get_Owning_Template_Parameter
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Template_Parameters.UML_Template_Parameter_Access;
-- Getter of ParameterableElement::owningTemplateParameter.
--
-- The formal template parameter that owns this element.
overriding procedure Set_Owning_Template_Parameter
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UML.Template_Parameters.UML_Template_Parameter_Access);
-- Setter of ParameterableElement::owningTemplateParameter.
--
-- The formal template parameter that owns this element.
overriding function Get_Template_Parameter
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Template_Parameters.UML_Template_Parameter_Access;
-- Getter of ParameterableElement::templateParameter.
--
-- The template parameter that exposes this element as a formal parameter.
overriding procedure Set_Template_Parameter
(Self : not null access UMLDI_UML_Interaction_Diagram_Proxy;
To : AMF.UML.Template_Parameters.UML_Template_Parameter_Access);
-- Setter of ParameterableElement::templateParameter.
--
-- The template parameter that exposes this element as a formal parameter.
overriding function All_Namespaces
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Namespaces.Collections.Ordered_Set_Of_UML_Namespace;
-- Operation NamedElement::allNamespaces.
--
-- The query allNamespaces() gives the sequence of namespaces in which the
-- NamedElement is nested, working outwards.
overriding function All_Owning_Packages
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Packages.Collections.Set_Of_UML_Package;
-- Operation NamedElement::allOwningPackages.
--
-- The query allOwningPackages() returns all the directly or indirectly
-- owning packages.
overriding function Is_Distinguishable_From
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy;
N : AMF.UML.Named_Elements.UML_Named_Element_Access;
Ns : AMF.UML.Namespaces.UML_Namespace_Access)
return Boolean;
-- Operation NamedElement::isDistinguishableFrom.
--
-- The query isDistinguishableFrom() determines whether two NamedElements
-- may logically co-exist within a Namespace. By default, two named
-- elements are distinguishable if (a) they have unrelated types or (b)
-- they have related types but different names.
overriding function Namespace
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Namespaces.UML_Namespace_Access;
-- Operation NamedElement::namespace.
--
-- Missing derivation for NamedElement::/namespace : Namespace
overriding function Qualified_Name
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return League.Strings.Universal_String;
-- Operation NamedElement::qualifiedName.
--
-- When there is a name, and all of the containing namespaces have a name,
-- the qualified name is constructed from the names of the containing
-- namespaces.
overriding function Separator
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return League.Strings.Universal_String;
-- Operation NamedElement::separator.
--
-- The query separator() gives the string that is used to separate names
-- when constructing a qualified name.
overriding function All_Owned_Elements
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return AMF.UML.Elements.Collections.Set_Of_UML_Element;
-- Operation Element::allOwnedElements.
--
-- The query allOwnedElements() gives all of the direct and indirect owned
-- elements of an element.
overriding function Is_Compatible_With
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy;
P : AMF.UML.Parameterable_Elements.UML_Parameterable_Element_Access)
return Boolean;
-- Operation ParameterableElement::isCompatibleWith.
--
-- The query isCompatibleWith() determines if this parameterable element
-- is compatible with the specified parameterable element. By default
-- parameterable element P is compatible with parameterable element Q if
-- the kind of P is the same or a subtype as the kind of Q. Subclasses
-- should override this operation to specify different compatibility
-- constraints.
overriding function Is_Template_Parameter
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy)
return Boolean;
-- Operation ParameterableElement::isTemplateParameter.
--
-- The query isTemplateParameter() determines if this parameterable
-- element is exposed as a formal template parameter.
overriding procedure Enter_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control);
overriding procedure Leave_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control);
overriding procedure Visit_Element
(Self : not null access constant UMLDI_UML_Interaction_Diagram_Proxy;
Iterator : in out AMF.Visitors.Abstract_Iterator'Class;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control);
end AMF.Internals.UMLDI_UML_Interaction_Diagrams;
|
reznikmm/matreshka | Ada | 3,642 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Ada Modeling Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2011-2012, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
-- This file is generated, don't edit it.
------------------------------------------------------------------------------
with AMF.Elements.Generic_Hash;
function AMF.Standard_Profile_L2.Refines.Hash is
new AMF.Elements.Generic_Hash (Standard_Profile_L2_Refine, Standard_Profile_L2_Refine_Access);
|
AdaCore/langkit | Ada | 8,991 | adb | --
-- Copyright (C) 2014-2022, AdaCore
-- SPDX-License-Identifier: Apache-2.0
--
with Ada.Unchecked_Deallocation;
with System; use System;
with System.Memory; use System.Memory;
package body Langkit_Support.Generic_Bump_Ptr is
use Pages_Vector;
procedure Dealloc is new Ada.Unchecked_Deallocation
(Bump_Ptr_Pool_Type, Bump_Ptr_Pool);
function Align (Size, Alignment : Storage_Offset) return Storage_Offset
with Inline;
-----------
-- Align --
-----------
function Align (Size, Alignment : Storage_Offset) return Storage_Offset is
M : constant Storage_Offset := Size mod Alignment;
begin
if M = 0 then
return Size;
else
return Size + (Alignment - M);
end if;
end Align;
------------
-- Create --
------------
function Create return Bump_Ptr_Pool is
begin
return new Bump_Ptr_Pool_Type;
end Create;
----------
-- Free --
----------
procedure Free (Pool : in out Bump_Ptr_Pool) is
begin
if Pool = No_Pool then
return;
end if;
-- Free every page allocated.
--
-- TODO: Might be interesting at some point to keep a global cache of
-- pages ourself, since we always use the same size.
for PI in First_Index (Pool.Pages) .. Last_Index (Pool.Pages) loop
Free (Get (Pool.Pages, PI));
end loop;
Destroy (Pool.Pages);
Dealloc (Pool);
end Free;
--------------
-- Allocate --
--------------
function Allocate
(Pool : Bump_Ptr_Pool; S : Storage_Offset) return System.Address
is
Obj_Offset : Storage_Offset;
begin
-- If the required size is bigger than the page size, we'll allocate a
-- special page the size of the required object. Basically we fall-back
-- on regular alloc mechanism, but this ensures that we can handle all
-- allocations transparently via this allocator.
if S > Page_Size then
declare
Mem : constant System.Address := System.Memory.Alloc (size_t (S));
begin
-- Append the allocated memory to the pool pages, so that it is
-- freed on pool free, but don't touch at the current_page, so
-- it can keep being used next time.
Append (Pool.Pages, Mem);
return Mem;
end;
end if;
-- When we don't have enough space to allocate the chunk, allocate a new
-- page.
if Page_Size - Pool.Current_Offset < S then
Pool.Current_Page := System.Memory.Alloc
(System.Memory.size_t (Page_Size));
Append (Pool.Pages, Pool.Current_Page);
Pool.Current_Offset := 0;
end if;
-- Allocation itself is as simple as bumping the offset pointer, and
-- returning the old value.
Obj_Offset := Pool.Current_Offset;
Pool.Current_Offset := Pool.Current_Offset + S;
return Pool.Current_Page + Obj_Offset;
end Allocate;
Pointer_Size : constant Storage_Offset :=
System.Address'Size / Storage_Unit;
-----------
-- Alloc --
-----------
package body Alloc is
-- All reads/writes on allocated objects will happen through
-- Element_Access, so there should be no issue with strict aliasing.
pragma Warnings (Off, "possible aliasing problem for type");
function To_Pointer is new Ada.Unchecked_Conversion
(System.Address, Element_Access);
pragma Warnings (On, "possible aliasing problem for type");
-----------
-- Alloc --
-----------
function Alloc (Pool : Bump_Ptr_Pool) return Element_Access is
begin
-- This function just queries the proper size of the Element_T type,
-- and converts the return value to the proper access type.
return To_Pointer
(Allocate
(Pool,
Align (Element_T'Max_Size_In_Storage_Elements, Pointer_Size)));
end Alloc;
end Alloc;
type Address_Access is access all System.Address;
------------------
-- Tagged_Alloc --
------------------
package body Tagged_Alloc is
T : aliased Element_T;
package Gen_Alloc is new
Langkit_Support.Generic_Bump_Ptr.Alloc (Element_T, Element_Access);
function Dirty_Conv is new
Ada.Unchecked_Conversion (Element_Access, Address_Access);
-----------
-- Alloc --
-----------
function Alloc (Pool : Bump_Ptr_Pool) return Element_Access is
-- This bit of code is actually quite funny. It is born out of the
-- conflation of several unfortunate design choices in Ada:
-- 1. The first one is that with Ada memory pools, you have to
-- declare the memory pool of your access type at the point of
-- definition of the access type. While this is fine and dandy for
-- global pools, in our case, when we want a scoped pool that links a
-- bunch of object's lifetime to another, this is highly unpractical.
-- It would make us declare new types in the scopes where we create
-- our object hierarchy, and do horrible casts everywhere.
-- 2. As a savvy Ada programmer, we then envision encapsulating this
-- logic in a generic. But this is impossible, because you cannot
-- declare a representation clause on a type that is declared in
-- the scope of a generic.
-- 3. Ok, so you cannot encapsulate in a generic. Let's do a memory
-- pool manually, like we'd do in C/C++. Problem is, you don't call
-- the new operator to instantiate tagged objects, so your tagged
-- objects are gonna have no tag!
-- 3. No problem, let's hack around it by creating a temp variable of
-- the type, and assigning to the newly allocated instance, so that
-- the tag is gonna be copied! Except assignment doesn't copy tags in
-- Ada.
-- Hence we are reduced to this dirty hack, where we'll create a temp
-- object, get the tag, and copy it manually in the newly created
-- object. This is dirty and completely implementation dependent.
-- So here be dragons.
-- Post-Scriptum: As it turns out, Ada 2012 memory subpools are
-- designed for exactly that purpose. This code survives because
-- GNAT's implementation of subpools is on average 10 times slower
-- than the ad-hoc allocation.
Ret : constant Element_Access := Gen_Alloc.Alloc (Pool);
T_Access : constant Element_Access := T'Unchecked_Access;
Tag_From : constant Address_Access := Dirty_Conv (T_Access);
Tag_To : constant Address_Access := Dirty_Conv (Ret);
begin
Ret.all := T;
Tag_To.all := Tag_From.all;
return Ret;
end Alloc;
end Tagged_Alloc;
-----------------
-- Array_Alloc --
-----------------
package body Array_Alloc is
-----------
-- Alloc --
-----------
function Alloc
(Pool : Bump_Ptr_Pool; Length : Natural) return Element_Array_Access
is
Stride : constant Storage_Offset :=
Align (Element_T'Max_Size_In_Storage_Elements, Pointer_Size);
Size : constant Storage_Offset := Stride * Storage_Offset (Length);
begin
return (if Length = 0
then Empty_Array_Access
else To_Pointer (Allocate (Pool, Size)));
end Alloc;
end Array_Alloc;
---------------------------
-- Allocate_From_Subpool --
---------------------------
overriding procedure Allocate_From_Subpool
(Pool : in out Ada_Bump_Ptr_Pool;
Storage_Address : out System.Address;
Size_In_Storage_Elements : System.Storage_Elements.Storage_Count;
Alignment : System.Storage_Elements.Storage_Count;
Subpool : not null Subpool_Handle)
is
pragma Unreferenced (Pool);
begin
Storage_Address := Allocate
(Bump_Ptr_Pool (Subpool), Align (Size_In_Storage_Elements, Alignment));
end Allocate_From_Subpool;
--------------------
-- Create_Subpool --
--------------------
overriding function Create_Subpool
(Pool : in out Ada_Bump_Ptr_Pool)
return not null Subpool_Handle
is
Res : constant Bump_Ptr_Pool := Create;
Subpool : constant Subpool_Handle := Subpool_Handle (Res);
begin
Set_Pool_Of_Subpool (Subpool, Pool);
return Subpool;
end Create_Subpool;
------------------------
-- Deallocate_Subpool --
------------------------
overriding procedure Deallocate_Subpool
(Pool : in out Ada_Bump_Ptr_Pool;
Subpool : in out Subpool_Handle)
is
pragma Unreferenced (Pool);
begin
Free (Bump_Ptr_Pool (Subpool));
end Deallocate_Subpool;
end Langkit_Support.Generic_Bump_Ptr;
|
OneWingedShark/Byron | Ada | 196 | ads | With
Ada.Containers.Indefinite_Holders;
Package Byron.Internals.Expressions.Holders is
new Ada.Containers.Indefinite_Holders(
Element_Type => Expression'Class
) with Preelaborate;
|
reznikmm/matreshka | Ada | 9,843 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Ada Modeling Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2012, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with AMF.Elements;
with AMF.Internals.Element_Collections;
with AMF.Internals.Helpers;
with AMF.Internals.Tables.UML_Attributes;
with AMF.Visitors.UMLDI_Iterators;
with AMF.Visitors.UMLDI_Visitors;
package body AMF.Internals.UMLDI_UML_Compartmentable_Shapes is
---------------------
-- Get_Compartment --
---------------------
overriding function Get_Compartment
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy)
return AMF.UMLDI.UML_Compartments.Collections.Ordered_Set_Of_UMLDI_UML_Compartment is
begin
return
AMF.UMLDI.UML_Compartments.Collections.Wrap
(AMF.Internals.Element_Collections.Wrap
(AMF.Internals.Tables.UML_Attributes.Internal_Get_Compartment
(Self.Element)));
end Get_Compartment;
-----------------
-- Get_Is_Icon --
-----------------
overriding function Get_Is_Icon
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy)
return Boolean is
begin
return
AMF.Internals.Tables.UML_Attributes.Internal_Get_Is_Icon
(Self.Element);
end Get_Is_Icon;
-----------------
-- Set_Is_Icon --
-----------------
overriding procedure Set_Is_Icon
(Self : not null access UMLDI_UML_Compartmentable_Shape_Proxy;
To : Boolean) is
begin
AMF.Internals.Tables.UML_Attributes.Internal_Set_Is_Icon
(Self.Element, To);
end Set_Is_Icon;
---------------------
-- Get_Local_Style --
---------------------
overriding function Get_Local_Style
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy)
return AMF.UMLDI.UML_Styles.UMLDI_UML_Style_Access is
begin
return
AMF.UMLDI.UML_Styles.UMLDI_UML_Style_Access
(AMF.Internals.Helpers.To_Element
(AMF.Internals.Tables.UML_Attributes.Internal_Get_Local_Style
(Self.Element)));
end Get_Local_Style;
---------------------
-- Set_Local_Style --
---------------------
overriding procedure Set_Local_Style
(Self : not null access UMLDI_UML_Compartmentable_Shape_Proxy;
To : AMF.UMLDI.UML_Styles.UMLDI_UML_Style_Access) is
begin
AMF.Internals.Tables.UML_Attributes.Internal_Set_Local_Style
(Self.Element,
AMF.Internals.Helpers.To_Element
(AMF.Elements.Element_Access (To)));
end Set_Local_Style;
-----------------------
-- Get_Model_Element --
-----------------------
overriding function Get_Model_Element
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy)
return AMF.UML.Elements.Collections.Set_Of_UML_Element is
begin
raise Program_Error;
return X : AMF.UML.Elements.Collections.Set_Of_UML_Element;
-- return
-- AMF.UML.Elements.Collections.Wrap
-- (AMF.Internals.Element_Collections.Wrap
-- (AMF.Internals.Tables.UML_Attributes.Internal_Get_Model_Element
-- (Self.Element)));
end Get_Model_Element;
-----------------------
-- Get_Model_Element --
-----------------------
overriding function Get_Model_Element
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy)
return AMF.CMOF.Elements.CMOF_Element_Access is
begin
return
AMF.CMOF.Elements.CMOF_Element_Access
(AMF.Internals.Helpers.To_Element
(AMF.Internals.Tables.UML_Attributes.Internal_Get_Model_Element
(Self.Element)));
end Get_Model_Element;
---------------------
-- Get_Local_Style --
---------------------
overriding function Get_Local_Style
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy)
return AMF.DI.Styles.DI_Style_Access is
begin
return
AMF.DI.Styles.DI_Style_Access
(AMF.Internals.Helpers.To_Element
(AMF.Internals.Tables.UML_Attributes.Internal_Get_Local_Style
(Self.Element)));
end Get_Local_Style;
---------------------
-- Set_Local_Style --
---------------------
overriding procedure Set_Local_Style
(Self : not null access UMLDI_UML_Compartmentable_Shape_Proxy;
To : AMF.DI.Styles.DI_Style_Access) is
begin
AMF.Internals.Tables.UML_Attributes.Internal_Set_Local_Style
(Self.Element,
AMF.Internals.Helpers.To_Element
(AMF.Elements.Element_Access (To)));
end Set_Local_Style;
-------------------
-- Enter_Element --
-------------------
overriding procedure Enter_Element
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control) is
begin
if Visitor in AMF.Visitors.UMLDI_Visitors.UMLDI_Visitor'Class then
AMF.Visitors.UMLDI_Visitors.UMLDI_Visitor'Class
(Visitor).Enter_UML_Compartmentable_Shape
(AMF.UMLDI.UML_Compartmentable_Shapes.UMLDI_UML_Compartmentable_Shape_Access (Self),
Control);
end if;
end Enter_Element;
-------------------
-- Leave_Element --
-------------------
overriding procedure Leave_Element
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control) is
begin
if Visitor in AMF.Visitors.UMLDI_Visitors.UMLDI_Visitor'Class then
AMF.Visitors.UMLDI_Visitors.UMLDI_Visitor'Class
(Visitor).Leave_UML_Compartmentable_Shape
(AMF.UMLDI.UML_Compartmentable_Shapes.UMLDI_UML_Compartmentable_Shape_Access (Self),
Control);
end if;
end Leave_Element;
-------------------
-- Visit_Element --
-------------------
overriding procedure Visit_Element
(Self : not null access constant UMLDI_UML_Compartmentable_Shape_Proxy;
Iterator : in out AMF.Visitors.Abstract_Iterator'Class;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control) is
begin
if Iterator in AMF.Visitors.UMLDI_Iterators.UMLDI_Iterator'Class then
AMF.Visitors.UMLDI_Iterators.UMLDI_Iterator'Class
(Iterator).Visit_UML_Compartmentable_Shape
(Visitor,
AMF.UMLDI.UML_Compartmentable_Shapes.UMLDI_UML_Compartmentable_Shape_Access (Self),
Control);
end if;
end Visit_Element;
end AMF.Internals.UMLDI_UML_Compartmentable_Shapes;
|
zhmu/ananas | Ada | 4,211 | ads | ------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- G N A T . B R A N C H _ P R E D I C T I O N --
-- --
-- S p e c --
-- --
-- Copyright (C) 2019-2022, AdaCore --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This package provides routines giving hints to the branch predictor of the
-- code generator. These hints are useful when optimization is enabled and the
-- branch probability heuristics are used (which is the default), but they are
-- overridden when profile feedback-directed optimization is used instead.
-- The canonical pattern is to use them as the condition of an If statement:
--
-- if Likely (X > 0) then
-- Do_Something;
-- end if;
--
-- when it is not obvious that one outcome of the condition is more likely
-- than the other, or else to reverse the prediction made by the heuristics
-- in very peculiar cases. In the other cases, it is better not to use them,
-- because predicting how programs actually perform is notoriously hard.
package GNAT.Branch_Prediction is
pragma Pure;
function Expect (Condition : Boolean; Outcome : Boolean) return Boolean;
pragma Import (Intrinsic, Expect, "__builtin_expect");
-- This function returns the value of its first parameter Condition and
-- tells the branch predictor that this value is expected to be Outcome.
function Likely (Condition : Boolean) return Boolean;
pragma Import (Intrinsic, Likely, "__builtin_likely");
-- This function returns the value of its parameter Condition and tells
-- the branch predictor that this value is expected to be True. Calling
-- it is strictly equivalent to calling Expect with Outcome set to True.
function Unlikely (Condition : Boolean) return Boolean;
pragma Import (Intrinsic, Unlikely, "__builtin_unlikely");
-- This function returns the value of its parameter Condition and tells
-- the branch predictor that this value is expected to be False. Calling
-- it is strictly equivalent to calling Expect with Outcome set to False.
end GNAT.Branch_Prediction;
|
Componolit/libsparkcrypto | Ada | 2,275 | ads | -------------------------------------------------------------------------------
-- This file is part of libsparkcrypto.
--
-- @author Alexander Senier
-- @date 2019-01-23
--
-- Copyright (C) 2018 Componolit GmbH
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- * Redistributions of source code must retain the above copyright notice,
-- this list of conditions and the following disclaimer.
--
-- * Redistributions in binary form must reproduce the above copyright
-- notice, this list of conditions and the following disclaimer in the
-- documentation and/or other materials provided with the distribution.
--
-- * Neither the name of the nor the names of its contributors may be used
-- to endorse or promote products derived from this software without
-- specific prior written permission.
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
-- BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-- POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------
with LSC.SHA1_Generic;
with LSC.Types;
pragma Elaborate_All (LSC.SHA1_Generic);
package LSC.SHA1
is
pragma Pure;
subtype Hash_Index is Types.Natural_Index range 1 .. 20;
subtype Hash_Type is Types.Bytes (Hash_Index);
function Hash is new LSC.SHA1_Generic.Hash
(Types.Natural_Index, Types.Byte, Types.Bytes,
Hash_Index, Types.Byte, Hash_Type);
end LSC.SHA1;
|
docandrew/troodon | Ada | 4,352 | ads | pragma Ada_2012;
pragma Style_Checks (Off);
with Interfaces.C; use Interfaces.C;
limited with bits_types_struct_timeval_h;
limited with bits_types_struct_timespec_h;
limited with bits_types_u_sigset_t_h;
package sys_select_h is
-- unsupported macro: FD_SETSIZE __FD_SETSIZE
-- unsupported macro: NFDBITS __NFDBITS
-- arg-macro: procedure FD_SET (fd, fdsetp)
-- __FD_SET (fd, fdsetp)
-- arg-macro: procedure FD_CLR (fd, fdsetp)
-- __FD_CLR (fd, fdsetp)
-- arg-macro: procedure FD_ISSET (fd, fdsetp)
-- __FD_ISSET (fd, fdsetp)
-- arg-macro: procedure FD_ZERO (fdsetp)
-- __FD_ZERO (fdsetp)
-- `fd_set' type and related macros, and `select'/`pselect' declarations.
-- Copyright (C) 1996-2021 Free Software Foundation, Inc.
-- This file is part of the GNU C Library.
-- The GNU C Library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License, or (at your option) any later version.
-- The GNU C Library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
-- You should have received a copy of the GNU Lesser General Public
-- License along with the GNU C Library; if not, see
-- <https://www.gnu.org/licenses/>.
-- POSIX 1003.1g: 6.2 Select from File Descriptor Sets <sys/select.h>
-- Get definition of needed basic types.
-- Get __FD_* definitions.
-- Get sigset_t.
-- Get definition of timer specification structures.
-- The fd_set member is required to be an array of longs.
subtype uu_fd_mask is long; -- /usr/include/sys/select.h:49
-- Some versions of <linux/posix_types.h> define this macros.
-- It's easier to assume 8-bit bytes than to get CHAR_BIT.
-- fd_set for select and pselect.
-- XPG4.2 requires this member name. Otherwise avoid the name
-- from the global namespace.
-- skipped anonymous struct anon_2
type fd_set_array947 is array (0 .. 15) of aliased uu_fd_mask;
type fd_set is record
fds_bits : aliased fd_set_array947; -- /usr/include/sys/select.h:64
end record
with Convention => C_Pass_By_Copy; -- /usr/include/sys/select.h:70
-- Maximum number of file descriptors in `fd_set'.
-- Sometimes the fd_set member is assumed to have this type.
subtype fd_mask is uu_fd_mask; -- /usr/include/sys/select.h:77
-- Number of bits per word of `fd_set' (some code assumes this is 32).
-- Access macros for `fd_set'.
-- Check the first NFDS descriptors each in READFDS (if not NULL) for read
-- readiness, in WRITEFDS (if not NULL) for write readiness, and in EXCEPTFDS
-- (if not NULL) for exceptional conditions. If TIMEOUT is not NULL, time out
-- after waiting the interval specified therein. Returns the number of ready
-- descriptors, or -1 for errors.
-- This function is a cancellation point and therefore not marked with
-- __THROW.
function c_select
(uu_nfds : int;
uu_readfds : access fd_set;
uu_writefds : access fd_set;
uu_exceptfds : access fd_set;
uu_timeout : access bits_types_struct_timeval_h.timeval) return int -- /usr/include/sys/select.h:101
with Import => True,
Convention => C,
External_Name => "select";
-- Same as above only that the TIMEOUT value is given with higher
-- resolution and a sigmask which is been set temporarily. This version
-- should be used.
-- This function is a cancellation point and therefore not marked with
-- __THROW.
function pselect
(uu_nfds : int;
uu_readfds : access fd_set;
uu_writefds : access fd_set;
uu_exceptfds : access fd_set;
uu_timeout : access constant bits_types_struct_timespec_h.timespec;
uu_sigmask : access constant bits_types_u_sigset_t_h.uu_sigset_t) return int -- /usr/include/sys/select.h:113
with Import => True,
Convention => C,
External_Name => "pselect";
-- Define some inlines helping to catch common problems.
end sys_select_h;
|
sungyeon/drake | Ada | 1,556 | ads | pragma License (Unrestricted);
-- extended unit
private with System.Unbounded_Allocators;
package System.Storage_Pools.Subpools.Unbounded is
-- The subpools version of System.Storage_Pools.Unbounded.
pragma Preelaborate;
type Unbounded_Pool_With_Subpools is
limited new Root_Storage_Pool_With_Subpools with private;
-- Note: Default_Subpool_For_Pool is not supported.
private
type Unbounded_Subpool is limited new Root_Subpool with record
Allocator : Unbounded_Allocators.Unbounded_Allocator;
end record;
type Unbounded_Pool_With_Subpools is
limited new Root_Storage_Pool_With_Subpools with null record;
pragma Finalize_Storage_Only (Unbounded_Pool_With_Subpools);
overriding function Create_Subpool (
Pool : in out Unbounded_Pool_With_Subpools)
return not null Subpool_Handle;
overriding procedure Allocate_From_Subpool (
Pool : in out Unbounded_Pool_With_Subpools;
Storage_Address : out Address;
Size_In_Storage_Elements : Storage_Elements.Storage_Count;
Alignment : Storage_Elements.Storage_Count;
Subpool : not null Subpool_Handle);
overriding procedure Deallocate_Subpool (
Pool : in out Unbounded_Pool_With_Subpools;
Subpool : in out Subpool_Handle);
overriding procedure Deallocate (
Pool : in out Unbounded_Pool_With_Subpools;
Storage_Address : Address;
Size_In_Storage_Elements : Storage_Elements.Storage_Count;
Alignment : Storage_Elements.Storage_Count);
end System.Storage_Pools.Subpools.Unbounded;
|
BrickBot/Bound-T-H8-300 | Ada | 3,842 | adb | -- Programs.Synonyms (body)
--
-- A component of the Bound-T Worst-Case Execution Time Tool.
--
-------------------------------------------------------------------------------
-- Copyright (c) 1999 .. 2015 Tidorum Ltd
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- 1. Redistributions of source code must retain the above copyright notice, this
-- list of conditions and the following disclaimer.
-- 2. Redistributions in binary form must reproduce the above copyright notice,
-- this list of conditions and the following disclaimer in the documentation
-- and/or other materials provided with the distribution.
--
-- This software is provided by the copyright holders and contributors "as is" and
-- any express or implied warranties, including, but not limited to, the implied
-- warranties of merchantability and fitness for a particular purpose are
-- disclaimed. In no event shall the copyright owner or contributors be liable for
-- any direct, indirect, incidental, special, exemplary, or consequential damages
-- (including, but not limited to, procurement of substitute goods or services;
-- loss of use, data, or profits; or business interruption) however caused and
-- on any theory of liability, whether in contract, strict liability, or tort
-- (including negligence or otherwise) arising in any way out of the use of this
-- software, even if advised of the possibility of such damage.
--
-- Other modules (files) of this software composition should contain their
-- own copyright statements, which may have different copyright and usage
-- conditions. The above conditions apply to this file.
-------------------------------------------------------------------------------
--
-- $Revision: 1.2 $
-- $Date: 2015/10/24 20:05:51 $
--
-- $Log: programs-synonyms.adb,v $
-- Revision 1.2 2015/10/24 20:05:51 niklas
-- Moved to free licence.
--
-- Revision 1.1 2007-07-27 20:24:19 niklas
-- BT-CH-0068. Option -synonyms.
--
with Output;
with Symbols;
package body Programs.Synonyms is
Synonym_Key : constant String := "Synonym";
--
-- The key for the basic output lines.
procedure Show (Subprogram : in Subprogram_T)
is
use Symbols;
Sub_Name : constant String := Name (Subprogram, Qualified => True);
-- The full name of this Subprogram.
Conns : constant Connection_Set_T :=
Connections_For_Address (
Address => Entry_Address (Subprogram),
Within => Symbol_Table (Program (Subprogram)));
-- All connections for this entry address.
Mark : Output.Nest_Mark_T;
-- For this Subprogram.
begin
Mark := Output.Nest (Locus (Subprogram, Qualified => True));
for C in Conns'Range loop
case Kind_Of (Conns(C)) is
when Symbols.Subprogram
| Symbols.Label =>
declare
Syno_Name : constant String := Scoped_Name_Of (Conns(C));
-- The synonym name.
begin
if Syno_Name /= Sub_Name then
Output.Result (
Key => Synonym_Key,
Text => Scoped_Name_Of (Conns(C)));
end if;
end;
when others =>
null;
end case;
end loop;
Output.Unnest (Mark);
exception
when others =>
Output.Unnest (Mark);
raise;
end Show;
procedure Show (Program : in Program_T)
is
Subs : constant Subprogram_List_T := Subprograms (Program);
-- All subprograms so far defined in the Program.
begin
for S in Subs'Range loop
Show (Subprogram => Subs(S));
end loop;
end Show;
end Programs.Synonyms;
|
caqg/linux-home | Ada | 960,313 | adb | -- generated parser support file.
-- command line: wisitoken-bnf-generate.exe --generate LALR Ada_Emacs re2c PROCESS ada.wy
--
-- Copyright (C) 2013 - 2019 Free Software Foundation, Inc.
-- This program is free software; you can redistribute it and/or
-- modify it under the terms of the GNU General Public License as
-- published by the Free Software Foundation; either version 3, or (at
-- your option) any later version.
--
-- This software is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
with Ada_Process_Actions; use Ada_Process_Actions;
with WisiToken.Lexer.re2c;
with ada_re2c_c;
package body Ada_Process_LALR_Main is
package Lexer is new WisiToken.Lexer.re2c
(ada_re2c_c.New_Lexer,
ada_re2c_c.Free_Lexer,
ada_re2c_c.Reset_Lexer,
ada_re2c_c.Next_Token);
procedure Create_Parser
(Parser : out WisiToken.Parse.LR.Parser.Parser;
Language_Fixes : in WisiToken.Parse.LR.Parser.Language_Fixes_Access;
Language_Matching_Begin_Tokens : in WisiToken.Parse.LR.Parser.Language_Matching_Begin_Tokens_Access;
Language_String_ID_Set : in WisiToken.Parse.LR.Parser.Language_String_ID_Set_Access;
Trace : not null access WisiToken.Trace'Class;
User_Data : in WisiToken.Syntax_Trees.User_Data_Access)
is
use WisiToken.Parse.LR;
McKenzie_Param : constant McKenzie_Param_Type :=
(First_Terminal => 3,
Last_Terminal => 107,
First_Nonterminal => 108,
Last_Nonterminal => 332,
Insert =>
(4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
Delete =>
(4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
Push_Back =>
(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2),
Undo_Reduce =>
(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2),
Minimal_Complete_Cost_Delta => -3,
Fast_Forward => 2,
Matching_Begin => 3,
Ignore_Check_Fail => 2,
Task_Count => 0,
Check_Limit => 4,
Check_Delta_Limit => 100,
Enqueue_Limit => 45000);
Table : constant Parse_Table_Ptr := new Parse_Table
(State_First => 0,
State_Last => 1281,
First_Terminal => 3,
Last_Terminal => 107,
First_Nonterminal => 108,
Last_Nonterminal => 332);
begin
Table.McKenzie_Param := McKenzie_Param;
declare
procedure Subr_1
is begin
Add_Action (Table.States (0), 4, 1);
Add_Action (Table.States (0), 5, 2);
Add_Action (Table.States (0), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (0), 15, 3);
Add_Action (Table.States (0), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (0), 18, 4);
Add_Action (Table.States (0), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (0), 27, 5);
Add_Action (Table.States (0), 28, 6);
Add_Conflict (Table.States (0), 28, (132, 1), 0, null, null);
Add_Action (Table.States (0), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (0), 30, 8);
Add_Action (Table.States (0), 31, 9);
Add_Action (Table.States (0), 32, 10);
Add_Action (Table.States (0), 36, 11);
Add_Action (Table.States (0), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (0), 40, 12);
Add_Action (Table.States (0), 41, 13);
Add_Action (Table.States (0), 46, 14);
Add_Action (Table.States (0), 47, 15);
Add_Action (Table.States (0), 48, 16);
Add_Action (Table.States (0), 49, 17);
Add_Action (Table.States (0), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (0), 51, 19);
Add_Action (Table.States (0), 52, 20);
Add_Action (Table.States (0), 57, 21);
Add_Action (Table.States (0), 58, 22);
Add_Action (Table.States (0), 60, 23);
Add_Action (Table.States (0), 61, 24);
Add_Action (Table.States (0), 63, 25);
Add_Action (Table.States (0), 66, 26);
Add_Action (Table.States (0), 69, 27);
Add_Action (Table.States (0), 71, 28);
Add_Action (Table.States (0), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (0), 74, 30);
Add_Action (Table.States (0), 93, 31);
Add_Action (Table.States (0), 104, 32);
Add_Action (Table.States (0), 105, 33);
Add_Action (Table.States (0), 106, 34);
Add_Error (Table.States (0));
Add_Goto (Table.States (0), 112, 35);
Add_Goto (Table.States (0), 113, 36);
Add_Goto (Table.States (0), 121, 37);
Add_Goto (Table.States (0), 123, 38);
Add_Goto (Table.States (0), 126, 39);
Add_Goto (Table.States (0), 127, 40);
Add_Goto (Table.States (0), 128, 41);
Add_Goto (Table.States (0), 131, 42);
Add_Goto (Table.States (0), 132, 43);
Add_Goto (Table.States (0), 133, 44);
Add_Goto (Table.States (0), 134, 45);
Add_Goto (Table.States (0), 135, 46);
Add_Goto (Table.States (0), 139, 47);
Add_Goto (Table.States (0), 142, 48);
Add_Goto (Table.States (0), 143, 49);
Add_Goto (Table.States (0), 151, 50);
Add_Goto (Table.States (0), 152, 51);
Add_Goto (Table.States (0), 157, 52);
Add_Goto (Table.States (0), 161, 53);
Add_Goto (Table.States (0), 179, 54);
Add_Goto (Table.States (0), 182, 55);
Add_Goto (Table.States (0), 186, 56);
Add_Goto (Table.States (0), 190, 57);
Add_Goto (Table.States (0), 193, 58);
Add_Goto (Table.States (0), 196, 59);
Add_Goto (Table.States (0), 206, 60);
Add_Goto (Table.States (0), 207, 61);
Add_Goto (Table.States (0), 209, 62);
Add_Goto (Table.States (0), 210, 63);
Add_Goto (Table.States (0), 213, 64);
Add_Goto (Table.States (0), 214, 65);
Add_Goto (Table.States (0), 215, 66);
Add_Goto (Table.States (0), 216, 67);
Add_Goto (Table.States (0), 217, 68);
Add_Goto (Table.States (0), 219, 69);
Add_Goto (Table.States (0), 222, 70);
Add_Goto (Table.States (0), 223, 71);
Add_Goto (Table.States (0), 232, 72);
Add_Goto (Table.States (0), 239, 73);
Add_Goto (Table.States (0), 243, 74);
Add_Goto (Table.States (0), 244, 75);
Add_Goto (Table.States (0), 245, 76);
Add_Goto (Table.States (0), 246, 77);
Add_Goto (Table.States (0), 247, 78);
Add_Goto (Table.States (0), 248, 79);
Add_Goto (Table.States (0), 249, 80);
Add_Goto (Table.States (0), 250, 81);
Add_Goto (Table.States (0), 251, 82);
Add_Goto (Table.States (0), 257, 83);
Add_Goto (Table.States (0), 259, 84);
Add_Goto (Table.States (0), 260, 85);
Add_Goto (Table.States (0), 261, 86);
Add_Goto (Table.States (0), 262, 87);
Add_Goto (Table.States (0), 263, 88);
Add_Goto (Table.States (0), 264, 89);
Add_Goto (Table.States (0), 265, 90);
Add_Goto (Table.States (0), 271, 91);
Add_Goto (Table.States (0), 272, 92);
Add_Goto (Table.States (0), 276, 93);
Add_Goto (Table.States (0), 281, 94);
Add_Goto (Table.States (0), 289, 95);
Add_Goto (Table.States (0), 290, 96);
Add_Goto (Table.States (0), 293, 97);
Add_Goto (Table.States (0), 294, 98);
Add_Goto (Table.States (0), 298, 99);
Add_Goto (Table.States (0), 302, 100);
Add_Goto (Table.States (0), 303, 101);
Add_Goto (Table.States (0), 304, 102);
Add_Goto (Table.States (0), 305, 103);
Add_Goto (Table.States (0), 306, 104);
Add_Goto (Table.States (0), 307, 105);
Add_Goto (Table.States (0), 308, 106);
Add_Goto (Table.States (0), 309, 107);
Add_Goto (Table.States (0), 311, 108);
Add_Goto (Table.States (0), 313, 109);
Add_Goto (Table.States (0), 315, 110);
Add_Goto (Table.States (0), 316, 111);
Add_Goto (Table.States (0), 317, 112);
Add_Goto (Table.States (0), 319, 113);
Add_Goto (Table.States (0), 323, 114);
Add_Goto (Table.States (0), 325, 115);
Add_Goto (Table.States (0), 331, 116);
Add_Goto (Table.States (0), 332, 117);
Table.States (0).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 41, 13)));
Add_Action (Table.States (1), 104, 118);
Add_Error (Table.States (1));
Table.States (1).Kernel := To_Vector (((113, 4, 4, False), (113, 4, 2, False)));
Table.States (1).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 118)));
Add_Action (Table.States (2), 104, 119);
Add_Action (Table.States (2), 105, 33);
Add_Action (Table.States (2), 106, 34);
Add_Error (Table.States (2));
Add_Goto (Table.States (2), 128, 41);
Add_Goto (Table.States (2), 239, 120);
Add_Goto (Table.States (2), 272, 92);
Add_Goto (Table.States (2), 293, 97);
Table.States (2).Kernel := To_Vector ((0 => (303, 5, 2, False)));
Table.States (2).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (3), 3, 121);
Add_Action (Table.States (3), 35, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (3), 39, 122);
Add_Action (Table.States (3), 40, 123);
Add_Action (Table.States (3), 41, 124);
Add_Action (Table.States (3), 52, 125);
Add_Action (Table.States (3), 76, 126);
Add_Action (Table.States (3), 94, 127);
Add_Action (Table.States (3), 95, 128);
Add_Action (Table.States (3), 103, 129);
Add_Action (Table.States (3), 104, 119);
Add_Action (Table.States (3), 105, 33);
Add_Action (Table.States (3), 106, 34);
Add_Error (Table.States (3));
Add_Goto (Table.States (3), 117, 130);
Add_Goto (Table.States (3), 128, 41);
Add_Goto (Table.States (3), 191, 131);
Add_Goto (Table.States (3), 192, 132);
Add_Goto (Table.States (3), 197, 133);
Add_Goto (Table.States (3), 239, 134);
Add_Goto (Table.States (3), 258, 135);
Add_Goto (Table.States (3), 272, 92);
Add_Goto (Table.States (3), 275, 136);
Add_Goto (Table.States (3), 282, 137);
Add_Goto (Table.States (3), 283, 138);
Add_Goto (Table.States (3), 284, 139);
Add_Goto (Table.States (3), 285, 140);
Add_Goto (Table.States (3), 286, 141);
Add_Goto (Table.States (3), 287, 142);
Add_Goto (Table.States (3), 293, 97);
Add_Goto (Table.States (3), 301, 143);
Add_Goto (Table.States (3), 320, 144);
Add_Goto (Table.States (3), 321, 145);
Add_Goto (Table.States (3), 330, 146);
Table.States (3).Kernel := To_Vector ((0 => (139, 15, 6, False)));
Table.States (3).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (4), 3, 121);
Add_Action (Table.States (4), 39, 122);
Add_Action (Table.States (4), 40, 123);
Add_Action (Table.States (4), 41, 124);
Add_Action (Table.States (4), 52, 125);
Add_Action (Table.States (4), 70, 147);
Add_Action (Table.States (4), 76, 126);
Add_Action (Table.States (4), 94, 127);
Add_Action (Table.States (4), 95, 128);
Add_Action (Table.States (4), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (4), 103, 129);
Add_Action (Table.States (4), 104, 119);
Add_Action (Table.States (4), 105, 33);
Add_Action (Table.States (4), 106, 34);
Add_Error (Table.States (4));
Add_Goto (Table.States (4), 117, 130);
Add_Goto (Table.States (4), 128, 41);
Add_Goto (Table.States (4), 191, 131);
Add_Goto (Table.States (4), 192, 148);
Add_Goto (Table.States (4), 197, 133);
Add_Goto (Table.States (4), 239, 134);
Add_Goto (Table.States (4), 258, 135);
Add_Goto (Table.States (4), 272, 92);
Add_Goto (Table.States (4), 275, 136);
Add_Goto (Table.States (4), 282, 137);
Add_Goto (Table.States (4), 283, 138);
Add_Goto (Table.States (4), 284, 139);
Add_Goto (Table.States (4), 285, 140);
Add_Goto (Table.States (4), 286, 141);
Add_Goto (Table.States (4), 287, 142);
Add_Goto (Table.States (4), 293, 97);
Add_Goto (Table.States (4), 301, 143);
Add_Goto (Table.States (4), 320, 144);
Add_Goto (Table.States (4), 321, 145);
Add_Goto (Table.States (4), 330, 146);
Table.States (4).Kernel := To_Vector (((161, 18, 2, False), (161, 18, 1, False)));
Table.States (4).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (5), 72, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (5), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (5), 104, 149);
Add_Error (Table.States (5));
Add_Goto (Table.States (5), 220, 150);
Table.States (5).Kernel := To_Vector (((190, 27, 2, False), (190, 27, 1, False)));
Table.States (5).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (6), 104, 151);
Add_Action (Table.States (6), 105, 152);
Add_Action (Table.States (6), 106, 34);
Add_Error (Table.States (6));
Add_Goto (Table.States (6), 128, 153);
Add_Goto (Table.States (6), 163, 154);
Add_Goto (Table.States (6), 230, 155);
Add_Goto (Table.States (6), 231, 156);
Add_Goto (Table.States (6), 239, 157);
Add_Goto (Table.States (6), 272, 92);
Add_Goto (Table.States (6), 293, 97);
Table.States (6).Kernel := To_Vector (((121, 28, 5, False), (127, 28, 4, False), (182, 28, 5, False), (229,
28, 0, False), (281, 28, 14, False)));
Table.States (6).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 231, 0)));
Add_Action (Table.States (7), 104, 119);
Add_Action (Table.States (7), 105, 33);
Add_Action (Table.States (7), 106, 34);
Add_Error (Table.States (7));
Add_Goto (Table.States (7), 128, 41);
Add_Goto (Table.States (7), 239, 158);
Add_Goto (Table.States (7), 272, 92);
Add_Goto (Table.States (7), 293, 97);
Table.States (7).Kernel := To_Vector ((0 => (207, 29, 2, False)));
Table.States (7).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (8), 29, 159);
Add_Conflict (Table.States (8), 29, (210, 1), 1, generic_formal_part_1'Access, null);
Add_Action (Table.States (8), 47, 160);
Add_Conflict (Table.States (8), 47, (210, 1), 1, generic_formal_part_1'Access, null);
Add_Action (Table.States (8), 48, 16);
Add_Action (Table.States (8), 50, 161);
Add_Conflict (Table.States (8), 50, (210, 1), 1, generic_formal_part_1'Access, null);
Add_Action (Table.States (8), 69, 162);
Add_Action (Table.States (8), 71, 28);
Add_Action (Table.States (8), 74, 163);
Add_Action (Table.States (8), 104, 164);
Add_Error (Table.States (8));
Add_Goto (Table.States (8), 198, 165);
Add_Goto (Table.States (8), 200, 166);
Add_Goto (Table.States (8), 201, 167);
Add_Goto (Table.States (8), 204, 168);
Add_Goto (Table.States (8), 211, 169);
Add_Goto (Table.States (8), 212, 170);
Add_Goto (Table.States (8), 219, 171);
Add_Goto (Table.States (8), 257, 172);
Add_Goto (Table.States (8), 331, 173);
Table.States (8).Kernel := To_Vector (((210, 30, 3, False), (210, 30, 0, False), (215, 30, 5, False), (215,
30, 5, False), (215, 30, 5, False)));
Table.States (8).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 210, 1)));
Add_Action (Table.States (9), 104, 174);
Add_Error (Table.States (9));
Table.States (9).Kernel := To_Vector ((0 => (303, 31, 2, False)));
Table.States (9).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 174)));
Add_Action (Table.States (10), 3, 121);
Add_Action (Table.States (10), 39, 122);
Add_Action (Table.States (10), 40, 123);
Add_Action (Table.States (10), 41, 124);
Add_Action (Table.States (10), 52, 125);
Add_Action (Table.States (10), 68, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (10), 76, 126);
Add_Action (Table.States (10), 94, 127);
Add_Action (Table.States (10), 95, 128);
Add_Action (Table.States (10), 103, 129);
Add_Action (Table.States (10), 104, 119);
Add_Action (Table.States (10), 105, 33);
Add_Action (Table.States (10), 106, 34);
Add_Error (Table.States (10));
Add_Goto (Table.States (10), 117, 130);
Add_Goto (Table.States (10), 128, 41);
Add_Goto (Table.States (10), 191, 131);
Add_Goto (Table.States (10), 192, 175);
Add_Goto (Table.States (10), 197, 133);
Add_Goto (Table.States (10), 239, 134);
Add_Goto (Table.States (10), 258, 135);
Add_Goto (Table.States (10), 272, 92);
Add_Goto (Table.States (10), 275, 136);
Add_Goto (Table.States (10), 282, 137);
Add_Goto (Table.States (10), 283, 138);
Add_Goto (Table.States (10), 284, 139);
Add_Goto (Table.States (10), 285, 140);
Add_Goto (Table.States (10), 286, 141);
Add_Goto (Table.States (10), 287, 142);
Add_Goto (Table.States (10), 293, 97);
Add_Goto (Table.States (10), 301, 143);
Add_Goto (Table.States (10), 320, 144);
Add_Goto (Table.States (10), 321, 145);
Add_Goto (Table.States (10), 330, 146);
Table.States (10).Kernel := To_Vector (((222, 32, 7, False), (222, 32, 5, False), (222, 32, 6, False),
(222, 32, 4, False)));
Table.States (10).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (11), 49, 176);
Add_Action (Table.States (11), 74, 177);
Add_Error (Table.States (11));
Table.States (11).Kernel := To_Vector (((332, 36, 4, False), (332, 36, 3, False)));
Table.States (11).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 177)));
Add_Action (Table.States (12), 46, 178);
Add_Error (Table.States (12));
Table.States (12).Kernel := To_Vector ((0 => (246, 40, 1, False)));
Table.States (12).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 46, 178)));
Add_Action (Table.States (13), 96, 179);
Add_Error (Table.States (13));
Table.States (13).Kernel := To_Vector ((0 => (303, 41, 1, False)));
Table.States (13).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 179)));
Add_Action (Table.States (14), (25, 29, 50), (246, 1), 1, overriding_indicator_opt_1'Access, null);
Table.States (14).Kernel := To_Vector ((0 => (246, 46, 0, False)));
Table.States (14).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 246, 1)));
Add_Action (Table.States (15), 14, 180);
Add_Action (Table.States (15), 104, 119);
Add_Action (Table.States (15), 105, 33);
Add_Action (Table.States (15), 106, 34);
Add_Error (Table.States (15));
Add_Goto (Table.States (15), 128, 41);
Add_Goto (Table.States (15), 239, 181);
Add_Goto (Table.States (15), 272, 92);
Add_Goto (Table.States (15), 293, 97);
Table.States (15).Kernel := To_Vector (((213, 47, 5, False), (247, 47, 6, False), (247, 47, 5, False),
(248, 47, 5, False), (250, 47, 4, False), (251, 47, 4, False), (251, 47, 3, False)));
Table.States (15).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (16), 104, 182);
Add_Error (Table.States (16));
Table.States (16).Kernel := To_Vector (((257, 48, 4, False), (257, 48, 6, False), (257, 48, 2, False)));
Table.States (16).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 182)));
Add_Action (Table.States (17), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (17), 28, 183);
Add_Action (Table.States (17), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (17), 30, 8);
Add_Action (Table.States (17), 40, 12);
Add_Action (Table.States (17), 46, 14);
Add_Action (Table.States (17), 47, 15);
Add_Action (Table.States (17), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (17), 51, 19);
Add_Action (Table.States (17), 63, 25);
Add_Action (Table.States (17), 66, 26);
Add_Action (Table.States (17), 69, 27);
Add_Action (Table.States (17), 71, 28);
Add_Action (Table.States (17), 74, 184);
Add_Action (Table.States (17), 104, 185);
Add_Error (Table.States (17));
Add_Goto (Table.States (17), 112, 35);
Add_Goto (Table.States (17), 121, 37);
Add_Goto (Table.States (17), 127, 40);
Add_Goto (Table.States (17), 134, 45);
Add_Goto (Table.States (17), 135, 46);
Add_Goto (Table.States (17), 157, 186);
Add_Goto (Table.States (17), 179, 54);
Add_Goto (Table.States (17), 182, 55);
Add_Goto (Table.States (17), 186, 56);
Add_Goto (Table.States (17), 193, 58);
Add_Goto (Table.States (17), 206, 60);
Add_Goto (Table.States (17), 207, 61);
Add_Goto (Table.States (17), 209, 62);
Add_Goto (Table.States (17), 210, 63);
Add_Goto (Table.States (17), 213, 64);
Add_Goto (Table.States (17), 214, 65);
Add_Goto (Table.States (17), 215, 66);
Add_Goto (Table.States (17), 216, 67);
Add_Goto (Table.States (17), 219, 69);
Add_Goto (Table.States (17), 223, 71);
Add_Goto (Table.States (17), 243, 74);
Add_Goto (Table.States (17), 244, 75);
Add_Goto (Table.States (17), 245, 76);
Add_Goto (Table.States (17), 246, 77);
Add_Goto (Table.States (17), 247, 78);
Add_Goto (Table.States (17), 248, 79);
Add_Goto (Table.States (17), 249, 80);
Add_Goto (Table.States (17), 250, 81);
Add_Goto (Table.States (17), 251, 82);
Add_Goto (Table.States (17), 259, 84);
Add_Goto (Table.States (17), 260, 85);
Add_Goto (Table.States (17), 262, 87);
Add_Goto (Table.States (17), 263, 88);
Add_Goto (Table.States (17), 264, 89);
Add_Goto (Table.States (17), 265, 90);
Add_Goto (Table.States (17), 271, 91);
Add_Goto (Table.States (17), 281, 94);
Add_Goto (Table.States (17), 289, 95);
Add_Goto (Table.States (17), 304, 102);
Add_Goto (Table.States (17), 305, 103);
Add_Goto (Table.States (17), 307, 105);
Add_Goto (Table.States (17), 308, 106);
Add_Goto (Table.States (17), 309, 107);
Add_Goto (Table.States (17), 311, 108);
Add_Goto (Table.States (17), 313, 109);
Add_Goto (Table.States (17), 316, 111);
Add_Goto (Table.States (17), 317, 112);
Add_Goto (Table.States (17), 319, 113);
Add_Goto (Table.States (17), 325, 115);
Add_Goto (Table.States (17), 331, 116);
Table.States (17).Kernel := To_Vector (((142, 49, 3, False), (332, 49, 3, False)));
Table.States (17).Minimal_Complete_Actions := To_Vector (((Reduce, 246, 0), (Shift, 74, 184)));
Add_Action (Table.States (18), 104, 119);
Add_Action (Table.States (18), 105, 33);
Add_Action (Table.States (18), 106, 34);
Add_Error (Table.States (18));
Add_Goto (Table.States (18), 128, 41);
Add_Goto (Table.States (18), 239, 187);
Add_Goto (Table.States (18), 272, 92);
Add_Goto (Table.States (18), 293, 97);
Table.States (18).Kernel := To_Vector ((0 => (262, 50, 1, False)));
Table.States (18).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (19), 14, 188);
Add_Action (Table.States (19), 69, 189);
Add_Action (Table.States (19), 104, 190);
Add_Error (Table.States (19));
Table.States (19).Kernel := To_Vector (((264, 51, 5, False), (265, 51, 5, False), (271, 51, 8, False),
(271, 51, 5, False), (304, 51, 7, False), (304, 51, 4, False)));
Table.States (19).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 190)));
Add_Action (Table.States (20), 96, 191);
Add_Action (Table.States (20), 104, 119);
Add_Action (Table.States (20), 105, 33);
Add_Action (Table.States (20), 106, 34);
Add_Error (Table.States (20));
Add_Goto (Table.States (20), 128, 41);
Add_Goto (Table.States (20), 239, 192);
Add_Goto (Table.States (20), 272, 92);
Add_Goto (Table.States (20), 293, 97);
Table.States (20).Kernel := To_Vector (((276, 52, 3, False), (276, 52, 2, False), (276, 52, 1, False)));
Table.States (20).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 191)));
Add_Action (Table.States (21), 104, 119);
Add_Action (Table.States (21), 105, 33);
Add_Action (Table.States (21), 106, 34);
Add_Error (Table.States (21));
Add_Goto (Table.States (21), 128, 41);
Add_Goto (Table.States (21), 239, 193);
Add_Goto (Table.States (21), 272, 92);
Add_Goto (Table.States (21), 293, 97);
Table.States (21).Kernel := To_Vector (((290, 57, 4, False), (290, 57, 2, False)));
Table.States (21).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (22), 3, 121);
Add_Action (Table.States (22), 21, Reduce, (195, 1), 0, null, null);
Add_Action (Table.States (22), 39, 122);
Add_Action (Table.States (22), 40, 123);
Add_Action (Table.States (22), 41, 124);
Add_Action (Table.States (22), 52, 125);
Add_Action (Table.States (22), 76, 126);
Add_Action (Table.States (22), 94, 127);
Add_Action (Table.States (22), 95, 128);
Add_Action (Table.States (22), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (22), 103, 129);
Add_Action (Table.States (22), 104, 194);
Add_Action (Table.States (22), 105, 33);
Add_Action (Table.States (22), 106, 34);
Add_Error (Table.States (22));
Add_Goto (Table.States (22), 117, 130);
Add_Goto (Table.States (22), 128, 41);
Add_Goto (Table.States (22), 191, 131);
Add_Goto (Table.States (22), 192, 195);
Add_Goto (Table.States (22), 194, 196);
Add_Goto (Table.States (22), 195, 197);
Add_Goto (Table.States (22), 197, 133);
Add_Goto (Table.States (22), 239, 134);
Add_Goto (Table.States (22), 258, 135);
Add_Goto (Table.States (22), 272, 92);
Add_Goto (Table.States (22), 275, 136);
Add_Goto (Table.States (22), 282, 137);
Add_Goto (Table.States (22), 283, 138);
Add_Goto (Table.States (22), 284, 139);
Add_Goto (Table.States (22), 285, 140);
Add_Goto (Table.States (22), 286, 141);
Add_Goto (Table.States (22), 287, 142);
Add_Goto (Table.States (22), 293, 97);
Add_Goto (Table.States (22), 301, 143);
Add_Goto (Table.States (22), 320, 144);
Add_Goto (Table.States (22), 321, 145);
Add_Goto (Table.States (22), 330, 146);
Table.States (22).Kernel := To_Vector (((196, 58, 4, False), (196, 58, 4, False), (302, 58, 1, False)));
Table.States (22).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (23), 76, 198);
Add_Error (Table.States (23));
Table.States (23).Kernel := To_Vector ((0 => (315, 60, 9, False)));
Table.States (23).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 76, 198)));
Add_Action (Table.States (24), 4, 1);
Add_Action (Table.States (24), 18, 4);
Add_Action (Table.States (24), 22, Reduce, (297, 1), 0, null, null);
Add_Action (Table.States (24), 24, Reduce, (297, 1), 0, null, null);
Add_Action (Table.States (24), 67, 199);
Add_Action (Table.States (24), 72, 200);
Add_Action (Table.States (24), 104, 119);
Add_Action (Table.States (24), 105, 33);
Add_Action (Table.States (24), 106, 34);
Add_Error (Table.States (24));
Add_Goto (Table.States (24), 113, 201);
Add_Goto (Table.States (24), 128, 41);
Add_Goto (Table.States (24), 160, 202);
Add_Goto (Table.States (24), 161, 203);
Add_Goto (Table.States (24), 178, 204);
Add_Goto (Table.States (24), 239, 205);
Add_Goto (Table.States (24), 261, 206);
Add_Goto (Table.States (24), 272, 92);
Add_Goto (Table.States (24), 293, 97);
Add_Goto (Table.States (24), 295, 207);
Add_Goto (Table.States (24), 296, 208);
Add_Goto (Table.States (24), 297, 209);
Add_Goto (Table.States (24), 324, 210);
Table.States (24).Kernel := To_Vector (((126, 61, 6, False), (152, 61, 5, False), (294, 61, 4, False),
(294, 61, 3, False), (323, 61, 7, False)));
Table.States (24).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 297, 0)));
Add_Action (Table.States (25), 104, 211);
Add_Error (Table.States (25));
Table.States (25).Kernel := To_Vector ((0 => (313, 63, 4, False)));
Table.States (25).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 211)));
Add_Action (Table.States (26), 14, 212);
Add_Action (Table.States (26), 69, 213);
Add_Action (Table.States (26), 104, 214);
Add_Error (Table.States (26));
Table.States (26).Kernel := To_Vector (((305, 66, 7, False), (305, 66, 4, False), (305, 66, 2, False),
(316, 66, 6, False), (317, 66, 5, False), (319, 66, 8, False), (319, 66, 5, False), (319, 66, 3, False)));
Table.States (26).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 214)));
Add_Action (Table.States (27), 104, 215);
Add_Error (Table.States (27));
Table.States (27).Kernel := To_Vector (((206, 69, 4, False), (223, 69, 4, False), (223, 69, 2, False),
(259, 69, 7, False), (260, 69, 4, False)));
Table.States (27).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 215)));
Add_Action (Table.States (28), 9, 216);
Add_Action (Table.States (28), 69, 217);
Add_Action (Table.States (28), 104, 119);
Add_Action (Table.States (28), 105, 33);
Add_Action (Table.States (28), 106, 34);
Add_Error (Table.States (28));
Add_Goto (Table.States (28), 128, 41);
Add_Goto (Table.States (28), 238, 218);
Add_Goto (Table.States (28), 239, 219);
Add_Goto (Table.States (28), 272, 92);
Add_Goto (Table.States (28), 293, 97);
Table.States (28).Kernel := To_Vector (((331, 71, 4, False), (331, 71, 3, False), (331, 71, 2, False)));
Table.States (28).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (29), 3, 121);
Add_Action (Table.States (29), 37, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (29), 39, 122);
Add_Action (Table.States (29), 40, 123);
Add_Action (Table.States (29), 41, 124);
Add_Action (Table.States (29), 52, 125);
Add_Action (Table.States (29), 76, 126);
Add_Action (Table.States (29), 94, 127);
Add_Action (Table.States (29), 95, 128);
Add_Action (Table.States (29), 103, 129);
Add_Action (Table.States (29), 104, 119);
Add_Action (Table.States (29), 105, 33);
Add_Action (Table.States (29), 106, 34);
Add_Error (Table.States (29));
Add_Goto (Table.States (29), 117, 130);
Add_Goto (Table.States (29), 128, 41);
Add_Goto (Table.States (29), 191, 131);
Add_Goto (Table.States (29), 192, 220);
Add_Goto (Table.States (29), 197, 133);
Add_Goto (Table.States (29), 239, 134);
Add_Goto (Table.States (29), 258, 135);
Add_Goto (Table.States (29), 272, 92);
Add_Goto (Table.States (29), 275, 136);
Add_Goto (Table.States (29), 282, 137);
Add_Goto (Table.States (29), 283, 138);
Add_Goto (Table.States (29), 284, 139);
Add_Goto (Table.States (29), 285, 140);
Add_Goto (Table.States (29), 286, 141);
Add_Goto (Table.States (29), 287, 142);
Add_Goto (Table.States (29), 293, 97);
Add_Goto (Table.States (29), 301, 143);
Add_Goto (Table.States (29), 320, 144);
Add_Goto (Table.States (29), 321, 145);
Add_Goto (Table.States (29), 330, 146);
Table.States (29).Kernel := To_Vector ((0 => (229, 73, 0, False)));
Table.States (29).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (30), 104, 119);
Add_Action (Table.States (30), 105, 33);
Add_Action (Table.States (30), 106, 34);
Add_Error (Table.States (30));
Add_Goto (Table.States (30), 128, 41);
Add_Goto (Table.States (30), 238, 221);
Add_Goto (Table.States (30), 239, 219);
Add_Goto (Table.States (30), 272, 92);
Add_Goto (Table.States (30), 293, 97);
Table.States (30).Kernel := To_Vector ((0 => (332, 74, 2, False)));
Table.States (30).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (31), 104, 222);
Add_Error (Table.States (31));
Table.States (31).Kernel := To_Vector ((0 => (217, 93, 2, False)));
Table.States (31).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 222)));
Add_Action (Table.States (32), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (32), 81, 223);
Add_Conflict (Table.States (32), 81, (219, 1), 1, identifier_list_1'Access, null);
Add_Action (Table.States (32), 82, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (32), 83, Reduce, (219, 1), 1, identifier_list_1'Access, null);
Add_Action (Table.States (32), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (32), 96, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (32), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (32), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (32));
Table.States (32).Kernel := To_Vector (((131, 104, 1, False), (219, 104, 0, False), (239, 104, 0, False),
(245, 104, 5, False), (245, 104, 6, False), (245, 104, 5, False)));
Table.States (32).Minimal_Complete_Actions := To_Vector (((Reduce, 219, 1), (Reduce, 239, 1)));
Add_Action (Table.States (33), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 7), 1, null,
name_7_check'Access);
Table.States (33).Kernel := To_Vector ((0 => (239, 105, 0, False)));
Table.States (33).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Add_Action (Table.States (34), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 6), 1, null, null);
Table.States (34).Kernel := To_Vector ((0 => (239, 106, 0, False)));
Table.States (34).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Add_Action (Table.States (35), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 0), 1, null,
null);
Table.States (35).Kernel := To_Vector ((0 => (157, 112, 0, False)));
Table.States (35).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (36), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (151, 5), 1, null, null);
Table.States (36).Kernel := To_Vector ((0 => (151, 113, 0, False)));
Table.States (36).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 151, 1)));
Add_Action (Table.States (37), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 1), 1, null,
null);
Table.States (37).Kernel := To_Vector ((0 => (157, 121, 0, False)));
Table.States (37).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (38), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 1), 1, null, null);
Table.States (38).Kernel := To_Vector ((0 => (303, 123, 0, False)));
Table.States (38).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (39), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (298, 3), 1, null, null);
Table.States (39).Kernel := To_Vector ((0 => (298, 126, 0, False)));
Table.States (39).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 298, 1)));
Add_Action (Table.States (40), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 74, 93, 104, 105, 106, 107), (121, 3), 1,
null, null);
Table.States (40).Kernel := To_Vector ((0 => (121, 127, 0, False)));
Table.States (40).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 121, 1)));
Add_Action (Table.States (41), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 3), 1, null, null);
Table.States (41).Kernel := To_Vector ((0 => (239, 128, 0, True)));
Table.States (41).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Table.States (41).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (42), (13, 17, 28, 37, 73), (132, 0), 1, null, block_label_opt_0_check'Access);
Table.States (42).Kernel := To_Vector ((0 => (132, 131, 0, False)));
Table.States (42).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 132, 1)));
Add_Action (Table.States (43), 13, 224);
Add_Action (Table.States (43), 17, 225);
Add_Action (Table.States (43), 28, 226);
Add_Action (Table.States (43), 37, 227);
Add_Action (Table.States (43), 73, 29);
Add_Error (Table.States (43));
Add_Goto (Table.States (43), 229, 228);
Table.States (43).Kernel := To_Vector (((133, 132, 4, False), (133, 132, 3, False), (232, 132, 5, False),
(232, 132, 4, False)));
Table.States (43).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 224)));
Add_Action (Table.States (44), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (151, 3), 1, null, null);
Table.States (44).Kernel := To_Vector ((0 => (151, 133, 0, False)));
Table.States (44).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 151, 1)));
Add_Action (Table.States (45), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 2), 1, null,
null);
Table.States (45).Kernel := To_Vector ((0 => (157, 134, 0, False)));
Table.States (45).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (46), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (134, 1), 1, null,
null);
Table.States (46).Kernel := To_Vector ((0 => (134, 135, 0, False)));
Table.States (46).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 134, 1)));
Add_Action (Table.States (47), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (151, 1), 1, null, null);
Table.States (47).Kernel := To_Vector ((0 => (151, 139, 0, False)));
Table.States (47).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 151, 1)));
Add_Action (Table.States (48), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (143, 1), 1,
compilation_unit_list_1'Access, compilation_unit_list_1_check'Access);
Table.States (48).Kernel := To_Vector ((0 => (143, 142, 0, False)));
Table.States (48).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 143, 1)));
Add_Action (Table.States (49), 4, 1);
Add_Action (Table.States (49), 5, 2);
Add_Action (Table.States (49), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (49), 15, 3);
Add_Action (Table.States (49), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (49), 18, 4);
Add_Action (Table.States (49), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (49), 27, 5);
Add_Action (Table.States (49), 28, 6);
Add_Conflict (Table.States (49), 28, (132, 1), 0, null, null);
Add_Action (Table.States (49), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (49), 30, 8);
Add_Action (Table.States (49), 31, 9);
Add_Action (Table.States (49), 32, 10);
Add_Action (Table.States (49), 36, 11);
Add_Action (Table.States (49), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (49), 40, 12);
Add_Action (Table.States (49), 41, 13);
Add_Action (Table.States (49), 46, 14);
Add_Action (Table.States (49), 47, 15);
Add_Action (Table.States (49), 48, 16);
Add_Action (Table.States (49), 49, 17);
Add_Action (Table.States (49), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (49), 51, 19);
Add_Action (Table.States (49), 52, 20);
Add_Action (Table.States (49), 57, 21);
Add_Action (Table.States (49), 58, 22);
Add_Action (Table.States (49), 60, 23);
Add_Action (Table.States (49), 61, 24);
Add_Action (Table.States (49), 63, 25);
Add_Action (Table.States (49), 66, 26);
Add_Action (Table.States (49), 69, 27);
Add_Action (Table.States (49), 71, 28);
Add_Action (Table.States (49), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (49), 74, 30);
Add_Action (Table.States (49), 93, 31);
Add_Action (Table.States (49), 104, 32);
Add_Action (Table.States (49), 105, 33);
Add_Action (Table.States (49), 106, 34);
Add_Action (Table.States (49), 107, Accept_It, (108, 0), 1, null, null);
Add_Error (Table.States (49));
Add_Goto (Table.States (49), 112, 35);
Add_Goto (Table.States (49), 113, 36);
Add_Goto (Table.States (49), 121, 37);
Add_Goto (Table.States (49), 123, 38);
Add_Goto (Table.States (49), 126, 39);
Add_Goto (Table.States (49), 127, 40);
Add_Goto (Table.States (49), 128, 41);
Add_Goto (Table.States (49), 131, 42);
Add_Goto (Table.States (49), 132, 43);
Add_Goto (Table.States (49), 133, 44);
Add_Goto (Table.States (49), 134, 45);
Add_Goto (Table.States (49), 135, 46);
Add_Goto (Table.States (49), 139, 47);
Add_Goto (Table.States (49), 142, 229);
Add_Goto (Table.States (49), 151, 50);
Add_Goto (Table.States (49), 152, 51);
Add_Goto (Table.States (49), 157, 52);
Add_Goto (Table.States (49), 161, 53);
Add_Goto (Table.States (49), 179, 54);
Add_Goto (Table.States (49), 182, 55);
Add_Goto (Table.States (49), 186, 56);
Add_Goto (Table.States (49), 190, 57);
Add_Goto (Table.States (49), 193, 58);
Add_Goto (Table.States (49), 196, 59);
Add_Goto (Table.States (49), 206, 60);
Add_Goto (Table.States (49), 207, 61);
Add_Goto (Table.States (49), 209, 62);
Add_Goto (Table.States (49), 210, 63);
Add_Goto (Table.States (49), 213, 64);
Add_Goto (Table.States (49), 214, 65);
Add_Goto (Table.States (49), 215, 66);
Add_Goto (Table.States (49), 216, 67);
Add_Goto (Table.States (49), 217, 68);
Add_Goto (Table.States (49), 219, 69);
Add_Goto (Table.States (49), 222, 70);
Add_Goto (Table.States (49), 223, 71);
Add_Goto (Table.States (49), 232, 72);
Add_Goto (Table.States (49), 239, 73);
Add_Goto (Table.States (49), 243, 74);
Add_Goto (Table.States (49), 244, 75);
Add_Goto (Table.States (49), 245, 76);
Add_Goto (Table.States (49), 246, 77);
Add_Goto (Table.States (49), 247, 78);
Add_Goto (Table.States (49), 248, 79);
Add_Goto (Table.States (49), 249, 80);
Add_Goto (Table.States (49), 250, 81);
Add_Goto (Table.States (49), 251, 82);
Add_Goto (Table.States (49), 257, 83);
Add_Goto (Table.States (49), 259, 84);
Add_Goto (Table.States (49), 260, 85);
Add_Goto (Table.States (49), 261, 86);
Add_Goto (Table.States (49), 262, 87);
Add_Goto (Table.States (49), 263, 88);
Add_Goto (Table.States (49), 264, 89);
Add_Goto (Table.States (49), 265, 90);
Add_Goto (Table.States (49), 271, 91);
Add_Goto (Table.States (49), 272, 92);
Add_Goto (Table.States (49), 276, 93);
Add_Goto (Table.States (49), 281, 94);
Add_Goto (Table.States (49), 289, 95);
Add_Goto (Table.States (49), 290, 96);
Add_Goto (Table.States (49), 293, 97);
Add_Goto (Table.States (49), 294, 98);
Add_Goto (Table.States (49), 298, 99);
Add_Goto (Table.States (49), 302, 100);
Add_Goto (Table.States (49), 303, 101);
Add_Goto (Table.States (49), 304, 102);
Add_Goto (Table.States (49), 305, 103);
Add_Goto (Table.States (49), 306, 104);
Add_Goto (Table.States (49), 307, 105);
Add_Goto (Table.States (49), 308, 106);
Add_Goto (Table.States (49), 309, 107);
Add_Goto (Table.States (49), 311, 108);
Add_Goto (Table.States (49), 313, 109);
Add_Goto (Table.States (49), 315, 110);
Add_Goto (Table.States (49), 316, 111);
Add_Goto (Table.States (49), 317, 112);
Add_Goto (Table.States (49), 319, 113);
Add_Goto (Table.States (49), 323, 114);
Add_Goto (Table.States (49), 325, 115);
Add_Goto (Table.States (49), 331, 116);
Add_Goto (Table.States (49), 332, 117);
Table.States (49).Kernel := To_Vector (((108, 143, 1, False), (143, 143, 2, True)));
end Subr_1;
procedure Subr_2
is begin
Add_Action (Table.States (50), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (306, 2), 1, null, null);
Table.States (50).Kernel := To_Vector ((0 => (306, 151, 0, False)));
Table.States (50).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 306, 1)));
Add_Action (Table.States (51), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (298, 2), 1, null, null);
Table.States (51).Kernel := To_Vector ((0 => (298, 152, 0, False)));
Table.States (51).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 298, 1)));
Add_Action (Table.States (52), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (142, 3), 1, null,
null);
Table.States (52).Kernel := To_Vector ((0 => (142, 157, 0, False)));
Table.States (52).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 142, 1)));
Add_Action (Table.States (53), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 7), 1, null, null);
Table.States (53).Kernel := To_Vector ((0 => (303, 161, 0, False)));
Table.States (53).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (54), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 3), 1, null,
null);
Table.States (54).Kernel := To_Vector ((0 => (157, 179, 0, False)));
Table.States (54).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (55), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 74, 93, 104, 105, 106, 107), (121, 1), 1,
null, null);
Table.States (55).Kernel := To_Vector ((0 => (121, 182, 0, False)));
Table.States (55).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 121, 1)));
Add_Action (Table.States (56), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 4), 1, null,
null);
Table.States (56).Kernel := To_Vector ((0 => (157, 186, 0, False)));
Table.States (56).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (57), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 2), 1, null, null);
Table.States (57).Kernel := To_Vector ((0 => (303, 190, 0, False)));
Table.States (57).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (58), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 5), 1, null,
null);
Table.States (58).Kernel := To_Vector ((0 => (157, 193, 0, False)));
Table.States (58).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (59), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (151, 4), 1, null, null);
Table.States (59).Kernel := To_Vector ((0 => (151, 196, 0, False)));
Table.States (59).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 151, 1)));
Add_Action (Table.States (60), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (325, 0), 1, null,
null);
Table.States (60).Kernel := To_Vector ((0 => (325, 206, 0, False)));
Table.States (60).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 325, 1)));
Add_Action (Table.States (61), (35, 74, 96), (312, 1), 1, null, subprogram_specification_1_check'Access);
Table.States (61).Kernel := To_Vector ((0 => (312, 207, 0, False)));
Table.States (61).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 312, 1)));
Add_Action (Table.States (62), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 6), 1, null,
null);
Table.States (62).Kernel := To_Vector ((0 => (157, 209, 0, False)));
Table.States (62).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (63), 29, 7);
Add_Action (Table.States (63), 47, 230);
Add_Action (Table.States (63), 50, 18);
Add_Error (Table.States (63));
Add_Goto (Table.States (63), 207, 61);
Add_Goto (Table.States (63), 251, 231);
Add_Goto (Table.States (63), 262, 87);
Add_Goto (Table.States (63), 312, 232);
Table.States (63).Kernel := To_Vector (((214, 210, 5, False), (216, 210, 3, False)));
Table.States (63).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 50, 18)));
Add_Action (Table.States (64), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 7), 1, null,
null);
Table.States (64).Kernel := To_Vector ((0 => (157, 213, 0, False)));
Table.States (64).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (65), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (209, 1), 1, null,
null);
Table.States (65).Kernel := To_Vector ((0 => (209, 214, 0, False)));
Table.States (65).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 209, 1)));
Add_Action (Table.States (66), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (289, 3), 1, null,
null);
Table.States (66).Kernel := To_Vector ((0 => (289, 215, 0, False)));
Table.States (66).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 289, 1)));
Add_Action (Table.States (67), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (209, 0), 1, null,
null);
Table.States (67).Kernel := To_Vector ((0 => (209, 216, 0, False)));
Table.States (67).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 209, 1)));
Add_Action (Table.States (68), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (306, 0), 1, null, null);
Table.States (68).Kernel := To_Vector ((0 => (306, 217, 0, False)));
Table.States (68).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 306, 1)));
Add_Action (Table.States (69), 81, 233);
Add_Action (Table.States (69), 83, 234);
Add_Error (Table.States (69));
Table.States (69).Kernel := To_Vector (((157, 219, 4, False), (186, 219, 3, False), (219, 219, 2, True),
(244, 219, 4, False), (244, 219, 5, False), (244, 219, 11, False), (244, 219, 3, False), (244, 219, 4,
False), (244, 219, 10, False)));
Table.States (69).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 81, 233)));
Add_Action (Table.States (70), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (151, 0), 1, null, null);
Table.States (70).Kernel := To_Vector ((0 => (151, 222, 0, False)));
Table.States (70).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 151, 1)));
Add_Action (Table.States (71), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (325, 1), 1, null,
null);
Table.States (71).Kernel := To_Vector ((0 => (325, 223, 0, False)));
Table.States (71).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 325, 1)));
Add_Action (Table.States (72), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (151, 2), 1, null, null);
Table.States (72).Kernel := To_Vector ((0 => (151, 232, 0, False)));
Table.States (72).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 151, 1)));
Add_Action (Table.States (73), 76, 235);
Add_Action (Table.States (73), 82, 236);
Add_Action (Table.States (73), 84, 237);
Add_Action (Table.States (73), 96, 238);
Add_Action (Table.States (73), 101, 239);
Add_Action (Table.States (73), 102, 240);
Add_Error (Table.States (73));
Add_Goto (Table.States (73), 115, 241);
Add_Goto (Table.States (73), 322, 242);
Table.States (73).Kernel := To_Vector (((123, 239, 2, False), (128, 239, 2, True), (239, 239, 5, True),
(239, 239, 2, True), (261, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (73).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 238)));
Add_Action (Table.States (74), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 8), 1, null,
null);
Table.States (74).Kernel := To_Vector ((0 => (157, 243, 0, False)));
Table.States (74).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (75), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 10), 1,
null, null);
Table.States (75).Kernel := To_Vector ((0 => (157, 244, 0, False)));
Table.States (75).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (76), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (289, 0), 1, null,
null);
Table.States (76).Kernel := To_Vector ((0 => (289, 245, 0, False)));
Table.States (76).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 289, 1)));
Add_Action (Table.States (77), 25, 243);
Add_Action (Table.States (77), 29, 244);
Add_Action (Table.States (77), 50, 245);
Add_Error (Table.States (77));
Add_Goto (Table.States (77), 207, 246);
Add_Goto (Table.States (77), 262, 247);
Add_Goto (Table.States (77), 312, 248);
Table.States (77).Kernel := To_Vector (((112, 246, 5, False), (179, 246, 6, False), (179, 246, 3, False),
(193, 246, 7, False), (213, 246, 6, False), (213, 246, 6, False), (243, 246, 5, False), (307, 246, 6,
False), (308, 246, 5, False), (309, 246, 3, False), (311, 246, 5, False)));
Table.States (77).Minimal_Complete_Actions := To_Vector (((Shift, 25, 243), (Shift, 50, 245)));
Add_Action (Table.States (78), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (263, 1), 1, null,
null);
Table.States (78).Kernel := To_Vector ((0 => (263, 247, 0, False)));
Table.States (78).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 263, 1)));
Add_Action (Table.States (79), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (135, 1), 1, null,
null);
Table.States (79).Kernel := To_Vector ((0 => (135, 248, 0, False)));
Table.States (79).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 135, 1)));
Add_Action (Table.States (80), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 11), 1,
null, null);
Table.States (80).Kernel := To_Vector ((0 => (157, 249, 0, False)));
Table.States (80).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (81), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (289, 1), 1, null,
null);
Table.States (81).Kernel := To_Vector ((0 => (289, 250, 0, False)));
Table.States (81).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 289, 1)));
Add_Action (Table.States (82), 96, 249);
Add_Error (Table.States (82));
Table.States (82).Kernel := To_Vector ((0 => (249, 251, 1, False)));
Table.States (82).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 249)));
Add_Action (Table.States (83), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 10), 1, null, null);
Table.States (83).Kernel := To_Vector ((0 => (303, 257, 0, False)));
Table.States (83).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (84), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (325, 3), 1, null,
null);
Table.States (84).Kernel := To_Vector ((0 => (325, 259, 0, False)));
Table.States (84).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 325, 1)));
Add_Action (Table.States (85), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (325, 2), 1, null,
null);
Table.States (85).Kernel := To_Vector ((0 => (325, 260, 0, False)));
Table.States (85).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 325, 1)));
Add_Action (Table.States (86), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 4), 1, null, null);
Table.States (86).Kernel := To_Vector ((0 => (303, 261, 0, False)));
Table.States (86).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (87), (35, 74, 96), (312, 0), 1, null, subprogram_specification_0_check'Access);
Table.States (87).Kernel := To_Vector ((0 => (312, 262, 0, False)));
Table.States (87).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 312, 1)));
Add_Action (Table.States (88), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (134, 0), 1, null,
null);
Table.States (88).Kernel := To_Vector ((0 => (134, 263, 0, False)));
Table.States (88).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 134, 1)));
Add_Action (Table.States (89), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (263, 3), 1, null,
null);
Table.States (89).Kernel := To_Vector ((0 => (263, 264, 0, False)));
Table.States (89).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 263, 1)));
Add_Action (Table.States (90), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (135, 3), 1, null,
null);
Table.States (90).Kernel := To_Vector ((0 => (135, 265, 0, False)));
Table.States (90).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 135, 1)));
Add_Action (Table.States (91), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (206, 2), 1, null,
null);
Table.States (91).Kernel := To_Vector ((0 => (206, 271, 0, False)));
Table.States (91).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 206, 1)));
Add_Action (Table.States (92), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 4), 1, null, null);
Table.States (92).Kernel := To_Vector ((0 => (239, 272, 0, True)));
Table.States (92).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Table.States (92).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (93), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 9), 1, null, null);
Table.States (93).Kernel := To_Vector ((0 => (303, 276, 0, False)));
Table.States (93).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (94), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 74, 93, 104, 105, 106, 107), (121, 2), 1,
null, null);
Table.States (94).Kernel := To_Vector ((0 => (121, 281, 0, False)));
Table.States (94).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 121, 1)));
Add_Action (Table.States (95), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 12), 1,
null, null);
Table.States (95).Kernel := To_Vector ((0 => (157, 289, 0, False)));
Table.States (95).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (96), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 6), 1, null, null);
Table.States (96).Kernel := To_Vector ((0 => (303, 290, 0, False)));
Table.States (96).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (97), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 2), 1, null,
name_2_check'Access);
Table.States (97).Kernel := To_Vector ((0 => (239, 293, 0, True)));
Table.States (97).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Table.States (97).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (98), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (298, 0), 1, null, null);
Table.States (98).Kernel := To_Vector ((0 => (298, 294, 0, False)));
Table.States (98).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 298, 1)));
Add_Action (Table.States (99), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (151, 6), 1, null, null);
Table.States (99).Kernel := To_Vector ((0 => (151, 298, 0, False)));
Table.States (99).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 151, 1)));
Add_Action (Table.States (100), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 5), 1, null, null);
Table.States (100).Kernel := To_Vector ((0 => (303, 302, 0, False)));
Table.States (100).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 1)));
Add_Action (Table.States (101), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (306, 1), 1, null, null);
Table.States (101).Kernel := To_Vector ((0 => (306, 303, 0, False)));
Table.States (101).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 306, 1)));
Add_Action (Table.States (102), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 7), 1, null,
null);
Table.States (102).Kernel := To_Vector ((0 => (244, 304, 0, False)));
Table.States (102).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 1)));
Add_Action (Table.States (103), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 6), 1, null,
null);
Table.States (103).Kernel := To_Vector ((0 => (244, 305, 0, False)));
Table.States (103).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 1)));
Add_Action (Table.States (104), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (142, 4), 1, null,
null);
Table.States (104).Kernel := To_Vector ((0 => (142, 306, 0, False)));
Table.States (104).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 142, 1)));
Add_Action (Table.States (105), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (263, 0), 1, null,
null);
Table.States (105).Kernel := To_Vector ((0 => (263, 307, 0, False)));
Table.States (105).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 263, 1)));
Add_Action (Table.States (106), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (135, 0), 1, null,
null);
Table.States (106).Kernel := To_Vector ((0 => (135, 308, 0, False)));
Table.States (106).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 135, 1)));
Add_Action (Table.States (107), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 13), 1,
null, null);
Table.States (107).Kernel := To_Vector ((0 => (157, 309, 0, False)));
Table.States (107).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (108), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (289, 2), 1, null,
null);
Table.States (108).Kernel := To_Vector ((0 => (289, 311, 0, False)));
Table.States (108).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 289, 1)));
Add_Action (Table.States (109), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 14), 1,
null, null);
Table.States (109).Kernel := To_Vector ((0 => (157, 313, 0, False)));
Table.States (109).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (110), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (142, 1), 1, null,
null);
Table.States (110).Kernel := To_Vector ((0 => (142, 315, 0, False)));
Table.States (110).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 142, 1)));
Add_Action (Table.States (111), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (263, 2), 1, null,
null);
Table.States (111).Kernel := To_Vector ((0 => (263, 316, 0, False)));
Table.States (111).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 263, 1)));
Add_Action (Table.States (112), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (135, 2), 1, null,
null);
Table.States (112).Kernel := To_Vector ((0 => (135, 317, 0, False)));
Table.States (112).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 135, 1)));
Add_Action (Table.States (113), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (206, 1), 1, null,
null);
Table.States (113).Kernel := To_Vector ((0 => (206, 319, 0, False)));
Table.States (113).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 206, 1)));
Add_Action (Table.States (114), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (298, 1), 1, null, null);
Table.States (114).Kernel := To_Vector ((0 => (298, 323, 0, False)));
Table.States (114).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 298, 1)));
Add_Action (Table.States (115), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 15), 1,
null, null);
Table.States (115).Kernel := To_Vector ((0 => (157, 325, 0, False)));
Table.States (115).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (116), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 16), 1,
null, null);
Table.States (116).Kernel := To_Vector ((0 => (157, 331, 0, False)));
Table.States (116).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 1)));
Add_Action (Table.States (117), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (142, 0), 1, null,
null);
Table.States (117).Kernel := To_Vector ((0 => (142, 332, 0, False)));
Table.States (117).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 142, 1)));
Add_Action (Table.States (118), 21, Reduce, (116, 1), 0, null, null);
Add_Action (Table.States (118), 76, 250);
Add_Conflict (Table.States (118), 76, (116, 1), 0, null, null);
Add_Action (Table.States (118), 96, Reduce, (116, 1), 0, null, null);
Add_Error (Table.States (118));
Add_Goto (Table.States (118), 115, 251);
Add_Goto (Table.States (118), 116, 252);
Table.States (118).Kernel := To_Vector (((113, 104, 3, False), (113, 104, 1, False)));
Table.States (118).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 116, 0)));
Add_Action (Table.States (119), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 5), 1, name_5'Access,
name_5_check'Access);
Table.States (119).Kernel := To_Vector ((0 => (239, 104, 0, False)));
Table.States (119).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Add_Action (Table.States (120), 76, 235);
Add_Action (Table.States (120), 84, 237);
Add_Action (Table.States (120), 96, 253);
Add_Action (Table.States (120), 101, 239);
Add_Action (Table.States (120), 102, 240);
Add_Error (Table.States (120));
Add_Goto (Table.States (120), 115, 241);
Add_Goto (Table.States (120), 322, 242);
Table.States (120).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(303, 239, 1, False)));
Table.States (120).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 253)));
Add_Action (Table.States (121), 39, 122);
Add_Action (Table.States (121), 41, 124);
Add_Action (Table.States (121), 76, 126);
Add_Action (Table.States (121), 103, 129);
Add_Action (Table.States (121), 104, 119);
Add_Action (Table.States (121), 105, 33);
Add_Action (Table.States (121), 106, 34);
Add_Error (Table.States (121));
Add_Goto (Table.States (121), 117, 130);
Add_Goto (Table.States (121), 128, 41);
Add_Goto (Table.States (121), 239, 134);
Add_Goto (Table.States (121), 258, 254);
Add_Goto (Table.States (121), 272, 92);
Add_Goto (Table.States (121), 293, 97);
Table.States (121).Kernel := To_Vector ((0 => (197, 3, 1, False)));
Table.States (121).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (122), 104, 119);
Add_Action (Table.States (122), 105, 33);
Add_Action (Table.States (122), 106, 34);
Add_Error (Table.States (122));
Add_Goto (Table.States (122), 128, 41);
Add_Goto (Table.States (122), 239, 255);
Add_Goto (Table.States (122), 272, 92);
Add_Goto (Table.States (122), 293, 97);
Table.States (122).Kernel := To_Vector ((0 => (258, 39, 1, False)));
Table.States (122).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (123), 39, 122);
Add_Action (Table.States (123), 41, 124);
Add_Action (Table.States (123), 76, 126);
Add_Action (Table.States (123), 103, 129);
Add_Action (Table.States (123), 104, 119);
Add_Action (Table.States (123), 105, 33);
Add_Action (Table.States (123), 106, 34);
Add_Error (Table.States (123));
Add_Goto (Table.States (123), 117, 130);
Add_Goto (Table.States (123), 128, 41);
Add_Goto (Table.States (123), 239, 134);
Add_Goto (Table.States (123), 258, 256);
Add_Goto (Table.States (123), 272, 92);
Add_Goto (Table.States (123), 293, 97);
Table.States (123).Kernel := To_Vector ((0 => (197, 40, 1, False)));
Table.States (123).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (124), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99, 100), (258, 1), 1, null, null);
Table.States (124).Kernel := To_Vector ((0 => (258, 41, 0, False)));
Table.States (124).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (125), 104, 119);
Add_Action (Table.States (125), 105, 33);
Add_Action (Table.States (125), 106, 34);
Add_Error (Table.States (125));
Add_Goto (Table.States (125), 128, 41);
Add_Goto (Table.States (125), 239, 257);
Add_Goto (Table.States (125), 272, 92);
Add_Goto (Table.States (125), 293, 97);
Table.States (125).Kernel := To_Vector (((275, 52, 2, True), (275, 52, 1, False)));
Table.States (125).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (126), 3, 121);
Add_Action (Table.States (126), 15, 258);
Add_Action (Table.States (126), 28, 259);
Add_Action (Table.States (126), 32, 260);
Add_Action (Table.States (126), 39, 122);
Add_Action (Table.States (126), 40, 261);
Add_Action (Table.States (126), 41, 262);
Add_Action (Table.States (126), 44, 263);
Add_Action (Table.States (126), 52, 125);
Add_Action (Table.States (126), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (126), 76, 126);
Add_Action (Table.States (126), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (126), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (126), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (126), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (126), 94, 127);
Add_Action (Table.States (126), 95, 128);
Add_Action (Table.States (126), 103, 129);
Add_Action (Table.States (126), 104, 119);
Add_Action (Table.States (126), 105, 33);
Add_Action (Table.States (126), 106, 264);
Add_Error (Table.States (126));
Add_Goto (Table.States (126), 117, 130);
Add_Goto (Table.States (126), 124, 265);
Add_Goto (Table.States (126), 125, 266);
Add_Goto (Table.States (126), 128, 41);
Add_Goto (Table.States (126), 136, 267);
Add_Goto (Table.States (126), 153, 268);
Add_Goto (Table.States (126), 165, 269);
Add_Goto (Table.States (126), 166, 270);
Add_Goto (Table.States (126), 191, 271);
Add_Goto (Table.States (126), 192, 272);
Add_Goto (Table.States (126), 197, 133);
Add_Goto (Table.States (126), 221, 273);
Add_Goto (Table.States (126), 239, 274);
Add_Goto (Table.States (126), 258, 135);
Add_Goto (Table.States (126), 272, 92);
Add_Goto (Table.States (126), 273, 275);
Add_Goto (Table.States (126), 275, 136);
Add_Goto (Table.States (126), 277, 276);
Add_Goto (Table.States (126), 282, 137);
Add_Goto (Table.States (126), 283, 138);
Add_Goto (Table.States (126), 284, 139);
Add_Goto (Table.States (126), 285, 140);
Add_Goto (Table.States (126), 286, 141);
Add_Goto (Table.States (126), 287, 142);
Add_Goto (Table.States (126), 293, 97);
Add_Goto (Table.States (126), 301, 277);
Add_Goto (Table.States (126), 320, 144);
Add_Goto (Table.States (126), 321, 145);
Add_Goto (Table.States (126), 330, 146);
Table.States (126).Kernel := To_Vector (((117, 76, 4, False), (117, 76, 2, False), (117, 76, 3, False),
(117, 76, 3, False), (117, 76, 1, False)));
Table.States (126).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Add_Action (Table.States (127), (3, 39, 40, 41, 76, 103, 104, 105, 106), (330, 1), 1, null, null);
Table.States (127).Kernel := To_Vector ((0 => (330, 94, 0, False)));
Table.States (127).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 330, 1)));
Add_Action (Table.States (128), (3, 39, 40, 41, 76, 103, 104, 105, 106), (330, 0), 1, null, null);
Table.States (128).Kernel := To_Vector ((0 => (330, 95, 0, False)));
Table.States (128).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 330, 1)));
Add_Action (Table.States (129), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99, 100), (258, 0), 1, primary_0'Access,
null);
Table.States (129).Kernel := To_Vector ((0 => (258, 103, 0, False)));
Table.States (129).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (130), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99, 100), (258, 2), 1, primary_2'Access,
null);
Table.States (130).Kernel := To_Vector ((0 => (258, 117, 0, False)));
Table.States (130).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (131), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (192,
0), 1, null, null);
Table.States (131).Kernel := To_Vector ((0 => (192, 191, 0, True)));
Table.States (131).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 1)));
Table.States (131).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (132), 35, 278);
Add_Error (Table.States (132));
Table.States (132).Kernel := To_Vector ((0 => (139, 192, 6, False)));
Table.States (132).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 278)));
Add_Action (Table.States (133), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99), (320, 1), 1, null, null);
Table.States (133).Kernel := To_Vector ((0 => (320, 197, 0, False)));
Table.States (133).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 320, 1)));
Add_Action (Table.States (134), 10, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 20, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 21, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 22, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 23, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 33, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 35, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 37, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 38, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 40, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 42, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 43, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 53, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 55, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 68, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 74, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 75, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 76, 235);
Add_Action (Table.States (134), 77, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 78, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 79, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 82, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 83, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 84, 237);
Add_Action (Table.States (134), 85, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 86, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 87, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 88, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 89, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 91, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 92, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 94, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 95, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 96, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 97, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 98, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 99, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 100, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (134), 101, 239);
Add_Action (Table.States (134), 102, 240);
Add_Error (Table.States (134));
Add_Goto (Table.States (134), 115, 241);
Add_Goto (Table.States (134), 322, 242);
Table.States (134).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(258, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (134).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (135), 10, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 20, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 21, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 22, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 23, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 33, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 35, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 37, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 38, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 40, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 42, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 43, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 53, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 55, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 68, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 74, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 75, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 77, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 78, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 79, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 82, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 83, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 85, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 86, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 87, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 88, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 89, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 91, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 92, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 94, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 95, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 96, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 97, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 98, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 99, Reduce, (197, 1), 1, null, null);
Add_Action (Table.States (135), 100, 279);
Add_Error (Table.States (135));
Table.States (135).Kernel := To_Vector (((197, 258, 2, False), (197, 258, 0, False)));
Table.States (135).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 197, 1)));
Add_Action (Table.States (136), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (287,
4), 1, null, null);
Table.States (136).Kernel := To_Vector ((0 => (287, 275, 0, True)));
Table.States (136).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 287, 1)));
Table.States (136).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (137), 10, 280);
Add_Conflict (Table.States (137), 10, (191, 1), 1, null, null);
Add_Action (Table.States (137), 20, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 21, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 22, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 23, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 35, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 37, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 43, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 53, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 68, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 74, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 75, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 77, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 79, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 83, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 87, Reduce, (191, 1), 1, null, null);
Add_Action (Table.States (137), 96, Reduce, (191, 1), 1, null, null);
Add_Error (Table.States (137));
Table.States (137).Kernel := To_Vector (((191, 282, 0, True), (282, 282, 2, True)));
Table.States (137).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 191, 1)));
Table.States (137).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (138), 10, 281);
Add_Conflict (Table.States (138), 10, (191, 2), 1, null, null);
Add_Action (Table.States (138), 20, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 21, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 22, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 23, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 35, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 37, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 43, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 53, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 68, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 74, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 75, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 77, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 79, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 83, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 87, Reduce, (191, 2), 1, null, null);
Add_Action (Table.States (138), 96, Reduce, (191, 2), 1, null, null);
Add_Error (Table.States (138));
Table.States (138).Kernel := To_Vector (((191, 283, 0, True), (283, 283, 3, True)));
Table.States (138).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 191, 1)));
Table.States (138).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (139), 10, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 20, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 21, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 22, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 23, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 35, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 37, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 43, 282);
Add_Conflict (Table.States (139), 43, (191, 3), 1, null, null);
Add_Action (Table.States (139), 53, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 68, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 74, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 75, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 77, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 79, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 83, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 87, Reduce, (191, 3), 1, null, null);
Add_Action (Table.States (139), 96, Reduce, (191, 3), 1, null, null);
Add_Error (Table.States (139));
Table.States (139).Kernel := To_Vector (((191, 284, 0, True), (284, 284, 2, True)));
Table.States (139).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 191, 1)));
Table.States (139).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (140), 10, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 20, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 21, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 22, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 23, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 35, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 37, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 43, 283);
Add_Conflict (Table.States (140), 43, (191, 4), 1, null, null);
Add_Action (Table.States (140), 53, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 68, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 74, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 75, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 77, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 79, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 83, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 87, Reduce, (191, 4), 1, null, null);
Add_Action (Table.States (140), 96, Reduce, (191, 4), 1, null, null);
Add_Error (Table.States (140));
Table.States (140).Kernel := To_Vector (((191, 285, 0, True), (285, 285, 3, True)));
Table.States (140).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 191, 1)));
Table.States (140).Minimal_Complete_Actions_Recursive := True;
end Subr_2;
procedure Subr_3
is begin
Add_Action (Table.States (141), 10, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 20, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 21, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 22, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 23, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 35, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 37, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 43, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 53, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 68, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 74, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 75, 284);
Add_Conflict (Table.States (141), 75, (191, 5), 1, null, null);
Add_Action (Table.States (141), 77, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 79, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 83, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 87, Reduce, (191, 5), 1, null, null);
Add_Action (Table.States (141), 96, Reduce, (191, 5), 1, null, null);
Add_Error (Table.States (141));
Table.States (141).Kernel := To_Vector (((191, 286, 0, True), (286, 286, 2, True)));
Table.States (141).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 191, 1)));
Table.States (141).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (142), 10, 285);
Add_Conflict (Table.States (142), 10, (191, 0), 1, null, null);
Add_Action (Table.States (142), 20, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 21, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 22, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 23, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 35, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 37, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 43, 286);
Add_Conflict (Table.States (142), 43, (191, 0), 1, null, null);
Add_Action (Table.States (142), 53, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 68, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 74, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 75, 287);
Add_Conflict (Table.States (142), 75, (191, 0), 1, null, null);
Add_Action (Table.States (142), 77, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 79, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 83, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 87, Reduce, (191, 0), 1, null, null);
Add_Action (Table.States (142), 96, Reduce, (191, 0), 1, null, null);
Add_Error (Table.States (142));
Table.States (142).Kernel := To_Vector (((191, 287, 0, True), (282, 287, 2, True), (283, 287, 3, True),
(284, 287, 2, True), (285, 287, 3, True), (286, 287, 2, True)));
Table.States (142).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 191, 1)));
Table.States (142).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (143), 10, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 20, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 21, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 22, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 23, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 33, 288);
Add_Action (Table.States (143), 35, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 37, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 40, 289);
Add_Action (Table.States (143), 43, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 53, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 68, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 74, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 75, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 77, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 79, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 83, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 86, 290);
Add_Action (Table.States (143), 87, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 88, 291);
Add_Action (Table.States (143), 89, 292);
Add_Action (Table.States (143), 91, 293);
Add_Action (Table.States (143), 92, 294);
Add_Action (Table.States (143), 96, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (143), 98, 295);
Add_Error (Table.States (143));
Add_Goto (Table.States (143), 288, 296);
Table.States (143).Kernel := To_Vector (((287, 301, 3, False), (287, 301, 2, False), (287, 301, 2, False),
(287, 301, 0, False)));
Table.States (143).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 287, 1)));
Add_Action (Table.States (144), 10, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 20, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 21, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 22, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 23, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 33, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 35, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 37, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 38, 297);
Add_Action (Table.States (144), 40, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 42, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 43, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 53, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 55, 298);
Add_Action (Table.States (144), 68, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 74, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 75, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 77, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 78, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 79, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 82, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 83, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 85, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 86, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 87, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 88, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 89, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 91, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 92, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 94, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 95, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 96, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 97, 299);
Add_Action (Table.States (144), 98, Reduce, (321, 1), 1, null, null);
Add_Action (Table.States (144), 99, 300);
Add_Error (Table.States (144));
Add_Goto (Table.States (144), 237, 301);
Table.States (144).Kernel := To_Vector (((320, 320, 2, True), (321, 320, 0, False)));
Table.States (144).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 321, 1)));
Add_Action (Table.States (145), 10, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 20, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 21, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 22, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 23, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 33, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 35, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 37, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 40, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 42, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 43, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 53, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 68, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 74, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 75, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 77, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 78, 302);
Add_Action (Table.States (145), 79, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 82, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 83, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 85, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 86, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 87, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 88, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 89, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 91, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 92, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 94, 303);
Add_Action (Table.States (145), 95, 304);
Add_Action (Table.States (145), 96, Reduce, (301, 1), 1, null, null);
Add_Action (Table.States (145), 98, Reduce, (301, 1), 1, null, null);
Add_Error (Table.States (145));
Add_Goto (Table.States (145), 130, 305);
Table.States (145).Kernel := To_Vector (((301, 321, 0, False), (321, 321, 2, True)));
Table.States (145).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 301, 1)));
Add_Action (Table.States (146), 3, 121);
Add_Action (Table.States (146), 39, 122);
Add_Action (Table.States (146), 40, 123);
Add_Action (Table.States (146), 41, 124);
Add_Action (Table.States (146), 76, 126);
Add_Action (Table.States (146), 103, 129);
Add_Action (Table.States (146), 104, 119);
Add_Action (Table.States (146), 105, 33);
Add_Action (Table.States (146), 106, 34);
Add_Error (Table.States (146));
Add_Goto (Table.States (146), 117, 130);
Add_Goto (Table.States (146), 128, 41);
Add_Goto (Table.States (146), 197, 133);
Add_Goto (Table.States (146), 239, 134);
Add_Goto (Table.States (146), 258, 135);
Add_Goto (Table.States (146), 272, 92);
Add_Goto (Table.States (146), 293, 97);
Add_Goto (Table.States (146), 320, 144);
Add_Goto (Table.States (146), 321, 306);
Table.States (146).Kernel := To_Vector ((0 => (301, 330, 1, False)));
Table.States (146).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (147), 3, 121);
Add_Action (Table.States (147), 39, 122);
Add_Action (Table.States (147), 40, 123);
Add_Action (Table.States (147), 41, 124);
Add_Action (Table.States (147), 52, 125);
Add_Action (Table.States (147), 76, 126);
Add_Action (Table.States (147), 94, 127);
Add_Action (Table.States (147), 95, 128);
Add_Action (Table.States (147), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (147), 103, 129);
Add_Action (Table.States (147), 104, 119);
Add_Action (Table.States (147), 105, 33);
Add_Action (Table.States (147), 106, 34);
Add_Error (Table.States (147));
Add_Goto (Table.States (147), 117, 130);
Add_Goto (Table.States (147), 128, 41);
Add_Goto (Table.States (147), 191, 131);
Add_Goto (Table.States (147), 192, 307);
Add_Goto (Table.States (147), 197, 133);
Add_Goto (Table.States (147), 239, 134);
Add_Goto (Table.States (147), 258, 135);
Add_Goto (Table.States (147), 272, 92);
Add_Goto (Table.States (147), 275, 136);
Add_Goto (Table.States (147), 282, 137);
Add_Goto (Table.States (147), 283, 138);
Add_Goto (Table.States (147), 284, 139);
Add_Goto (Table.States (147), 285, 140);
Add_Goto (Table.States (147), 286, 141);
Add_Goto (Table.States (147), 287, 142);
Add_Goto (Table.States (147), 293, 97);
Add_Goto (Table.States (147), 301, 143);
Add_Goto (Table.States (147), 320, 144);
Add_Goto (Table.States (147), 321, 145);
Add_Goto (Table.States (147), 330, 146);
Table.States (147).Kernel := To_Vector ((0 => (161, 70, 1, False)));
Table.States (147).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (148), 96, 308);
Add_Error (Table.States (148));
Table.States (148).Kernel := To_Vector ((0 => (161, 192, 1, False)));
Table.States (148).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 308)));
Add_Action (Table.States (149), (72, 96), (220, 0), 1, null, identifier_opt_0_check'Access);
Table.States (149).Kernel := To_Vector ((0 => (220, 104, 0, False)));
Table.States (149).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 1)));
Add_Action (Table.States (150), 72, 309);
Add_Action (Table.States (150), 96, 310);
Add_Error (Table.States (150));
Table.States (150).Kernel := To_Vector (((190, 220, 2, False), (190, 220, 1, False)));
Table.States (150).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 310)));
Add_Action (Table.States (151), 33, 311);
Add_Action (Table.States (151), 42, 312);
Add_Action (Table.States (151), 71, Reduce, (163, 0), 1, null, null);
Add_Conflict (Table.States (151), 71, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (151), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (151), 81, 313);
Add_Action (Table.States (151), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (151), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (151), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (151));
Table.States (151).Kernel := To_Vector (((163, 104, 0, False), (230, 104, 5, False), (230, 104, 4, False),
(230, 104, 3, False), (230, 104, 3, False), (230, 104, 2, False), (230, 104, 2, False), (239, 104, 0,
False)));
Table.States (151).Minimal_Complete_Actions := To_Vector (((Reduce, 163, 1), (Reduce, 239, 1)));
Add_Action (Table.States (152), 71, Reduce, (163, 1), 1, null, null);
Add_Conflict (Table.States (152), 71, (239, 7), 1, null, name_7_check'Access);
Add_Action (Table.States (152), 76, Reduce, (239, 7), 1, null, name_7_check'Access);
Add_Action (Table.States (152), 84, Reduce, (239, 7), 1, null, name_7_check'Access);
Add_Action (Table.States (152), 101, Reduce, (239, 7), 1, null, name_7_check'Access);
Add_Action (Table.States (152), 102, Reduce, (239, 7), 1, null, name_7_check'Access);
Add_Error (Table.States (152));
Table.States (152).Kernel := To_Vector (((163, 105, 0, False), (239, 105, 0, False)));
Table.States (152).Minimal_Complete_Actions := To_Vector (((Reduce, 163, 1), (Reduce, 239, 1)));
Add_Action (Table.States (153), 71, 314);
Add_Conflict (Table.States (153), 71, (239, 3), 1, null, null);
Add_Action (Table.States (153), 76, Reduce, (239, 3), 1, null, null);
Add_Action (Table.States (153), 84, Reduce, (239, 3), 1, null, null);
Add_Action (Table.States (153), 101, Reduce, (239, 3), 1, null, null);
Add_Action (Table.States (153), 102, Reduce, (239, 3), 1, null, null);
Add_Error (Table.States (153));
Table.States (153).Kernel := To_Vector (((121, 128, 2, False), (239, 128, 0, True)));
Table.States (153).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Table.States (153).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (154), 71, 315);
Add_Error (Table.States (154));
Table.States (154).Kernel := To_Vector ((0 => (127, 163, 3, False)));
Table.States (154).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 71, 315)));
Add_Action (Table.States (155), (1 => 37), (231, 0), 1, null, null);
Table.States (155).Kernel := To_Vector ((0 => (231, 230, 0, False)));
Table.States (155).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 231, 1)));
Add_Action (Table.States (156), (1 => 37), (229, 1), 2, iteration_scheme_1'Access, null);
Table.States (156).Kernel := To_Vector ((0 => (229, 231, 0, False)));
Table.States (156).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 229, 2)));
Add_Action (Table.States (157), 71, 316);
Add_Action (Table.States (157), 76, 235);
Add_Action (Table.States (157), 84, 237);
Add_Action (Table.States (157), 101, 239);
Add_Action (Table.States (157), 102, 240);
Add_Error (Table.States (157));
Add_Goto (Table.States (157), 115, 241);
Add_Goto (Table.States (157), 322, 242);
Table.States (157).Kernel := To_Vector (((128, 239, 2, True), (182, 239, 4, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (281, 239, 13, False), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (157).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 71, 316)));
Add_Action (Table.States (158), 58, 317);
Add_Action (Table.States (158), 76, 318);
Add_Action (Table.States (158), 84, 237);
Add_Action (Table.States (158), 101, 239);
Add_Action (Table.States (158), 102, 240);
Add_Error (Table.States (158));
Add_Goto (Table.States (158), 115, 241);
Add_Goto (Table.States (158), 199, 319);
Add_Goto (Table.States (158), 252, 320);
Add_Goto (Table.States (158), 291, 321);
Add_Goto (Table.States (158), 322, 242);
Table.States (158).Kernel := To_Vector (((128, 239, 2, True), (207, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (158).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 58, 317)));
Add_Action (Table.States (159), 104, 119);
Add_Action (Table.States (159), 105, 33);
Add_Action (Table.States (159), 106, 34);
Add_Error (Table.States (159));
Add_Goto (Table.States (159), 128, 41);
Add_Goto (Table.States (159), 239, 322);
Add_Goto (Table.States (159), 272, 92);
Add_Goto (Table.States (159), 293, 97);
Table.States (159).Kernel := To_Vector ((0 => (215, 29, 4, False)));
Table.States (159).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (160), 104, 119);
Add_Action (Table.States (160), 105, 33);
Add_Action (Table.States (160), 106, 34);
Add_Error (Table.States (160));
Add_Goto (Table.States (160), 128, 41);
Add_Goto (Table.States (160), 239, 323);
Add_Goto (Table.States (160), 272, 92);
Add_Goto (Table.States (160), 293, 97);
Table.States (160).Kernel := To_Vector ((0 => (215, 47, 4, False)));
Table.States (160).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (161), 104, 119);
Add_Action (Table.States (161), 105, 33);
Add_Action (Table.States (161), 106, 34);
Add_Error (Table.States (161));
Add_Goto (Table.States (161), 128, 41);
Add_Goto (Table.States (161), 239, 324);
Add_Goto (Table.States (161), 272, 92);
Add_Goto (Table.States (161), 293, 97);
Table.States (161).Kernel := To_Vector ((0 => (215, 50, 4, False)));
Table.States (161).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (162), 104, 325);
Add_Error (Table.States (162));
Table.States (162).Kernel := To_Vector (((201, 69, 4, False), (201, 69, 4, False), (201, 69, 2, False)));
Table.States (162).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 325)));
Add_Action (Table.States (163), 29, 7);
Add_Action (Table.States (163), 47, 326);
Add_Action (Table.States (163), 50, 18);
Add_Error (Table.States (163));
Add_Goto (Table.States (163), 207, 61);
Add_Goto (Table.States (163), 262, 87);
Add_Goto (Table.States (163), 312, 327);
Table.States (163).Kernel := To_Vector (((200, 74, 6, False), (200, 74, 5, False), (200, 74, 5, False),
(200, 74, 3, False), (204, 74, 6, False)));
Table.States (163).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 50, 18)));
Add_Action (Table.States (164), (81, 83), (219, 1), 1, identifier_list_1'Access, null);
Table.States (164).Kernel := To_Vector ((0 => (219, 104, 0, False)));
Table.States (164).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 219, 1)));
Add_Action (Table.States (165), (29, 47, 48, 50, 69, 71, 74, 104), (212, 0), 1, null, null);
Table.States (165).Kernel := To_Vector ((0 => (212, 198, 0, False)));
Table.States (165).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 212, 1)));
Add_Action (Table.States (166), (29, 47, 48, 50, 69, 71, 74, 104), (212, 2), 1, null, null);
Table.States (166).Kernel := To_Vector ((0 => (212, 200, 0, False)));
Table.States (166).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 212, 1)));
Add_Action (Table.States (167), (29, 47, 48, 50, 69, 71, 74, 104), (212, 1), 1, null, null);
Table.States (167).Kernel := To_Vector ((0 => (212, 201, 0, False)));
Table.States (167).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 212, 1)));
Add_Action (Table.States (168), (29, 47, 48, 50, 69, 71, 74, 104), (212, 3), 1, null, null);
Table.States (168).Kernel := To_Vector ((0 => (212, 204, 0, False)));
Table.States (168).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 212, 1)));
Add_Action (Table.States (169), 29, Reduce, (210, 0), 2, generic_formal_part_0'Access, null);
Add_Action (Table.States (169), 47, Reduce, (210, 0), 2, generic_formal_part_0'Access, null);
Add_Action (Table.States (169), 48, 16);
Add_Action (Table.States (169), 50, Reduce, (210, 0), 2, generic_formal_part_0'Access, null);
Add_Action (Table.States (169), 69, 162);
Add_Action (Table.States (169), 71, 28);
Add_Action (Table.States (169), 74, 163);
Add_Action (Table.States (169), 104, 164);
Add_Error (Table.States (169));
Add_Goto (Table.States (169), 198, 165);
Add_Goto (Table.States (169), 200, 166);
Add_Goto (Table.States (169), 201, 167);
Add_Goto (Table.States (169), 204, 168);
Add_Goto (Table.States (169), 212, 328);
Add_Goto (Table.States (169), 219, 171);
Add_Goto (Table.States (169), 257, 172);
Add_Goto (Table.States (169), 331, 173);
Table.States (169).Kernel := To_Vector (((210, 211, 0, False), (211, 211, 3, True)));
Table.States (169).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 210, 2)));
Add_Action (Table.States (170), (29, 47, 48, 50, 69, 71, 74, 104), (211, 1), 1, null, null);
Table.States (170).Kernel := To_Vector ((0 => (211, 212, 0, False)));
Table.States (170).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 211, 1)));
Add_Action (Table.States (171), 81, 329);
Add_Action (Table.States (171), 83, 234);
Add_Error (Table.States (171));
Table.States (171).Kernel := To_Vector (((198, 219, 4, False), (198, 219, 5, False), (198, 219, 3, False),
(198, 219, 4, False), (219, 219, 2, True)));
Table.States (171).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 81, 329)));
Add_Action (Table.States (172), (29, 47, 48, 50, 69, 71, 74, 104), (212, 4), 1, null, null);
Table.States (172).Kernel := To_Vector ((0 => (212, 257, 0, False)));
Table.States (172).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 212, 1)));
Add_Action (Table.States (173), (29, 47, 48, 50, 69, 71, 74, 104), (212, 5), 1, null, null);
Table.States (173).Kernel := To_Vector ((0 => (212, 331, 0, False)));
Table.States (173).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 212, 1)));
Add_Action (Table.States (174), 96, 330);
Add_Error (Table.States (174));
Table.States (174).Kernel := To_Vector ((0 => (303, 104, 1, False)));
Table.States (174).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 330)));
Add_Action (Table.States (175), 68, 331);
Add_Error (Table.States (175));
Table.States (175).Kernel := To_Vector (((222, 192, 7, False), (222, 192, 5, False), (222, 192, 6, False),
(222, 192, 4, False)));
Table.States (175).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 68, 331)));
Add_Action (Table.States (176), 74, 332);
Add_Error (Table.States (176));
Table.States (176).Kernel := To_Vector ((0 => (332, 49, 3, False)));
Table.States (176).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 332)));
Add_Action (Table.States (177), 104, 119);
Add_Action (Table.States (177), 105, 33);
Add_Action (Table.States (177), 106, 34);
Add_Error (Table.States (177));
Add_Goto (Table.States (177), 128, 41);
Add_Goto (Table.States (177), 238, 333);
Add_Goto (Table.States (177), 239, 219);
Add_Goto (Table.States (177), 272, 92);
Add_Goto (Table.States (177), 293, 97);
Table.States (177).Kernel := To_Vector ((0 => (332, 74, 2, False)));
Table.States (177).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (178), (25, 29, 50), (246, 0), 2, overriding_indicator_opt_0'Access, null);
Table.States (178).Kernel := To_Vector ((0 => (246, 46, 0, False)));
Table.States (178).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 246, 2)));
Add_Action (Table.States (179), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 0), 2, simple_statement_0'Access, null);
Table.States (179).Kernel := To_Vector ((0 => (303, 96, 0, False)));
Table.States (179).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 2)));
Add_Action (Table.States (180), 104, 119);
Add_Action (Table.States (180), 105, 33);
Add_Action (Table.States (180), 106, 34);
Add_Error (Table.States (180));
Add_Goto (Table.States (180), 128, 41);
Add_Goto (Table.States (180), 239, 334);
Add_Goto (Table.States (180), 272, 92);
Add_Goto (Table.States (180), 293, 97);
Table.States (180).Kernel := To_Vector (((247, 14, 5, False), (247, 14, 4, False), (248, 14, 4, False)));
Table.States (180).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (181), 35, 335);
Add_Conflict (Table.States (181), 35, (122, 1), 0, null, null);
Add_Action (Table.States (181), 56, 336);
Add_Action (Table.States (181), 74, 337);
Add_Action (Table.States (181), 76, 235);
Add_Action (Table.States (181), 84, 237);
Add_Action (Table.States (181), 101, 239);
Add_Action (Table.States (181), 102, 240);
Add_Error (Table.States (181));
Add_Goto (Table.States (181), 115, 241);
Add_Goto (Table.States (181), 122, 338);
Add_Goto (Table.States (181), 322, 242);
Table.States (181).Kernel := To_Vector (((128, 239, 2, True), (213, 239, 4, False), (239, 239, 5, True),
(239, 239, 2, True), (250, 239, 3, False), (251, 239, 3, False), (251, 239, 2, False), (272, 239, 3, True),
(293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True)));
Table.States (181).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (182), 76, 339);
Add_Action (Table.States (182), 96, 340);
Add_Error (Table.States (182));
Table.States (182).Kernel := To_Vector (((257, 104, 3, False), (257, 104, 5, False), (257, 104, 1,
False)));
Table.States (182).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 340)));
Add_Action (Table.States (183), 104, 341);
Add_Action (Table.States (183), 105, 152);
Add_Action (Table.States (183), 106, 34);
Add_Error (Table.States (183));
Add_Goto (Table.States (183), 128, 153);
Add_Goto (Table.States (183), 163, 154);
Add_Goto (Table.States (183), 239, 157);
Add_Goto (Table.States (183), 272, 92);
Add_Goto (Table.States (183), 293, 97);
Table.States (183).Kernel := To_Vector (((121, 28, 5, False), (127, 28, 4, False), (182, 28, 5, False),
(281, 28, 14, False)));
Table.States (183).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 341)));
Add_Action (Table.States (184), 104, 119);
Add_Action (Table.States (184), 105, 33);
Add_Action (Table.States (184), 106, 34);
Add_Error (Table.States (184));
Add_Goto (Table.States (184), 128, 41);
Add_Goto (Table.States (184), 238, 342);
Add_Goto (Table.States (184), 239, 219);
Add_Goto (Table.States (184), 272, 92);
Add_Goto (Table.States (184), 293, 97);
Table.States (184).Kernel := To_Vector ((0 => (332, 74, 2, False)));
Table.States (184).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (185), 81, 343);
Add_Conflict (Table.States (185), 81, (219, 1), 1, identifier_list_1'Access, null);
Add_Action (Table.States (185), 83, Reduce, (219, 1), 1, identifier_list_1'Access, null);
Add_Error (Table.States (185));
Table.States (185).Kernel := To_Vector (((219, 104, 0, False), (245, 104, 5, False), (245, 104, 6, False),
(245, 104, 5, False)));
Table.States (185).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 219, 1)));
Add_Action (Table.States (186), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (142, 2), 2,
compilation_unit_2'Access, null);
Table.States (186).Kernel := To_Vector ((0 => (142, 157, 0, False)));
Table.States (186).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 142, 2)));
Add_Action (Table.States (187), 35, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (187), 74, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (187), 76, 318);
Add_Action (Table.States (187), 84, 237);
Add_Action (Table.States (187), 96, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (187), 101, 239);
Add_Action (Table.States (187), 102, 240);
Add_Error (Table.States (187));
Add_Goto (Table.States (187), 115, 241);
Add_Goto (Table.States (187), 199, 344);
Add_Goto (Table.States (187), 253, 345);
Add_Goto (Table.States (187), 322, 242);
Table.States (187).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(262, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (187).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 0)));
Add_Action (Table.States (188), 104, 346);
Add_Error (Table.States (188));
Table.States (188).Kernel := To_Vector (((264, 14, 4, False), (265, 14, 4, False)));
Table.States (188).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 346)));
Add_Action (Table.States (189), 104, 347);
Add_Error (Table.States (189));
Table.States (189).Kernel := To_Vector (((271, 69, 7, False), (271, 69, 4, False)));
Table.States (189).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 347)));
Add_Action (Table.States (190), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (190), 74, 337);
Add_Error (Table.States (190));
Add_Goto (Table.States (190), 122, 348);
Table.States (190).Kernel := To_Vector (((304, 104, 6, False), (304, 104, 3, False)));
Table.States (190).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (191), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (276, 2), 2, raise_statement_2'Access, null);
Table.States (191).Kernel := To_Vector ((0 => (276, 96, 0, False)));
Table.States (191).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 276, 2)));
Add_Action (Table.States (192), 74, 349);
Add_Action (Table.States (192), 76, 235);
Add_Action (Table.States (192), 84, 237);
Add_Action (Table.States (192), 96, 350);
Add_Action (Table.States (192), 101, 239);
Add_Action (Table.States (192), 102, 240);
Add_Error (Table.States (192));
Add_Goto (Table.States (192), 115, 241);
Add_Goto (Table.States (192), 322, 242);
Table.States (192).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (276, 239, 2, False), (276, 239, 1, False), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (192).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 350)));
Add_Action (Table.States (193), 74, 351);
Add_Action (Table.States (193), 76, 235);
Add_Action (Table.States (193), 84, 237);
Add_Action (Table.States (193), 96, 352);
Add_Action (Table.States (193), 101, 239);
Add_Action (Table.States (193), 102, 240);
Add_Error (Table.States (193));
Add_Goto (Table.States (193), 115, 241);
Add_Goto (Table.States (193), 322, 242);
Table.States (193).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (290, 239, 3, False), (290, 239, 1, False), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (193).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 352)));
Add_Action (Table.States (194), 10, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 33, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 38, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 40, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 43, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 55, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 75, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 78, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 81, 353);
Add_Action (Table.States (194), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 86, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 88, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 89, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 91, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 92, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 94, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 95, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 96, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 97, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 98, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 99, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 100, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (194), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (194));
Table.States (194).Kernel := To_Vector (((194, 104, 3, False), (194, 104, 2, False), (239, 104, 0,
False)));
Table.States (194).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Add_Action (Table.States (195), 96, 354);
Add_Error (Table.States (195));
Table.States (195).Kernel := To_Vector ((0 => (302, 192, 1, False)));
Table.States (195).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 354)));
Add_Action (Table.States (196), 21, Reduce, (195, 0), 1, null, null);
Add_Action (Table.States (196), 96, 355);
Add_Error (Table.States (196));
Table.States (196).Kernel := To_Vector (((195, 194, 0, False), (196, 194, 1, False)));
Table.States (196).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 195, 1)));
Add_Action (Table.States (197), 21, 356);
Add_Error (Table.States (197));
Table.States (197).Kernel := To_Vector ((0 => (196, 195, 4, False)));
Table.States (197).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 356)));
Add_Action (Table.States (198), 104, 119);
Add_Action (Table.States (198), 105, 33);
Add_Action (Table.States (198), 106, 34);
Add_Error (Table.States (198));
Add_Goto (Table.States (198), 128, 41);
Add_Goto (Table.States (198), 239, 357);
Add_Goto (Table.States (198), 272, 92);
Add_Goto (Table.States (198), 293, 97);
Table.States (198).Kernel := To_Vector ((0 => (315, 76, 8, False)));
Table.States (198).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (199), 96, 358);
Add_Error (Table.States (199));
Table.States (199).Kernel := To_Vector ((0 => (295, 67, 1, False)));
Table.States (199).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 358)));
Add_Action (Table.States (200), 3, 121);
Add_Action (Table.States (200), 39, 122);
Add_Action (Table.States (200), 40, 123);
Add_Action (Table.States (200), 41, 124);
Add_Action (Table.States (200), 52, 125);
Add_Action (Table.States (200), 76, 126);
Add_Action (Table.States (200), 87, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (200), 94, 127);
Add_Action (Table.States (200), 95, 128);
Add_Action (Table.States (200), 103, 129);
Add_Action (Table.States (200), 104, 119);
Add_Action (Table.States (200), 105, 33);
Add_Action (Table.States (200), 106, 34);
Add_Error (Table.States (200));
Add_Goto (Table.States (200), 117, 130);
Add_Goto (Table.States (200), 128, 41);
Add_Goto (Table.States (200), 191, 131);
Add_Goto (Table.States (200), 192, 359);
Add_Goto (Table.States (200), 197, 133);
Add_Goto (Table.States (200), 239, 134);
Add_Goto (Table.States (200), 258, 135);
Add_Goto (Table.States (200), 272, 92);
Add_Goto (Table.States (200), 275, 136);
Add_Goto (Table.States (200), 282, 137);
Add_Goto (Table.States (200), 283, 138);
Add_Goto (Table.States (200), 284, 139);
Add_Goto (Table.States (200), 285, 140);
Add_Goto (Table.States (200), 286, 141);
Add_Goto (Table.States (200), 287, 142);
Add_Goto (Table.States (200), 293, 97);
Add_Goto (Table.States (200), 301, 143);
Add_Goto (Table.States (200), 320, 144);
Add_Goto (Table.States (200), 321, 145);
Add_Goto (Table.States (200), 330, 146);
Table.States (200).Kernel := To_Vector (((295, 72, 4, False), (295, 72, 3, False), (295, 72, 3, False)));
Table.States (200).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
end Subr_3;
procedure Subr_4
is begin
Add_Action (Table.States (201), 4, 1);
Add_Action (Table.States (201), 5, 2);
Add_Action (Table.States (201), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (201), 15, 3);
Add_Action (Table.States (201), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (201), 18, 4);
Add_Action (Table.States (201), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (201), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (201), 27, 5);
Add_Action (Table.States (201), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (201), 31, 9);
Add_Action (Table.States (201), 32, 10);
Add_Action (Table.States (201), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (201), 41, 13);
Add_Action (Table.States (201), 43, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (201), 48, 16);
Add_Action (Table.States (201), 52, 20);
Add_Action (Table.States (201), 57, 21);
Add_Action (Table.States (201), 58, 22);
Add_Action (Table.States (201), 61, 24);
Add_Action (Table.States (201), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (201), 93, 31);
Add_Action (Table.States (201), 104, 360);
Add_Action (Table.States (201), 105, 33);
Add_Action (Table.States (201), 106, 34);
Add_Error (Table.States (201));
Add_Goto (Table.States (201), 113, 36);
Add_Goto (Table.States (201), 123, 38);
Add_Goto (Table.States (201), 126, 39);
Add_Goto (Table.States (201), 128, 41);
Add_Goto (Table.States (201), 131, 42);
Add_Goto (Table.States (201), 132, 43);
Add_Goto (Table.States (201), 133, 44);
Add_Goto (Table.States (201), 139, 47);
Add_Goto (Table.States (201), 151, 50);
Add_Goto (Table.States (201), 152, 51);
Add_Goto (Table.States (201), 161, 53);
Add_Goto (Table.States (201), 190, 57);
Add_Goto (Table.States (201), 196, 59);
Add_Goto (Table.States (201), 217, 68);
Add_Goto (Table.States (201), 222, 70);
Add_Goto (Table.States (201), 232, 72);
Add_Goto (Table.States (201), 239, 73);
Add_Goto (Table.States (201), 257, 83);
Add_Goto (Table.States (201), 261, 86);
Add_Goto (Table.States (201), 272, 92);
Add_Goto (Table.States (201), 276, 93);
Add_Goto (Table.States (201), 290, 96);
Add_Goto (Table.States (201), 293, 97);
Add_Goto (Table.States (201), 294, 98);
Add_Goto (Table.States (201), 298, 99);
Add_Goto (Table.States (201), 299, 361);
Add_Goto (Table.States (201), 300, 362);
Add_Goto (Table.States (201), 302, 100);
Add_Goto (Table.States (201), 303, 101);
Add_Goto (Table.States (201), 306, 363);
Add_Goto (Table.States (201), 323, 114);
Table.States (201).Kernel := To_Vector ((0 => (295, 113, 0, False)));
Table.States (201).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (202), (22, 24, 43), (295, 5), 1, null, null);
Table.States (202).Kernel := To_Vector ((0 => (295, 160, 0, False)));
Table.States (202).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 295, 1)));
Add_Action (Table.States (203), 4, 1);
Add_Action (Table.States (203), 5, 2);
Add_Action (Table.States (203), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (203), 15, 3);
Add_Action (Table.States (203), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (203), 18, 4);
Add_Action (Table.States (203), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (203), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (203), 27, 5);
Add_Action (Table.States (203), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (203), 31, 9);
Add_Action (Table.States (203), 32, 10);
Add_Action (Table.States (203), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (203), 41, 13);
Add_Action (Table.States (203), 43, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (203), 48, 16);
Add_Action (Table.States (203), 52, 20);
Add_Action (Table.States (203), 57, 21);
Add_Action (Table.States (203), 58, 22);
Add_Action (Table.States (203), 61, 24);
Add_Action (Table.States (203), 68, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (203), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (203), 93, 31);
Add_Action (Table.States (203), 104, 360);
Add_Action (Table.States (203), 105, 33);
Add_Action (Table.States (203), 106, 34);
Add_Error (Table.States (203));
Add_Goto (Table.States (203), 113, 36);
Add_Goto (Table.States (203), 123, 38);
Add_Goto (Table.States (203), 126, 39);
Add_Goto (Table.States (203), 128, 41);
Add_Goto (Table.States (203), 131, 42);
Add_Goto (Table.States (203), 132, 43);
Add_Goto (Table.States (203), 133, 44);
Add_Goto (Table.States (203), 139, 47);
Add_Goto (Table.States (203), 151, 50);
Add_Goto (Table.States (203), 152, 51);
Add_Goto (Table.States (203), 161, 53);
Add_Goto (Table.States (203), 190, 57);
Add_Goto (Table.States (203), 196, 59);
Add_Goto (Table.States (203), 217, 68);
Add_Goto (Table.States (203), 222, 70);
Add_Goto (Table.States (203), 232, 72);
Add_Goto (Table.States (203), 239, 73);
Add_Goto (Table.States (203), 257, 83);
Add_Goto (Table.States (203), 261, 86);
Add_Goto (Table.States (203), 272, 92);
Add_Goto (Table.States (203), 276, 93);
Add_Goto (Table.States (203), 290, 96);
Add_Goto (Table.States (203), 293, 97);
Add_Goto (Table.States (203), 294, 98);
Add_Goto (Table.States (203), 298, 99);
Add_Goto (Table.States (203), 299, 361);
Add_Goto (Table.States (203), 300, 364);
Add_Goto (Table.States (203), 302, 100);
Add_Goto (Table.States (203), 303, 101);
Add_Goto (Table.States (203), 306, 363);
Add_Goto (Table.States (203), 323, 114);
Table.States (203).Kernel := To_Vector (((160, 161, 0, False), (324, 161, 0, False)));
Table.States (203).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (204), 22, 365);
Add_Action (Table.States (204), 43, 366);
Add_Error (Table.States (204));
Table.States (204).Kernel := To_Vector (((152, 178, 4, False), (323, 178, 6, False)));
Table.States (204).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 22, 365)));
Add_Action (Table.States (205), 4, 1);
Add_Action (Table.States (205), 5, 2);
Add_Action (Table.States (205), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (205), 15, 3);
Add_Action (Table.States (205), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (205), 18, 4);
Add_Action (Table.States (205), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (205), 27, 5);
Add_Action (Table.States (205), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (205), 31, 9);
Add_Action (Table.States (205), 32, 10);
Add_Action (Table.States (205), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (205), 41, 13);
Add_Action (Table.States (205), 43, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (205), 48, 16);
Add_Action (Table.States (205), 52, 20);
Add_Action (Table.States (205), 57, 21);
Add_Action (Table.States (205), 58, 22);
Add_Action (Table.States (205), 61, 24);
Add_Action (Table.States (205), 68, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (205), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (205), 76, 235);
Add_Action (Table.States (205), 84, 237);
Add_Action (Table.States (205), 93, 31);
Add_Action (Table.States (205), 96, 238);
Add_Action (Table.States (205), 101, 239);
Add_Action (Table.States (205), 102, 240);
Add_Action (Table.States (205), 104, 360);
Add_Action (Table.States (205), 105, 33);
Add_Action (Table.States (205), 106, 34);
Add_Error (Table.States (205));
Add_Goto (Table.States (205), 113, 36);
Add_Goto (Table.States (205), 115, 241);
Add_Goto (Table.States (205), 123, 38);
Add_Goto (Table.States (205), 126, 39);
Add_Goto (Table.States (205), 128, 41);
Add_Goto (Table.States (205), 131, 42);
Add_Goto (Table.States (205), 132, 43);
Add_Goto (Table.States (205), 133, 44);
Add_Goto (Table.States (205), 139, 47);
Add_Goto (Table.States (205), 151, 50);
Add_Goto (Table.States (205), 152, 51);
Add_Goto (Table.States (205), 161, 53);
Add_Goto (Table.States (205), 190, 57);
Add_Goto (Table.States (205), 196, 59);
Add_Goto (Table.States (205), 217, 68);
Add_Goto (Table.States (205), 222, 70);
Add_Goto (Table.States (205), 232, 72);
Add_Goto (Table.States (205), 239, 73);
Add_Goto (Table.States (205), 257, 83);
Add_Goto (Table.States (205), 261, 86);
Add_Goto (Table.States (205), 272, 92);
Add_Goto (Table.States (205), 276, 93);
Add_Goto (Table.States (205), 290, 96);
Add_Goto (Table.States (205), 293, 97);
Add_Goto (Table.States (205), 294, 98);
Add_Goto (Table.States (205), 298, 99);
Add_Goto (Table.States (205), 299, 361);
Add_Goto (Table.States (205), 300, 367);
Add_Goto (Table.States (205), 302, 100);
Add_Goto (Table.States (205), 303, 101);
Add_Goto (Table.States (205), 306, 363);
Add_Goto (Table.States (205), 322, 242);
Add_Goto (Table.States (205), 323, 114);
Table.States (205).Kernel := To_Vector (((128, 239, 2, True), (178, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (261, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True), (324, 239, 0, False)));
Table.States (205).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (206), 4, 1);
Add_Action (Table.States (206), 5, 2);
Add_Action (Table.States (206), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (206), 15, 3);
Add_Action (Table.States (206), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (206), 18, 4);
Add_Action (Table.States (206), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (206), 27, 5);
Add_Action (Table.States (206), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (206), 31, 9);
Add_Action (Table.States (206), 32, 10);
Add_Action (Table.States (206), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (206), 41, 13);
Add_Action (Table.States (206), 43, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (206), 48, 16);
Add_Action (Table.States (206), 52, 20);
Add_Action (Table.States (206), 57, 21);
Add_Action (Table.States (206), 58, 22);
Add_Action (Table.States (206), 61, 24);
Add_Action (Table.States (206), 68, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (206), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (206), 93, 31);
Add_Action (Table.States (206), 104, 360);
Add_Action (Table.States (206), 105, 33);
Add_Action (Table.States (206), 106, 34);
Add_Error (Table.States (206));
Add_Goto (Table.States (206), 113, 36);
Add_Goto (Table.States (206), 123, 38);
Add_Goto (Table.States (206), 126, 39);
Add_Goto (Table.States (206), 128, 41);
Add_Goto (Table.States (206), 131, 42);
Add_Goto (Table.States (206), 132, 43);
Add_Goto (Table.States (206), 133, 44);
Add_Goto (Table.States (206), 139, 47);
Add_Goto (Table.States (206), 151, 50);
Add_Goto (Table.States (206), 152, 51);
Add_Goto (Table.States (206), 161, 53);
Add_Goto (Table.States (206), 190, 57);
Add_Goto (Table.States (206), 196, 59);
Add_Goto (Table.States (206), 217, 68);
Add_Goto (Table.States (206), 222, 70);
Add_Goto (Table.States (206), 232, 72);
Add_Goto (Table.States (206), 239, 73);
Add_Goto (Table.States (206), 257, 83);
Add_Goto (Table.States (206), 261, 86);
Add_Goto (Table.States (206), 272, 92);
Add_Goto (Table.States (206), 276, 93);
Add_Goto (Table.States (206), 290, 96);
Add_Goto (Table.States (206), 293, 97);
Add_Goto (Table.States (206), 294, 98);
Add_Goto (Table.States (206), 298, 99);
Add_Goto (Table.States (206), 299, 361);
Add_Goto (Table.States (206), 300, 368);
Add_Goto (Table.States (206), 302, 100);
Add_Goto (Table.States (206), 303, 101);
Add_Goto (Table.States (206), 306, 363);
Add_Goto (Table.States (206), 323, 114);
Table.States (206).Kernel := To_Vector (((178, 261, 0, False), (324, 261, 0, False)));
Table.States (206).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (207), (22, 24, 43), (296, 1), 1, select_alternative_list_1'Access, null);
Table.States (207).Kernel := To_Vector ((0 => (296, 295, 0, False)));
Table.States (207).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 296, 1)));
Add_Action (Table.States (208), 22, Reduce, (297, 0), 1, null, null);
Add_Action (Table.States (208), 24, Reduce, (297, 0), 1, null, null);
Add_Action (Table.States (208), 43, 369);
Add_Error (Table.States (208));
Table.States (208).Kernel := To_Vector (((296, 296, 3, True), (297, 296, 0, False)));
Table.States (208).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 297, 1)));
Add_Action (Table.States (209), 22, 370);
Add_Action (Table.States (209), 24, 371);
Add_Error (Table.States (209));
Table.States (209).Kernel := To_Vector (((294, 297, 4, False), (294, 297, 3, False)));
Table.States (209).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 371)));
Add_Action (Table.States (210), 68, 372);
Add_Error (Table.States (210));
Table.States (210).Kernel := To_Vector ((0 => (126, 324, 5, False)));
Table.States (210).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 68, 372)));
Add_Action (Table.States (211), 35, 373);
Add_Error (Table.States (211));
Table.States (211).Kernel := To_Vector ((0 => (313, 104, 3, False)));
Table.States (211).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 373)));
Add_Action (Table.States (212), 104, 374);
Add_Error (Table.States (212));
Table.States (212).Kernel := To_Vector (((316, 14, 5, False), (317, 14, 4, False)));
Table.States (212).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 374)));
Add_Action (Table.States (213), 104, 375);
Add_Error (Table.States (213));
Table.States (213).Kernel := To_Vector (((319, 69, 7, False), (319, 69, 4, False), (319, 69, 2, False)));
Table.States (213).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 375)));
Add_Action (Table.States (214), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (214), 74, 337);
Add_Action (Table.States (214), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (214));
Add_Goto (Table.States (214), 122, 376);
Table.States (214).Kernel := To_Vector (((305, 104, 6, False), (305, 104, 3, False), (305, 104, 1,
False)));
Table.States (214).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (215), 35, Reduce, (169, 2), 0, null, null);
Add_Action (Table.States (215), 76, 377);
Add_Action (Table.States (215), 96, Reduce, (169, 2), 0, null, null);
Add_Error (Table.States (215));
Add_Goto (Table.States (215), 169, 378);
Table.States (215).Kernel := To_Vector (((206, 104, 3, False), (223, 104, 3, False), (223, 104, 1, False),
(259, 104, 6, False), (260, 104, 3, False)));
Table.States (215).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 169, 0)));
Add_Action (Table.States (216), 69, 379);
Add_Error (Table.States (216));
Table.States (216).Kernel := To_Vector ((0 => (331, 9, 3, False)));
Table.States (216).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 69, 379)));
Add_Action (Table.States (217), 104, 119);
Add_Action (Table.States (217), 105, 33);
Add_Action (Table.States (217), 106, 34);
Add_Error (Table.States (217));
Add_Goto (Table.States (217), 128, 41);
Add_Goto (Table.States (217), 238, 380);
Add_Goto (Table.States (217), 239, 219);
Add_Goto (Table.States (217), 272, 92);
Add_Goto (Table.States (217), 293, 97);
Table.States (217).Kernel := To_Vector ((0 => (331, 69, 2, False)));
Table.States (217).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (218), 83, 381);
Add_Action (Table.States (218), 96, 382);
Add_Error (Table.States (218));
Table.States (218).Kernel := To_Vector (((238, 238, 2, True), (331, 238, 1, False)));
Table.States (218).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 382)));
Add_Action (Table.States (219), 76, 235);
Add_Action (Table.States (219), 83, Reduce, (238, 1), 1, null, null);
Add_Action (Table.States (219), 84, 237);
Add_Action (Table.States (219), 96, Reduce, (238, 1), 1, null, null);
Add_Action (Table.States (219), 101, 239);
Add_Action (Table.States (219), 102, 240);
Add_Error (Table.States (219));
Add_Goto (Table.States (219), 115, 241);
Add_Goto (Table.States (219), 322, 242);
Table.States (219).Kernel := To_Vector (((128, 239, 2, True), (238, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (219).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 238, 1)));
Add_Action (Table.States (220), (1 => 37), (229, 0), 2, iteration_scheme_0'Access, null);
Table.States (220).Kernel := To_Vector ((0 => (229, 192, 0, False)));
Table.States (220).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 229, 2)));
Add_Action (Table.States (221), 83, 381);
Add_Action (Table.States (221), 96, 383);
Add_Error (Table.States (221));
Table.States (221).Kernel := To_Vector (((238, 238, 2, True), (332, 238, 1, False)));
Table.States (221).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 383)));
Add_Action (Table.States (222), 90, 384);
Add_Error (Table.States (222));
Table.States (222).Kernel := To_Vector ((0 => (217, 104, 1, False)));
Table.States (222).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 90, 384)));
Add_Action (Table.States (223), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (223), 13, Reduce, (131, 0), 2, block_label_0'Access, block_label_0_check'Access);
Add_Action (Table.States (223), 17, Reduce, (131, 0), 2, block_label_0'Access, block_label_0_check'Access);
Add_Action (Table.States (223), 26, 385);
Add_Action (Table.States (223), 28, Reduce, (131, 0), 2, block_label_0'Access, block_label_0_check'Access);
Add_Action (Table.States (223), 37, Reduce, (131, 0), 2, block_label_0'Access, block_label_0_check'Access);
Add_Action (Table.States (223), 40, 386);
Add_Action (Table.States (223), 73, Reduce, (131, 0), 2, block_label_0'Access, block_label_0_check'Access);
Add_Action (Table.States (223), 104, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (223), 105, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (223), 106, Reduce, (241, 1), 0, null, null);
Add_Error (Table.States (223));
Add_Goto (Table.States (223), 114, 387);
Add_Goto (Table.States (223), 241, 388);
Table.States (223).Kernel := To_Vector (((131, 81, 0, False), (245, 81, 4, False), (245, 81, 5, False),
(245, 81, 4, False)));
Table.States (223).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 131, 2)));
Add_Action (Table.States (224), 4, 1);
Add_Action (Table.States (224), 5, 2);
Add_Action (Table.States (224), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (224), 15, 3);
Add_Action (Table.States (224), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (224), 18, 4);
Add_Action (Table.States (224), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (224), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (224), 27, 5);
Add_Action (Table.States (224), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (224), 31, 9);
Add_Action (Table.States (224), 32, 10);
Add_Action (Table.States (224), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (224), 41, 13);
Add_Action (Table.States (224), 48, 16);
Add_Action (Table.States (224), 52, 20);
Add_Action (Table.States (224), 57, 21);
Add_Action (Table.States (224), 58, 22);
Add_Action (Table.States (224), 61, 24);
Add_Action (Table.States (224), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (224), 93, 31);
Add_Action (Table.States (224), 104, 360);
Add_Action (Table.States (224), 105, 33);
Add_Action (Table.States (224), 106, 34);
Add_Error (Table.States (224));
Add_Goto (Table.States (224), 113, 36);
Add_Goto (Table.States (224), 123, 38);
Add_Goto (Table.States (224), 126, 39);
Add_Goto (Table.States (224), 128, 41);
Add_Goto (Table.States (224), 131, 42);
Add_Goto (Table.States (224), 132, 43);
Add_Goto (Table.States (224), 133, 44);
Add_Goto (Table.States (224), 139, 47);
Add_Goto (Table.States (224), 151, 50);
Add_Goto (Table.States (224), 152, 51);
Add_Goto (Table.States (224), 161, 53);
Add_Goto (Table.States (224), 190, 57);
Add_Goto (Table.States (224), 196, 59);
Add_Goto (Table.States (224), 217, 68);
Add_Goto (Table.States (224), 218, 389);
Add_Goto (Table.States (224), 222, 70);
Add_Goto (Table.States (224), 232, 72);
Add_Goto (Table.States (224), 239, 73);
Add_Goto (Table.States (224), 257, 83);
Add_Goto (Table.States (224), 261, 86);
Add_Goto (Table.States (224), 272, 92);
Add_Goto (Table.States (224), 276, 93);
Add_Goto (Table.States (224), 290, 96);
Add_Goto (Table.States (224), 293, 97);
Add_Goto (Table.States (224), 294, 98);
Add_Goto (Table.States (224), 298, 99);
Add_Goto (Table.States (224), 299, 361);
Add_Goto (Table.States (224), 300, 390);
Add_Goto (Table.States (224), 302, 100);
Add_Goto (Table.States (224), 303, 101);
Add_Goto (Table.States (224), 306, 363);
Add_Goto (Table.States (224), 323, 114);
Table.States (224).Kernel := To_Vector ((0 => (133, 13, 2, False)));
Table.States (224).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (225), 13, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (225), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (225), 28, 183);
Add_Action (Table.States (225), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (225), 30, 8);
Add_Action (Table.States (225), 40, 12);
Add_Action (Table.States (225), 46, 14);
Add_Action (Table.States (225), 47, 15);
Add_Action (Table.States (225), 48, 16);
Add_Action (Table.States (225), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (225), 51, 19);
Add_Action (Table.States (225), 63, 25);
Add_Action (Table.States (225), 66, 26);
Add_Action (Table.States (225), 69, 27);
Add_Action (Table.States (225), 71, 28);
Add_Action (Table.States (225), 104, 185);
Add_Error (Table.States (225));
Add_Goto (Table.States (225), 112, 35);
Add_Goto (Table.States (225), 121, 37);
Add_Goto (Table.States (225), 127, 40);
Add_Goto (Table.States (225), 134, 45);
Add_Goto (Table.States (225), 135, 46);
Add_Goto (Table.States (225), 157, 391);
Add_Goto (Table.States (225), 158, 392);
Add_Goto (Table.States (225), 159, 393);
Add_Goto (Table.States (225), 179, 54);
Add_Goto (Table.States (225), 182, 55);
Add_Goto (Table.States (225), 186, 56);
Add_Goto (Table.States (225), 193, 58);
Add_Goto (Table.States (225), 206, 60);
Add_Goto (Table.States (225), 207, 61);
Add_Goto (Table.States (225), 209, 62);
Add_Goto (Table.States (225), 210, 63);
Add_Goto (Table.States (225), 213, 64);
Add_Goto (Table.States (225), 214, 65);
Add_Goto (Table.States (225), 215, 66);
Add_Goto (Table.States (225), 216, 67);
Add_Goto (Table.States (225), 219, 69);
Add_Goto (Table.States (225), 223, 71);
Add_Goto (Table.States (225), 243, 74);
Add_Goto (Table.States (225), 244, 75);
Add_Goto (Table.States (225), 245, 76);
Add_Goto (Table.States (225), 246, 77);
Add_Goto (Table.States (225), 247, 78);
Add_Goto (Table.States (225), 248, 79);
Add_Goto (Table.States (225), 249, 80);
Add_Goto (Table.States (225), 250, 81);
Add_Goto (Table.States (225), 251, 82);
Add_Goto (Table.States (225), 257, 394);
Add_Goto (Table.States (225), 259, 84);
Add_Goto (Table.States (225), 260, 85);
Add_Goto (Table.States (225), 262, 87);
Add_Goto (Table.States (225), 263, 88);
Add_Goto (Table.States (225), 264, 89);
Add_Goto (Table.States (225), 265, 90);
Add_Goto (Table.States (225), 271, 91);
Add_Goto (Table.States (225), 281, 94);
Add_Goto (Table.States (225), 289, 95);
Add_Goto (Table.States (225), 304, 102);
Add_Goto (Table.States (225), 305, 103);
Add_Goto (Table.States (225), 307, 105);
Add_Goto (Table.States (225), 308, 106);
Add_Goto (Table.States (225), 309, 107);
Add_Goto (Table.States (225), 311, 108);
Add_Goto (Table.States (225), 313, 109);
Add_Goto (Table.States (225), 316, 111);
Add_Goto (Table.States (225), 317, 112);
Add_Goto (Table.States (225), 319, 113);
Add_Goto (Table.States (225), 325, 115);
Add_Goto (Table.States (225), 331, 116);
Table.States (225).Kernel := To_Vector ((0 => (133, 17, 3, False)));
Table.States (225).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (226), 37, Reduce, (231, 1), 0, null, null);
Add_Action (Table.States (226), 104, 395);
Add_Error (Table.States (226));
Add_Goto (Table.States (226), 230, 155);
Add_Goto (Table.States (226), 231, 156);
Table.States (226).Kernel := To_Vector ((0 => (229, 28, 0, False)));
Table.States (226).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 231, 0)));
Add_Action (Table.States (227), 4, 1);
Add_Action (Table.States (227), 5, 2);
Add_Action (Table.States (227), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (227), 15, 3);
Add_Action (Table.States (227), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (227), 18, 4);
Add_Action (Table.States (227), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (227), 27, 5);
Add_Action (Table.States (227), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (227), 31, 9);
Add_Action (Table.States (227), 32, 10);
Add_Action (Table.States (227), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (227), 41, 13);
Add_Action (Table.States (227), 48, 16);
Add_Action (Table.States (227), 52, 20);
Add_Action (Table.States (227), 57, 21);
Add_Action (Table.States (227), 58, 22);
Add_Action (Table.States (227), 61, 24);
Add_Action (Table.States (227), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (227), 93, 31);
Add_Action (Table.States (227), 104, 360);
Add_Action (Table.States (227), 105, 33);
Add_Action (Table.States (227), 106, 34);
Add_Error (Table.States (227));
Add_Goto (Table.States (227), 113, 36);
Add_Goto (Table.States (227), 123, 38);
Add_Goto (Table.States (227), 126, 39);
Add_Goto (Table.States (227), 128, 41);
Add_Goto (Table.States (227), 131, 42);
Add_Goto (Table.States (227), 132, 43);
Add_Goto (Table.States (227), 133, 44);
Add_Goto (Table.States (227), 139, 47);
Add_Goto (Table.States (227), 151, 50);
Add_Goto (Table.States (227), 152, 51);
Add_Goto (Table.States (227), 161, 53);
Add_Goto (Table.States (227), 190, 57);
Add_Goto (Table.States (227), 196, 59);
Add_Goto (Table.States (227), 217, 68);
Add_Goto (Table.States (227), 222, 70);
Add_Goto (Table.States (227), 232, 72);
Add_Goto (Table.States (227), 239, 73);
Add_Goto (Table.States (227), 257, 83);
Add_Goto (Table.States (227), 261, 86);
Add_Goto (Table.States (227), 272, 92);
Add_Goto (Table.States (227), 276, 93);
Add_Goto (Table.States (227), 290, 96);
Add_Goto (Table.States (227), 293, 97);
Add_Goto (Table.States (227), 294, 98);
Add_Goto (Table.States (227), 298, 99);
Add_Goto (Table.States (227), 299, 361);
Add_Goto (Table.States (227), 300, 396);
Add_Goto (Table.States (227), 302, 100);
Add_Goto (Table.States (227), 303, 101);
Add_Goto (Table.States (227), 306, 363);
Add_Goto (Table.States (227), 323, 114);
Table.States (227).Kernel := To_Vector ((0 => (232, 37, 3, False)));
Table.States (227).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (228), 37, 397);
Add_Error (Table.States (228));
Table.States (228).Kernel := To_Vector ((0 => (232, 229, 4, False)));
Table.States (228).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 397)));
Add_Action (Table.States (229), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (143, 0), 2,
compilation_unit_list_0'Access, null);
Table.States (229).Kernel := To_Vector ((0 => (143, 142, 0, True)));
Table.States (229).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 143, 2)));
Table.States (229).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (230), 104, 119);
Add_Action (Table.States (230), 105, 33);
Add_Action (Table.States (230), 106, 34);
Add_Error (Table.States (230));
Add_Goto (Table.States (230), 128, 41);
Add_Goto (Table.States (230), 239, 398);
Add_Goto (Table.States (230), 272, 92);
Add_Goto (Table.States (230), 293, 97);
Table.States (230).Kernel := To_Vector (((251, 47, 4, False), (251, 47, 3, False)));
Table.States (230).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (231), 96, 399);
Add_Error (Table.States (231));
Table.States (231).Kernel := To_Vector ((0 => (214, 251, 1, False)));
Table.States (231).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 399)));
Add_Action (Table.States (232), 74, 337);
Add_Action (Table.States (232), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (232));
Add_Goto (Table.States (232), 122, 400);
Table.States (232).Kernel := To_Vector ((0 => (216, 312, 1, False)));
Table.States (232).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (233), 7, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 8, 401);
Add_Action (Table.States (233), 11, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 16, 402);
Add_Conflict (Table.States (233), 16, (118, 1), 0, null, null);
Add_Action (Table.States (233), 26, 403);
Add_Action (Table.States (233), 40, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 74, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 82, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 96, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 104, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 105, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (233), 106, Reduce, (118, 1), 0, null, null);
Add_Error (Table.States (233));
Add_Goto (Table.States (233), 118, 404);
Table.States (233).Kernel := To_Vector (((157, 81, 3, False), (186, 81, 2, False), (244, 81, 3, False),
(244, 81, 4, False), (244, 81, 10, False), (244, 81, 2, False), (244, 81, 3, False), (244, 81, 9, False)));
Table.States (233).Minimal_Complete_Actions := To_Vector (((Shift, 26, 403), (Reduce, 118, 0)));
Add_Action (Table.States (234), 104, 405);
Add_Error (Table.States (234));
Table.States (234).Kernel := To_Vector ((0 => (219, 83, 1, True)));
Table.States (234).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 405)));
Table.States (234).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (235), 3, 121);
Add_Action (Table.States (235), 15, 258);
Add_Action (Table.States (235), 28, 259);
Add_Action (Table.States (235), 32, 260);
Add_Action (Table.States (235), 39, 122);
Add_Action (Table.States (235), 40, 261);
Add_Action (Table.States (235), 41, 124);
Add_Action (Table.States (235), 44, 263);
Add_Action (Table.States (235), 52, 125);
Add_Action (Table.States (235), 76, 126);
Add_Action (Table.States (235), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (235), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (235), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (235), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (235), 94, 127);
Add_Action (Table.States (235), 95, 128);
Add_Action (Table.States (235), 103, 129);
Add_Action (Table.States (235), 104, 119);
Add_Action (Table.States (235), 105, 33);
Add_Action (Table.States (235), 106, 264);
Add_Error (Table.States (235));
Add_Goto (Table.States (235), 117, 130);
Add_Goto (Table.States (235), 124, 265);
Add_Goto (Table.States (235), 125, 406);
Add_Goto (Table.States (235), 128, 41);
Add_Goto (Table.States (235), 136, 267);
Add_Goto (Table.States (235), 153, 407);
Add_Goto (Table.States (235), 165, 269);
Add_Goto (Table.States (235), 166, 270);
Add_Goto (Table.States (235), 191, 408);
Add_Goto (Table.States (235), 197, 133);
Add_Goto (Table.States (235), 221, 273);
Add_Goto (Table.States (235), 239, 274);
Add_Goto (Table.States (235), 258, 135);
Add_Goto (Table.States (235), 272, 92);
Add_Goto (Table.States (235), 273, 275);
Add_Goto (Table.States (235), 275, 136);
Add_Goto (Table.States (235), 277, 409);
Add_Goto (Table.States (235), 278, 410);
Add_Goto (Table.States (235), 282, 137);
Add_Goto (Table.States (235), 283, 138);
Add_Goto (Table.States (235), 284, 139);
Add_Goto (Table.States (235), 285, 140);
Add_Goto (Table.States (235), 286, 141);
Add_Goto (Table.States (235), 287, 142);
Add_Goto (Table.States (235), 293, 97);
Add_Goto (Table.States (235), 301, 277);
Add_Goto (Table.States (235), 320, 144);
Add_Goto (Table.States (235), 321, 145);
Add_Goto (Table.States (235), 330, 146);
Table.States (235).Kernel := To_Vector (((115, 76, 1, False), (115, 76, 3, False), (239, 76, 4, True)));
Table.States (235).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Table.States (235).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (236), 3, 121);
Add_Action (Table.States (236), 39, 122);
Add_Action (Table.States (236), 40, 123);
Add_Action (Table.States (236), 41, 124);
Add_Action (Table.States (236), 52, 125);
Add_Action (Table.States (236), 76, 126);
Add_Action (Table.States (236), 94, 127);
Add_Action (Table.States (236), 95, 128);
Add_Action (Table.States (236), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (236), 103, 129);
Add_Action (Table.States (236), 104, 119);
Add_Action (Table.States (236), 105, 33);
Add_Action (Table.States (236), 106, 34);
Add_Error (Table.States (236));
Add_Goto (Table.States (236), 117, 130);
Add_Goto (Table.States (236), 128, 41);
Add_Goto (Table.States (236), 191, 131);
Add_Goto (Table.States (236), 192, 411);
Add_Goto (Table.States (236), 197, 133);
Add_Goto (Table.States (236), 239, 134);
Add_Goto (Table.States (236), 258, 135);
Add_Goto (Table.States (236), 272, 92);
Add_Goto (Table.States (236), 275, 136);
Add_Goto (Table.States (236), 282, 137);
Add_Goto (Table.States (236), 283, 138);
Add_Goto (Table.States (236), 284, 139);
Add_Goto (Table.States (236), 285, 140);
Add_Goto (Table.States (236), 286, 141);
Add_Goto (Table.States (236), 287, 142);
Add_Goto (Table.States (236), 293, 97);
Add_Goto (Table.States (236), 301, 143);
Add_Goto (Table.States (236), 320, 144);
Add_Goto (Table.States (236), 321, 145);
Add_Goto (Table.States (236), 330, 146);
Table.States (236).Kernel := To_Vector ((0 => (123, 82, 1, False)));
Table.States (236).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
end Subr_4;
procedure Subr_5
is begin
Add_Action (Table.States (237), 9, 412);
Add_Action (Table.States (237), 104, 413);
Add_Action (Table.States (237), 105, 414);
Add_Action (Table.States (237), 106, 415);
Add_Error (Table.States (237));
Table.States (237).Kernel := To_Vector (((293, 84, 1, True), (293, 84, 1, True), (293, 84, 1, True), (293,
84, 1, True)));
Table.States (237).Minimal_Complete_Actions := To_Vector (((Shift, 104, 413), (Shift, 106, 415), (Shift,
105, 414), (Shift, 9, 412)));
Table.States (237).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (238), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (261, 0), 2, procedure_call_statement_0'Access, null);
Table.States (238).Kernel := To_Vector ((0 => (261, 96, 0, False)));
Table.States (238).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 261, 2)));
Add_Action (Table.States (239), (7, 19, 20, 38, 53, 76, 104, 105, 106), (322, 0), 1, null, null);
Table.States (239).Kernel := To_Vector ((0 => (322, 101, 0, False)));
Table.States (239).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 322, 1)));
Add_Action (Table.States (240), (7, 19, 20, 38, 53, 76, 104, 105, 106), (322, 1), 1, null, null);
Table.States (240).Kernel := To_Vector ((0 => (322, 102, 0, False)));
Table.States (240).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 322, 1)));
Add_Action (Table.States (241), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 1), 2, name_1'Access,
null);
Table.States (241).Kernel := To_Vector ((0 => (239, 115, 0, True)));
Table.States (241).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 2)));
Table.States (241).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (242), 7, 416);
Add_Action (Table.States (242), 19, 417);
Add_Action (Table.States (242), 20, 418);
Add_Action (Table.States (242), 38, 419);
Add_Action (Table.States (242), 76, 126);
Add_Action (Table.States (242), 104, 119);
Add_Action (Table.States (242), 105, 33);
Add_Action (Table.States (242), 106, 34);
Add_Error (Table.States (242));
Add_Goto (Table.States (242), 117, 420);
Add_Goto (Table.States (242), 128, 41);
Add_Goto (Table.States (242), 129, 421);
Add_Goto (Table.States (242), 239, 422);
Add_Goto (Table.States (242), 272, 92);
Add_Goto (Table.States (242), 293, 97);
Table.States (242).Kernel := To_Vector (((128, 322, 1, True), (272, 322, 2, True)));
Table.States (242).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Table.States (242).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (243), 104, 423);
Add_Error (Table.States (243));
Table.States (243).Kernel := To_Vector (((179, 25, 5, False), (179, 25, 2, False)));
Table.States (243).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 423)));
Add_Action (Table.States (244), 104, 119);
Add_Action (Table.States (244), 105, 33);
Add_Action (Table.States (244), 106, 34);
Add_Error (Table.States (244));
Add_Goto (Table.States (244), 128, 41);
Add_Goto (Table.States (244), 239, 424);
Add_Goto (Table.States (244), 272, 92);
Add_Goto (Table.States (244), 293, 97);
Table.States (244).Kernel := To_Vector (((207, 29, 2, False), (213, 29, 5, False)));
Table.States (244).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (245), 104, 119);
Add_Action (Table.States (245), 105, 33);
Add_Action (Table.States (245), 106, 34);
Add_Error (Table.States (245));
Add_Goto (Table.States (245), 128, 41);
Add_Goto (Table.States (245), 239, 425);
Add_Goto (Table.States (245), 272, 92);
Add_Goto (Table.States (245), 293, 97);
Table.States (245).Kernel := To_Vector (((213, 50, 5, False), (262, 50, 1, False)));
Table.States (245).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (246), 35, 426);
Add_Conflict (Table.States (246), 35, (312, 1), 1, null, subprogram_specification_1_check'Access);
Add_Action (Table.States (246), 56, Reduce, (312, 1), 1, null, subprogram_specification_1_check'Access);
Add_Action (Table.States (246), 74, Reduce, (312, 1), 1, null, subprogram_specification_1_check'Access);
Add_Action (Table.States (246), 96, Reduce, (312, 1), 1, null, subprogram_specification_1_check'Access);
Add_Error (Table.States (246));
Table.States (246).Kernel := To_Vector (((193, 207, 4, False), (312, 207, 0, False)));
Table.States (246).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 312, 1)));
Add_Action (Table.States (247), 35, 427);
Add_Conflict (Table.States (247), 35, (312, 0), 1, null, subprogram_specification_0_check'Access);
Add_Action (Table.States (247), 56, Reduce, (312, 0), 1, null, subprogram_specification_0_check'Access);
Add_Action (Table.States (247), 74, Reduce, (312, 0), 1, null, subprogram_specification_0_check'Access);
Add_Action (Table.States (247), 96, Reduce, (312, 0), 1, null, subprogram_specification_0_check'Access);
Add_Error (Table.States (247));
Table.States (247).Kernel := To_Vector (((243, 262, 3, False), (312, 262, 0, False)));
Table.States (247).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 312, 1)));
Add_Action (Table.States (248), 35, 428);
Add_Conflict (Table.States (248), 35, (122, 1), 0, null, null);
Add_Action (Table.States (248), 56, 429);
Add_Action (Table.States (248), 74, 337);
Add_Action (Table.States (248), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (248));
Add_Goto (Table.States (248), 122, 430);
Table.States (248).Kernel := To_Vector (((112, 312, 3, False), (307, 312, 4, False), (308, 312, 3, False),
(309, 312, 1, False), (311, 312, 3, False)));
Table.States (248).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (249), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (249, 0), 2,
package_declaration_0'Access, null);
Table.States (249).Kernel := To_Vector ((0 => (249, 96, 0, False)));
Table.States (249).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 249, 2)));
Add_Action (Table.States (250), 3, 121);
Add_Action (Table.States (250), 15, 258);
Add_Action (Table.States (250), 28, 259);
Add_Action (Table.States (250), 32, 260);
Add_Action (Table.States (250), 39, 122);
Add_Action (Table.States (250), 40, 261);
Add_Action (Table.States (250), 41, 124);
Add_Action (Table.States (250), 44, 263);
Add_Action (Table.States (250), 52, 125);
Add_Action (Table.States (250), 76, 126);
Add_Action (Table.States (250), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (250), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (250), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (250), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (250), 94, 127);
Add_Action (Table.States (250), 95, 128);
Add_Action (Table.States (250), 103, 129);
Add_Action (Table.States (250), 104, 119);
Add_Action (Table.States (250), 105, 33);
Add_Action (Table.States (250), 106, 264);
Add_Error (Table.States (250));
Add_Goto (Table.States (250), 117, 130);
Add_Goto (Table.States (250), 124, 265);
Add_Goto (Table.States (250), 125, 406);
Add_Goto (Table.States (250), 128, 41);
Add_Goto (Table.States (250), 136, 267);
Add_Goto (Table.States (250), 153, 407);
Add_Goto (Table.States (250), 165, 269);
Add_Goto (Table.States (250), 166, 270);
Add_Goto (Table.States (250), 191, 408);
Add_Goto (Table.States (250), 197, 133);
Add_Goto (Table.States (250), 221, 273);
Add_Goto (Table.States (250), 239, 274);
Add_Goto (Table.States (250), 258, 135);
Add_Goto (Table.States (250), 272, 92);
Add_Goto (Table.States (250), 273, 275);
Add_Goto (Table.States (250), 275, 136);
Add_Goto (Table.States (250), 277, 276);
Add_Goto (Table.States (250), 282, 137);
Add_Goto (Table.States (250), 283, 138);
Add_Goto (Table.States (250), 284, 139);
Add_Goto (Table.States (250), 285, 140);
Add_Goto (Table.States (250), 286, 141);
Add_Goto (Table.States (250), 287, 142);
Add_Goto (Table.States (250), 293, 97);
Add_Goto (Table.States (250), 301, 277);
Add_Goto (Table.States (250), 320, 144);
Add_Goto (Table.States (250), 321, 145);
Add_Goto (Table.States (250), 330, 146);
Table.States (250).Kernel := To_Vector (((115, 76, 1, False), (115, 76, 3, False)));
Table.States (250).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Add_Action (Table.States (251), (21, 76, 96), (116, 0), 1, null, null);
Table.States (251).Kernel := To_Vector ((0 => (116, 115, 0, False)));
Table.States (251).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 116, 1)));
Add_Action (Table.States (252), 21, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (252), 76, 431);
Add_Action (Table.States (252), 96, Reduce, (253, 1), 0, null, null);
Add_Error (Table.States (252));
Add_Goto (Table.States (252), 199, 344);
Add_Goto (Table.States (252), 253, 432);
Table.States (252).Kernel := To_Vector (((113, 116, 3, False), (113, 116, 1, False)));
Table.States (252).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 0)));
Add_Action (Table.States (253), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 8), 3, simple_statement_8'Access, null);
Table.States (253).Kernel := To_Vector ((0 => (303, 96, 0, False)));
Table.States (253).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 3)));
Add_Action (Table.States (254), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99), (197, 2), 2, null, null);
Table.States (254).Kernel := To_Vector ((0 => (197, 258, 0, False)));
Table.States (254).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 197, 2)));
Add_Action (Table.States (255), 10, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 20, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 21, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 22, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 23, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 33, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 35, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 37, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 38, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 40, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 42, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 43, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 53, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 55, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 68, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 74, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 75, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 76, 235);
Add_Action (Table.States (255), 77, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 78, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 79, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 82, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 83, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 84, 237);
Add_Action (Table.States (255), 85, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 86, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 87, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 88, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 89, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 91, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 92, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 94, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 95, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 96, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 97, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 98, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 99, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 100, Reduce, (258, 4), 2, primary_4'Access, null);
Add_Action (Table.States (255), 101, 239);
Add_Action (Table.States (255), 102, 240);
Add_Error (Table.States (255));
Add_Goto (Table.States (255), 115, 241);
Add_Goto (Table.States (255), 322, 242);
Table.States (255).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(258, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (255).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 2)));
Add_Action (Table.States (256), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99), (197, 3), 2, null, null);
Table.States (256).Kernel := To_Vector ((0 => (197, 258, 0, False)));
Table.States (256).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 197, 2)));
Add_Action (Table.States (257), 10, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 20, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 21, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 22, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 23, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 35, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 37, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 43, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 53, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 68, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 74, 433);
Add_Conflict (Table.States (257), 74, (275, 1), 2, null, null);
Add_Action (Table.States (257), 75, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 76, 235);
Add_Action (Table.States (257), 77, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 79, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 83, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 84, 237);
Add_Action (Table.States (257), 87, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 96, Reduce, (275, 1), 2, null, null);
Add_Action (Table.States (257), 101, 239);
Add_Action (Table.States (257), 102, 240);
Add_Error (Table.States (257));
Add_Goto (Table.States (257), 115, 241);
Add_Goto (Table.States (257), 322, 242);
Table.States (257).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (275, 239, 1, True), (275, 239, 0, False), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (257).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 275, 2)));
Table.States (257).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (258), 3, 121);
Add_Action (Table.States (258), 35, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (258), 39, 122);
Add_Action (Table.States (258), 40, 123);
Add_Action (Table.States (258), 41, 124);
Add_Action (Table.States (258), 52, 125);
Add_Action (Table.States (258), 76, 126);
Add_Action (Table.States (258), 94, 127);
Add_Action (Table.States (258), 95, 128);
Add_Action (Table.States (258), 103, 129);
Add_Action (Table.States (258), 104, 119);
Add_Action (Table.States (258), 105, 33);
Add_Action (Table.States (258), 106, 34);
Add_Error (Table.States (258));
Add_Goto (Table.States (258), 117, 130);
Add_Goto (Table.States (258), 128, 41);
Add_Goto (Table.States (258), 191, 131);
Add_Goto (Table.States (258), 192, 434);
Add_Goto (Table.States (258), 197, 133);
Add_Goto (Table.States (258), 239, 134);
Add_Goto (Table.States (258), 258, 135);
Add_Goto (Table.States (258), 272, 92);
Add_Goto (Table.States (258), 275, 136);
Add_Goto (Table.States (258), 282, 137);
Add_Goto (Table.States (258), 283, 138);
Add_Goto (Table.States (258), 284, 139);
Add_Goto (Table.States (258), 285, 140);
Add_Goto (Table.States (258), 286, 141);
Add_Goto (Table.States (258), 287, 142);
Add_Goto (Table.States (258), 293, 97);
Add_Goto (Table.States (258), 301, 143);
Add_Goto (Table.States (258), 320, 144);
Add_Goto (Table.States (258), 321, 145);
Add_Goto (Table.States (258), 330, 146);
Table.States (258).Kernel := To_Vector ((0 => (136, 15, 3, False)));
Table.States (258).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (259), 9, 435);
Add_Action (Table.States (259), 62, 436);
Add_Error (Table.States (259));
Add_Goto (Table.States (259), 274, 437);
Table.States (259).Kernel := To_Vector ((0 => (273, 28, 5, False)));
Table.States (259).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 9, 435)));
Add_Action (Table.States (260), 3, 121);
Add_Action (Table.States (260), 39, 122);
Add_Action (Table.States (260), 40, 123);
Add_Action (Table.States (260), 41, 124);
Add_Action (Table.States (260), 52, 125);
Add_Action (Table.States (260), 68, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (260), 76, 126);
Add_Action (Table.States (260), 94, 127);
Add_Action (Table.States (260), 95, 128);
Add_Action (Table.States (260), 103, 129);
Add_Action (Table.States (260), 104, 119);
Add_Action (Table.States (260), 105, 33);
Add_Action (Table.States (260), 106, 34);
Add_Error (Table.States (260));
Add_Goto (Table.States (260), 117, 130);
Add_Goto (Table.States (260), 128, 41);
Add_Goto (Table.States (260), 191, 131);
Add_Goto (Table.States (260), 192, 438);
Add_Goto (Table.States (260), 197, 133);
Add_Goto (Table.States (260), 239, 134);
Add_Goto (Table.States (260), 258, 135);
Add_Goto (Table.States (260), 272, 92);
Add_Goto (Table.States (260), 275, 136);
Add_Goto (Table.States (260), 282, 137);
Add_Goto (Table.States (260), 283, 138);
Add_Goto (Table.States (260), 284, 139);
Add_Goto (Table.States (260), 285, 140);
Add_Goto (Table.States (260), 286, 141);
Add_Goto (Table.States (260), 287, 142);
Add_Goto (Table.States (260), 293, 97);
Add_Goto (Table.States (260), 301, 143);
Add_Goto (Table.States (260), 320, 144);
Add_Goto (Table.States (260), 321, 145);
Add_Goto (Table.States (260), 330, 146);
Table.States (260).Kernel := To_Vector (((221, 32, 4, False), (221, 32, 2, False), (221, 32, 3, False),
(221, 32, 1, False)));
Table.States (260).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (261), 39, 122);
Add_Action (Table.States (261), 41, 439);
Add_Action (Table.States (261), 76, 126);
Add_Action (Table.States (261), 103, 129);
Add_Action (Table.States (261), 104, 119);
Add_Action (Table.States (261), 105, 33);
Add_Action (Table.States (261), 106, 34);
Add_Error (Table.States (261));
Add_Goto (Table.States (261), 117, 130);
Add_Goto (Table.States (261), 128, 41);
Add_Goto (Table.States (261), 239, 134);
Add_Goto (Table.States (261), 258, 256);
Add_Goto (Table.States (261), 272, 92);
Add_Goto (Table.States (261), 293, 97);
Table.States (261).Kernel := To_Vector (((165, 40, 2, False), (197, 40, 1, False)));
Table.States (261).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (262), 10, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 33, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 38, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 40, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 43, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 54, 440);
Add_Action (Table.States (262), 55, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 74, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 75, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 77, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 78, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 79, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 83, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 85, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 86, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 87, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 88, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 89, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 91, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 92, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 94, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 95, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 97, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 98, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 99, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (262), 100, Reduce, (258, 1), 1, null, null);
Add_Error (Table.States (262));
Table.States (262).Kernel := To_Vector (((117, 41, 2, False), (258, 41, 0, False)));
Table.States (262).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (263), (79, 87), (165, 3), 1, null, null);
Table.States (263).Kernel := To_Vector ((0 => (165, 44, 0, False)));
Table.States (263).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 165, 1)));
Add_Action (Table.States (264), 10, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 33, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 35, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 38, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 40, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 43, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 53, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 55, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 74, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 75, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 76, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 77, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 78, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 79, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 83, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 84, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 85, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 86, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 87, 441);
Add_Conflict (Table.States (264), 87, (239, 6), 1, null, null);
Add_Action (Table.States (264), 88, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 89, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 91, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 92, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 94, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 95, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 96, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 97, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 98, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 99, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 100, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 101, Reduce, (239, 6), 1, null, null);
Add_Action (Table.States (264), 102, Reduce, (239, 6), 1, null, null);
Add_Error (Table.States (264));
Table.States (264).Kernel := To_Vector (((124, 106, 1, False), (124, 106, 2, False), (239, 106, 0,
False)));
Table.States (264).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Add_Action (Table.States (265), (35, 77, 83, 96), (125, 1), 1, null, null);
Table.States (265).Kernel := To_Vector ((0 => (125, 124, 0, False)));
Table.States (265).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 1)));
Add_Action (Table.States (266), 77, 442);
Add_Action (Table.States (266), 83, 443);
Add_Error (Table.States (266));
Table.States (266).Kernel := To_Vector (((117, 125, 1, False), (125, 125, 1, True)));
Table.States (266).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 442)));
Add_Action (Table.States (267), (1 => 77), (153, 1), 1, null, null);
Table.States (267).Kernel := To_Vector ((0 => (153, 136, 0, False)));
Table.States (267).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 153, 1)));
Add_Action (Table.States (268), 77, 444);
Add_Error (Table.States (268));
Table.States (268).Kernel := To_Vector ((0 => (117, 153, 1, False)));
Table.States (268).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 444)));
Add_Action (Table.States (269), (79, 87), (166, 1), 1, null, null);
Table.States (269).Kernel := To_Vector ((0 => (166, 165, 0, False)));
Table.States (269).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 166, 1)));
Add_Action (Table.States (270), 79, 445);
Add_Action (Table.States (270), 87, 446);
Add_Error (Table.States (270));
Table.States (270).Kernel := To_Vector (((124, 166, 1, False), (124, 166, 2, False), (166, 166, 2, True)));
Table.States (270).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 446)));
Add_Action (Table.States (271), 74, Reduce, (192, 0), 1, null, null);
Add_Action (Table.States (271), 77, Reduce, (124, 4), 1, association_opt_4'Access, null);
Add_Conflict (Table.States (271), 77, (192, 0), 1, null, null);
Add_Action (Table.States (271), 79, Reduce, (165, 0), 1, null, null);
Add_Action (Table.States (271), 83, Reduce, (124, 4), 1, association_opt_4'Access, null);
Add_Action (Table.States (271), 87, Reduce, (165, 0), 1, null, null);
Add_Error (Table.States (271));
Table.States (271).Kernel := To_Vector (((124, 191, 0, False), (165, 191, 0, False), (192, 191, 0, True)));
Table.States (271).Minimal_Complete_Actions := To_Vector (((Reduce, 124, 1), (Reduce, 165, 1), (Reduce,
192, 1)));
Table.States (271).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (272), 74, 447);
Add_Error (Table.States (272));
Table.States (272).Kernel := To_Vector (((117, 192, 4, False), (117, 192, 2, False)));
Table.States (272).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 447)));
Add_Action (Table.States (273), (1 => 77), (153, 0), 1, null, null);
Table.States (273).Kernel := To_Vector ((0 => (153, 221, 0, False)));
Table.States (273).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 153, 1)));
Add_Action (Table.States (274), 10, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 20, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 21, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 22, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 23, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 33, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 35, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 37, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 38, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 40, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 43, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 53, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 55, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 68, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 74, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 75, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 76, 235);
Add_Action (Table.States (274), 77, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 78, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 79, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 83, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 84, 237);
Add_Action (Table.States (274), 85, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 86, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 87, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 88, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 89, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 91, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 92, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 94, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 95, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 96, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 97, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 98, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 99, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 100, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (274), 101, 239);
Add_Action (Table.States (274), 102, 240);
Add_Error (Table.States (274));
Add_Goto (Table.States (274), 115, 241);
Add_Goto (Table.States (274), 322, 448);
Table.States (274).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(258, 239, 0, False), (272, 239, 3, True), (277, 239, 4, False), (277, 239, 2, False), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True)));
Table.States (274).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (275), (1 => 77), (153, 2), 1, null, null);
Table.States (275).Kernel := To_Vector ((0 => (153, 273, 0, False)));
Table.States (275).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 153, 1)));
Add_Action (Table.States (276), (79, 87), (165, 2), 1, null, null);
Table.States (276).Kernel := To_Vector ((0 => (165, 277, 0, False)));
Table.States (276).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 165, 1)));
Add_Action (Table.States (277), 10, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 33, 288);
Add_Action (Table.States (277), 35, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 40, 289);
Add_Action (Table.States (277), 43, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 74, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 75, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 77, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 79, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 83, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 85, 449);
Add_Action (Table.States (277), 86, 290);
Add_Action (Table.States (277), 87, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 88, 291);
Add_Action (Table.States (277), 89, 292);
Add_Action (Table.States (277), 91, 293);
Add_Action (Table.States (277), 92, 294);
Add_Action (Table.States (277), 96, Reduce, (287, 3), 1, null, null);
Add_Action (Table.States (277), 98, 295);
Add_Error (Table.States (277));
Add_Goto (Table.States (277), 288, 296);
Table.States (277).Kernel := To_Vector (((277, 301, 2, False), (287, 301, 3, False), (287, 301, 2, False),
(287, 301, 2, False), (287, 301, 0, False)));
Table.States (277).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 287, 1)));
Add_Action (Table.States (278), 72, 450);
Add_Error (Table.States (278));
Add_Goto (Table.States (278), 140, 451);
Add_Goto (Table.States (278), 141, 452);
Table.States (278).Kernel := To_Vector ((0 => (139, 35, 5, False)));
Table.States (278).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 72, 450)));
Add_Action (Table.States (279), 39, 122);
Add_Action (Table.States (279), 41, 124);
Add_Action (Table.States (279), 76, 126);
Add_Action (Table.States (279), 103, 129);
Add_Action (Table.States (279), 104, 119);
Add_Action (Table.States (279), 105, 33);
Add_Action (Table.States (279), 106, 34);
Add_Error (Table.States (279));
Add_Goto (Table.States (279), 117, 130);
Add_Goto (Table.States (279), 128, 41);
Add_Goto (Table.States (279), 239, 134);
Add_Goto (Table.States (279), 258, 453);
Add_Goto (Table.States (279), 272, 92);
Add_Goto (Table.States (279), 293, 97);
Table.States (279).Kernel := To_Vector ((0 => (197, 100, 1, False)));
Table.States (279).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (280), 3, 121);
Add_Action (Table.States (280), 39, 122);
Add_Action (Table.States (280), 40, 123);
Add_Action (Table.States (280), 41, 124);
Add_Action (Table.States (280), 52, 125);
Add_Action (Table.States (280), 76, 126);
Add_Action (Table.States (280), 94, 127);
Add_Action (Table.States (280), 95, 128);
Add_Action (Table.States (280), 103, 129);
Add_Action (Table.States (280), 104, 119);
Add_Action (Table.States (280), 105, 33);
Add_Action (Table.States (280), 106, 34);
Add_Error (Table.States (280));
Add_Goto (Table.States (280), 117, 130);
Add_Goto (Table.States (280), 128, 41);
Add_Goto (Table.States (280), 197, 133);
Add_Goto (Table.States (280), 239, 134);
Add_Goto (Table.States (280), 258, 135);
Add_Goto (Table.States (280), 272, 92);
Add_Goto (Table.States (280), 275, 136);
Add_Goto (Table.States (280), 287, 454);
Add_Goto (Table.States (280), 293, 97);
Add_Goto (Table.States (280), 301, 143);
Add_Goto (Table.States (280), 320, 144);
Add_Goto (Table.States (280), 321, 145);
Add_Goto (Table.States (280), 330, 146);
Table.States (280).Kernel := To_Vector ((0 => (282, 10, 1, True)));
Table.States (280).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (280).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (281), 68, 455);
Add_Error (Table.States (281));
Table.States (281).Kernel := To_Vector ((0 => (283, 10, 2, True)));
Table.States (281).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 68, 455)));
Table.States (281).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (282), 3, 121);
Add_Action (Table.States (282), 39, 122);
Add_Action (Table.States (282), 40, 123);
Add_Action (Table.States (282), 41, 124);
Add_Action (Table.States (282), 52, 125);
Add_Action (Table.States (282), 76, 126);
Add_Action (Table.States (282), 94, 127);
Add_Action (Table.States (282), 95, 128);
Add_Action (Table.States (282), 103, 129);
Add_Action (Table.States (282), 104, 119);
Add_Action (Table.States (282), 105, 33);
Add_Action (Table.States (282), 106, 34);
Add_Error (Table.States (282));
Add_Goto (Table.States (282), 117, 130);
Add_Goto (Table.States (282), 128, 41);
Add_Goto (Table.States (282), 197, 133);
Add_Goto (Table.States (282), 239, 134);
Add_Goto (Table.States (282), 258, 135);
Add_Goto (Table.States (282), 272, 92);
Add_Goto (Table.States (282), 275, 136);
Add_Goto (Table.States (282), 287, 456);
Add_Goto (Table.States (282), 293, 97);
Add_Goto (Table.States (282), 301, 143);
Add_Goto (Table.States (282), 320, 144);
Add_Goto (Table.States (282), 321, 145);
Add_Goto (Table.States (282), 330, 146);
Table.States (282).Kernel := To_Vector ((0 => (284, 43, 1, True)));
Table.States (282).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (282).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (283), 22, 457);
Add_Error (Table.States (283));
Table.States (283).Kernel := To_Vector ((0 => (285, 43, 2, True)));
Table.States (283).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 22, 457)));
Table.States (283).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (284), 3, 121);
Add_Action (Table.States (284), 39, 122);
Add_Action (Table.States (284), 40, 123);
Add_Action (Table.States (284), 41, 124);
Add_Action (Table.States (284), 52, 125);
Add_Action (Table.States (284), 76, 126);
Add_Action (Table.States (284), 94, 127);
Add_Action (Table.States (284), 95, 128);
Add_Action (Table.States (284), 103, 129);
Add_Action (Table.States (284), 104, 119);
Add_Action (Table.States (284), 105, 33);
Add_Action (Table.States (284), 106, 34);
Add_Error (Table.States (284));
Add_Goto (Table.States (284), 117, 130);
Add_Goto (Table.States (284), 128, 41);
Add_Goto (Table.States (284), 197, 133);
Add_Goto (Table.States (284), 239, 134);
Add_Goto (Table.States (284), 258, 135);
Add_Goto (Table.States (284), 272, 92);
Add_Goto (Table.States (284), 275, 136);
Add_Goto (Table.States (284), 287, 458);
Add_Goto (Table.States (284), 293, 97);
Add_Goto (Table.States (284), 301, 143);
Add_Goto (Table.States (284), 320, 144);
Add_Goto (Table.States (284), 321, 145);
Add_Goto (Table.States (284), 330, 146);
Table.States (284).Kernel := To_Vector ((0 => (286, 75, 1, True)));
Table.States (284).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (284).Minimal_Complete_Actions_Recursive := True;
end Subr_5;
procedure Subr_6
is begin
Add_Action (Table.States (285), 3, 121);
Add_Action (Table.States (285), 39, 122);
Add_Action (Table.States (285), 40, 123);
Add_Action (Table.States (285), 41, 124);
Add_Action (Table.States (285), 52, 125);
Add_Action (Table.States (285), 68, 459);
Add_Action (Table.States (285), 76, 126);
Add_Action (Table.States (285), 94, 127);
Add_Action (Table.States (285), 95, 128);
Add_Action (Table.States (285), 103, 129);
Add_Action (Table.States (285), 104, 119);
Add_Action (Table.States (285), 105, 33);
Add_Action (Table.States (285), 106, 34);
Add_Error (Table.States (285));
Add_Goto (Table.States (285), 117, 130);
Add_Goto (Table.States (285), 128, 41);
Add_Goto (Table.States (285), 197, 133);
Add_Goto (Table.States (285), 239, 134);
Add_Goto (Table.States (285), 258, 135);
Add_Goto (Table.States (285), 272, 92);
Add_Goto (Table.States (285), 275, 136);
Add_Goto (Table.States (285), 287, 460);
Add_Goto (Table.States (285), 293, 97);
Add_Goto (Table.States (285), 301, 143);
Add_Goto (Table.States (285), 320, 144);
Add_Goto (Table.States (285), 321, 145);
Add_Goto (Table.States (285), 330, 146);
Table.States (285).Kernel := To_Vector (((282, 10, 1, True), (283, 10, 2, True)));
Table.States (285).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (285).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (286), 3, 121);
Add_Action (Table.States (286), 22, 461);
Add_Action (Table.States (286), 39, 122);
Add_Action (Table.States (286), 40, 123);
Add_Action (Table.States (286), 41, 124);
Add_Action (Table.States (286), 52, 125);
Add_Action (Table.States (286), 76, 126);
Add_Action (Table.States (286), 94, 127);
Add_Action (Table.States (286), 95, 128);
Add_Action (Table.States (286), 103, 129);
Add_Action (Table.States (286), 104, 119);
Add_Action (Table.States (286), 105, 33);
Add_Action (Table.States (286), 106, 34);
Add_Error (Table.States (286));
Add_Goto (Table.States (286), 117, 130);
Add_Goto (Table.States (286), 128, 41);
Add_Goto (Table.States (286), 197, 133);
Add_Goto (Table.States (286), 239, 134);
Add_Goto (Table.States (286), 258, 135);
Add_Goto (Table.States (286), 272, 92);
Add_Goto (Table.States (286), 275, 136);
Add_Goto (Table.States (286), 287, 462);
Add_Goto (Table.States (286), 293, 97);
Add_Goto (Table.States (286), 301, 143);
Add_Goto (Table.States (286), 320, 144);
Add_Goto (Table.States (286), 321, 145);
Add_Goto (Table.States (286), 330, 146);
Table.States (286).Kernel := To_Vector (((284, 43, 1, True), (285, 43, 2, True)));
Table.States (286).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (286).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (287), 3, 121);
Add_Action (Table.States (287), 39, 122);
Add_Action (Table.States (287), 40, 123);
Add_Action (Table.States (287), 41, 124);
Add_Action (Table.States (287), 52, 125);
Add_Action (Table.States (287), 76, 126);
Add_Action (Table.States (287), 94, 127);
Add_Action (Table.States (287), 95, 128);
Add_Action (Table.States (287), 103, 129);
Add_Action (Table.States (287), 104, 119);
Add_Action (Table.States (287), 105, 33);
Add_Action (Table.States (287), 106, 34);
Add_Error (Table.States (287));
Add_Goto (Table.States (287), 117, 130);
Add_Goto (Table.States (287), 128, 41);
Add_Goto (Table.States (287), 197, 133);
Add_Goto (Table.States (287), 239, 134);
Add_Goto (Table.States (287), 258, 135);
Add_Goto (Table.States (287), 272, 92);
Add_Goto (Table.States (287), 275, 136);
Add_Goto (Table.States (287), 287, 463);
Add_Goto (Table.States (287), 293, 97);
Add_Goto (Table.States (287), 301, 143);
Add_Goto (Table.States (287), 320, 144);
Add_Goto (Table.States (287), 321, 145);
Add_Goto (Table.States (287), 330, 146);
Table.States (287).Kernel := To_Vector ((0 => (286, 75, 1, True)));
Table.States (287).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (287).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (288), 3, 121);
Add_Action (Table.States (288), 39, 122);
Add_Action (Table.States (288), 40, 123);
Add_Action (Table.States (288), 41, 124);
Add_Action (Table.States (288), 76, 126);
Add_Action (Table.States (288), 94, 127);
Add_Action (Table.States (288), 95, 128);
Add_Action (Table.States (288), 103, 129);
Add_Action (Table.States (288), 104, 119);
Add_Action (Table.States (288), 105, 33);
Add_Action (Table.States (288), 106, 34);
Add_Error (Table.States (288));
Add_Goto (Table.States (288), 117, 130);
Add_Goto (Table.States (288), 128, 41);
Add_Goto (Table.States (288), 197, 133);
Add_Goto (Table.States (288), 233, 464);
Add_Goto (Table.States (288), 234, 465);
Add_Goto (Table.States (288), 239, 274);
Add_Goto (Table.States (288), 258, 135);
Add_Goto (Table.States (288), 272, 92);
Add_Goto (Table.States (288), 277, 466);
Add_Goto (Table.States (288), 293, 97);
Add_Goto (Table.States (288), 301, 467);
Add_Goto (Table.States (288), 320, 144);
Add_Goto (Table.States (288), 321, 145);
Add_Goto (Table.States (288), 330, 146);
Table.States (288).Kernel := To_Vector ((0 => (287, 33, 1, False)));
Table.States (288).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (289), 33, 468);
Add_Error (Table.States (289));
Table.States (289).Kernel := To_Vector ((0 => (287, 40, 2, False)));
Table.States (289).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 33, 468)));
Add_Action (Table.States (290), (3, 39, 40, 41, 76, 94, 95, 103, 104, 105, 106), (288, 0), 1, null, null);
Table.States (290).Kernel := To_Vector ((0 => (288, 86, 0, False)));
Table.States (290).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 288, 1)));
Add_Action (Table.States (291), (3, 39, 40, 41, 76, 94, 95, 103, 104, 105, 106), (288, 4), 1, null, null);
Table.States (291).Kernel := To_Vector ((0 => (288, 88, 0, False)));
Table.States (291).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 288, 1)));
Add_Action (Table.States (292), (3, 39, 40, 41, 76, 94, 95, 103, 104, 105, 106), (288, 5), 1, null, null);
Table.States (292).Kernel := To_Vector ((0 => (288, 89, 0, False)));
Table.States (292).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 288, 1)));
Add_Action (Table.States (293), (3, 39, 40, 41, 76, 94, 95, 103, 104, 105, 106), (288, 2), 1, null, null);
Table.States (293).Kernel := To_Vector ((0 => (288, 91, 0, False)));
Table.States (293).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 288, 1)));
Add_Action (Table.States (294), (3, 39, 40, 41, 76, 94, 95, 103, 104, 105, 106), (288, 3), 1, null, null);
Table.States (294).Kernel := To_Vector ((0 => (288, 92, 0, False)));
Table.States (294).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 288, 1)));
Add_Action (Table.States (295), (3, 39, 40, 41, 76, 94, 95, 103, 104, 105, 106), (288, 1), 1, null, null);
Table.States (295).Kernel := To_Vector ((0 => (288, 98, 0, False)));
Table.States (295).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 288, 1)));
Add_Action (Table.States (296), 3, 121);
Add_Action (Table.States (296), 39, 122);
Add_Action (Table.States (296), 40, 123);
Add_Action (Table.States (296), 41, 124);
Add_Action (Table.States (296), 76, 126);
Add_Action (Table.States (296), 94, 127);
Add_Action (Table.States (296), 95, 128);
Add_Action (Table.States (296), 103, 129);
Add_Action (Table.States (296), 104, 119);
Add_Action (Table.States (296), 105, 33);
Add_Action (Table.States (296), 106, 34);
Add_Error (Table.States (296));
Add_Goto (Table.States (296), 117, 130);
Add_Goto (Table.States (296), 128, 41);
Add_Goto (Table.States (296), 197, 133);
Add_Goto (Table.States (296), 239, 134);
Add_Goto (Table.States (296), 258, 135);
Add_Goto (Table.States (296), 272, 92);
Add_Goto (Table.States (296), 293, 97);
Add_Goto (Table.States (296), 301, 469);
Add_Goto (Table.States (296), 320, 144);
Add_Goto (Table.States (296), 321, 145);
Add_Goto (Table.States (296), 330, 146);
Table.States (296).Kernel := To_Vector ((0 => (287, 288, 1, False)));
Table.States (296).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (297), (3, 39, 40, 41, 76, 103, 104, 105, 106), (237, 2), 1, null, null);
Table.States (297).Kernel := To_Vector ((0 => (237, 38, 0, False)));
Table.States (297).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 237, 1)));
Add_Action (Table.States (298), (3, 39, 40, 41, 76, 103, 104, 105, 106), (237, 3), 1, null, null);
Table.States (298).Kernel := To_Vector ((0 => (237, 55, 0, False)));
Table.States (298).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 237, 1)));
Add_Action (Table.States (299), (3, 39, 40, 41, 76, 103, 104, 105, 106), (237, 1), 1, null, null);
Table.States (299).Kernel := To_Vector ((0 => (237, 97, 0, False)));
Table.States (299).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 237, 1)));
Add_Action (Table.States (300), (3, 39, 40, 41, 76, 103, 104, 105, 106), (237, 0), 1, null, null);
Table.States (300).Kernel := To_Vector ((0 => (237, 99, 0, False)));
Table.States (300).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 237, 1)));
Add_Action (Table.States (301), 3, 121);
Add_Action (Table.States (301), 39, 122);
Add_Action (Table.States (301), 40, 123);
Add_Action (Table.States (301), 41, 124);
Add_Action (Table.States (301), 76, 126);
Add_Action (Table.States (301), 103, 129);
Add_Action (Table.States (301), 104, 119);
Add_Action (Table.States (301), 105, 33);
Add_Action (Table.States (301), 106, 34);
Add_Error (Table.States (301));
Add_Goto (Table.States (301), 117, 130);
Add_Goto (Table.States (301), 128, 41);
Add_Goto (Table.States (301), 197, 470);
Add_Goto (Table.States (301), 239, 134);
Add_Goto (Table.States (301), 258, 135);
Add_Goto (Table.States (301), 272, 92);
Add_Goto (Table.States (301), 293, 97);
Table.States (301).Kernel := To_Vector ((0 => (320, 237, 1, True)));
Table.States (301).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (301).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (302), (3, 39, 40, 41, 76, 103, 104, 105, 106), (130, 2), 1, null, null);
Table.States (302).Kernel := To_Vector ((0 => (130, 78, 0, False)));
Table.States (302).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 130, 1)));
Add_Action (Table.States (303), (3, 39, 40, 41, 76, 103, 104, 105, 106), (130, 1), 1, null, null);
Table.States (303).Kernel := To_Vector ((0 => (130, 94, 0, False)));
Table.States (303).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 130, 1)));
Add_Action (Table.States (304), (3, 39, 40, 41, 76, 103, 104, 105, 106), (130, 0), 1, null, null);
Table.States (304).Kernel := To_Vector ((0 => (130, 95, 0, False)));
Table.States (304).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 130, 1)));
Add_Action (Table.States (305), 3, 121);
Add_Action (Table.States (305), 39, 122);
Add_Action (Table.States (305), 40, 123);
Add_Action (Table.States (305), 41, 124);
Add_Action (Table.States (305), 76, 126);
Add_Action (Table.States (305), 103, 129);
Add_Action (Table.States (305), 104, 119);
Add_Action (Table.States (305), 105, 33);
Add_Action (Table.States (305), 106, 34);
Add_Error (Table.States (305));
Add_Goto (Table.States (305), 117, 130);
Add_Goto (Table.States (305), 128, 41);
Add_Goto (Table.States (305), 197, 133);
Add_Goto (Table.States (305), 239, 134);
Add_Goto (Table.States (305), 258, 135);
Add_Goto (Table.States (305), 272, 92);
Add_Goto (Table.States (305), 293, 97);
Add_Goto (Table.States (305), 320, 471);
Table.States (305).Kernel := To_Vector ((0 => (321, 130, 1, True)));
Table.States (305).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (305).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (306), 10, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 20, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 21, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 22, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 23, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 33, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 35, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 37, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 40, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 42, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 43, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 53, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 68, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 74, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 75, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 77, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 78, 302);
Add_Action (Table.States (306), 79, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 82, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 83, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 85, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 86, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 87, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 88, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 89, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 91, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 92, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 94, 303);
Add_Action (Table.States (306), 95, 304);
Add_Action (Table.States (306), 96, Reduce, (301, 0), 2, null, null);
Add_Action (Table.States (306), 98, Reduce, (301, 0), 2, null, null);
Add_Error (Table.States (306));
Add_Goto (Table.States (306), 130, 305);
Table.States (306).Kernel := To_Vector (((301, 321, 0, False), (321, 321, 2, True)));
Table.States (306).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 301, 2)));
Add_Action (Table.States (307), 96, 472);
Add_Error (Table.States (307));
Table.States (307).Kernel := To_Vector ((0 => (161, 192, 1, False)));
Table.States (307).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 472)));
Add_Action (Table.States (308), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (161, 1), 3, delay_statement_1'Access, null);
Table.States (308).Kernel := To_Vector ((0 => (161, 96, 0, False)));
Table.States (308).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 161, 3)));
Add_Action (Table.States (309), 3, 121);
Add_Action (Table.States (309), 39, 122);
Add_Action (Table.States (309), 40, 123);
Add_Action (Table.States (309), 41, 124);
Add_Action (Table.States (309), 52, 125);
Add_Action (Table.States (309), 76, 126);
Add_Action (Table.States (309), 94, 127);
Add_Action (Table.States (309), 95, 128);
Add_Action (Table.States (309), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (309), 103, 129);
Add_Action (Table.States (309), 104, 119);
Add_Action (Table.States (309), 105, 33);
Add_Action (Table.States (309), 106, 34);
Add_Error (Table.States (309));
Add_Goto (Table.States (309), 117, 130);
Add_Goto (Table.States (309), 128, 41);
Add_Goto (Table.States (309), 191, 131);
Add_Goto (Table.States (309), 192, 473);
Add_Goto (Table.States (309), 197, 133);
Add_Goto (Table.States (309), 239, 134);
Add_Goto (Table.States (309), 258, 135);
Add_Goto (Table.States (309), 272, 92);
Add_Goto (Table.States (309), 275, 136);
Add_Goto (Table.States (309), 282, 137);
Add_Goto (Table.States (309), 283, 138);
Add_Goto (Table.States (309), 284, 139);
Add_Goto (Table.States (309), 285, 140);
Add_Goto (Table.States (309), 286, 141);
Add_Goto (Table.States (309), 287, 142);
Add_Goto (Table.States (309), 293, 97);
Add_Goto (Table.States (309), 301, 143);
Add_Goto (Table.States (309), 320, 144);
Add_Goto (Table.States (309), 321, 145);
Add_Goto (Table.States (309), 330, 146);
Table.States (309).Kernel := To_Vector ((0 => (190, 72, 1, False)));
Table.States (309).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (310), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (190, 1), 3, exit_statement_1'Access, null);
Table.States (310).Kernel := To_Vector ((0 => (190, 96, 0, False)));
Table.States (310).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 190, 3)));
Add_Action (Table.States (311), 3, 121);
Add_Action (Table.States (311), 39, 122);
Add_Action (Table.States (311), 40, 474);
Add_Action (Table.States (311), 41, 124);
Add_Action (Table.States (311), 59, 475);
Add_Action (Table.States (311), 76, 126);
Add_Action (Table.States (311), 94, 127);
Add_Action (Table.States (311), 95, 128);
Add_Action (Table.States (311), 103, 129);
Add_Action (Table.States (311), 104, 119);
Add_Action (Table.States (311), 105, 33);
Add_Action (Table.States (311), 106, 34);
Add_Error (Table.States (311));
Add_Goto (Table.States (311), 117, 130);
Add_Goto (Table.States (311), 128, 41);
Add_Goto (Table.States (311), 167, 476);
Add_Goto (Table.States (311), 197, 133);
Add_Goto (Table.States (311), 239, 477);
Add_Goto (Table.States (311), 258, 135);
Add_Goto (Table.States (311), 272, 92);
Add_Goto (Table.States (311), 277, 478);
Add_Goto (Table.States (311), 293, 97);
Add_Goto (Table.States (311), 301, 479);
Add_Goto (Table.States (311), 314, 480);
Add_Goto (Table.States (311), 320, 144);
Add_Goto (Table.States (311), 321, 145);
Add_Goto (Table.States (311), 330, 146);
Table.States (311).Kernel := To_Vector (((230, 33, 2, False), (230, 33, 1, False)));
Table.States (311).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (312), 59, 481);
Add_Action (Table.States (312), 104, 119);
Add_Action (Table.States (312), 105, 33);
Add_Action (Table.States (312), 106, 34);
Add_Error (Table.States (312));
Add_Goto (Table.States (312), 128, 41);
Add_Goto (Table.States (312), 239, 482);
Add_Goto (Table.States (312), 272, 92);
Add_Goto (Table.States (312), 293, 97);
Table.States (312).Kernel := To_Vector (((230, 42, 2, False), (230, 42, 1, False)));
Table.States (312).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (313), 40, 483);
Add_Action (Table.States (313), 104, 119);
Add_Action (Table.States (313), 105, 33);
Add_Action (Table.States (313), 106, 34);
Add_Error (Table.States (313));
Add_Goto (Table.States (313), 128, 41);
Add_Goto (Table.States (313), 239, 484);
Add_Goto (Table.States (313), 272, 92);
Add_Goto (Table.States (313), 293, 97);
Add_Goto (Table.States (313), 314, 485);
Table.States (313).Kernel := To_Vector (((230, 81, 4, False), (230, 81, 3, False)));
Table.States (313).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (314), 3, 121);
Add_Action (Table.States (314), 39, 122);
Add_Action (Table.States (314), 40, 123);
Add_Action (Table.States (314), 41, 124);
Add_Action (Table.States (314), 52, 125);
Add_Action (Table.States (314), 76, 126);
Add_Action (Table.States (314), 94, 127);
Add_Action (Table.States (314), 95, 128);
Add_Action (Table.States (314), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (314), 103, 129);
Add_Action (Table.States (314), 104, 119);
Add_Action (Table.States (314), 105, 33);
Add_Action (Table.States (314), 106, 34);
Add_Error (Table.States (314));
Add_Goto (Table.States (314), 117, 130);
Add_Goto (Table.States (314), 128, 41);
Add_Goto (Table.States (314), 191, 131);
Add_Goto (Table.States (314), 192, 486);
Add_Goto (Table.States (314), 197, 133);
Add_Goto (Table.States (314), 239, 134);
Add_Goto (Table.States (314), 258, 135);
Add_Goto (Table.States (314), 272, 92);
Add_Goto (Table.States (314), 275, 136);
Add_Goto (Table.States (314), 282, 137);
Add_Goto (Table.States (314), 283, 138);
Add_Goto (Table.States (314), 284, 139);
Add_Goto (Table.States (314), 285, 140);
Add_Goto (Table.States (314), 286, 141);
Add_Goto (Table.States (314), 287, 142);
Add_Goto (Table.States (314), 293, 97);
Add_Goto (Table.States (314), 301, 143);
Add_Goto (Table.States (314), 320, 144);
Add_Goto (Table.States (314), 321, 145);
Add_Goto (Table.States (314), 330, 146);
Table.States (314).Kernel := To_Vector ((0 => (121, 71, 1, False)));
Table.States (314).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (315), 12, 487);
Add_Error (Table.States (315));
Table.States (315).Kernel := To_Vector ((0 => (127, 71, 2, False)));
Table.States (315).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 12, 487)));
Add_Action (Table.States (316), 54, 488);
Add_Action (Table.States (316), 76, 126);
Add_Error (Table.States (316));
Add_Goto (Table.States (316), 117, 489);
Table.States (316).Kernel := To_Vector (((182, 71, 3, False), (281, 71, 12, False)));
Table.States (316).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 76, 126)));
Add_Action (Table.States (317), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 21, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 35, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 40, 386);
Add_Action (Table.States (317), 56, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 74, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 77, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 82, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 96, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 104, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 105, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (317), 106, Reduce, (241, 1), 0, null, null);
Add_Error (Table.States (317));
Add_Goto (Table.States (317), 114, 490);
Add_Goto (Table.States (317), 241, 491);
Table.States (317).Kernel := To_Vector (((291, 58, 0, False), (291, 58, 2, True)));
Table.States (317).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 241, 0)));
Add_Action (Table.States (318), 3, 121);
Add_Action (Table.States (318), 15, 258);
Add_Action (Table.States (318), 28, 259);
Add_Action (Table.States (318), 32, 260);
Add_Action (Table.States (318), 39, 122);
Add_Action (Table.States (318), 40, 261);
Add_Action (Table.States (318), 41, 124);
Add_Action (Table.States (318), 44, 263);
Add_Action (Table.States (318), 52, 125);
Add_Action (Table.States (318), 76, 126);
Add_Action (Table.States (318), 77, Reduce, (124, 5), 0, null, null);
Add_Conflict (Table.States (318), 77, (254, 4), 0, null, null);
Add_Action (Table.States (318), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (318), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (318), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (318), 94, 127);
Add_Action (Table.States (318), 95, 128);
Add_Action (Table.States (318), 96, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (318), 103, 129);
Add_Action (Table.States (318), 104, 492);
Add_Action (Table.States (318), 105, 33);
Add_Action (Table.States (318), 106, 264);
Add_Error (Table.States (318));
Add_Goto (Table.States (318), 117, 130);
Add_Goto (Table.States (318), 124, 265);
Add_Goto (Table.States (318), 125, 406);
Add_Goto (Table.States (318), 128, 41);
Add_Goto (Table.States (318), 136, 267);
Add_Goto (Table.States (318), 153, 407);
Add_Goto (Table.States (318), 165, 269);
Add_Goto (Table.States (318), 166, 270);
Add_Goto (Table.States (318), 191, 408);
Add_Goto (Table.States (318), 197, 133);
Add_Goto (Table.States (318), 219, 493);
Add_Goto (Table.States (318), 221, 273);
Add_Goto (Table.States (318), 239, 274);
Add_Goto (Table.States (318), 254, 494);
Add_Goto (Table.States (318), 255, 495);
Add_Goto (Table.States (318), 258, 135);
Add_Goto (Table.States (318), 272, 92);
Add_Goto (Table.States (318), 273, 275);
Add_Goto (Table.States (318), 275, 136);
Add_Goto (Table.States (318), 277, 409);
Add_Goto (Table.States (318), 278, 410);
Add_Goto (Table.States (318), 282, 137);
Add_Goto (Table.States (318), 283, 138);
Add_Goto (Table.States (318), 284, 139);
Add_Goto (Table.States (318), 285, 140);
Add_Goto (Table.States (318), 286, 141);
Add_Goto (Table.States (318), 287, 142);
Add_Goto (Table.States (318), 293, 97);
Add_Goto (Table.States (318), 301, 277);
Add_Goto (Table.States (318), 320, 144);
Add_Goto (Table.States (318), 321, 145);
Add_Goto (Table.States (318), 330, 146);
Table.States (318).Kernel := To_Vector (((115, 76, 1, False), (115, 76, 3, False), (199, 76, 1, False),
(239, 76, 4, True)));
Table.States (318).Minimal_Complete_Actions := To_Vector (((Reduce, 125, 0), (Reduce, 255, 0)));
Table.States (318).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (319), 58, 317);
Add_Error (Table.States (319));
Add_Goto (Table.States (319), 291, 496);
Table.States (319).Kernel := To_Vector ((0 => (252, 199, 1, True)));
Table.States (319).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 58, 317)));
Table.States (319).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (320), (35, 56, 74, 96), (207, 0), 3, function_specification_0'Access,
function_specification_0_check'Access);
Table.States (320).Kernel := To_Vector ((0 => (207, 252, 0, False)));
Table.States (320).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 207, 3)));
Add_Action (Table.States (321), (21, 35, 56, 74, 77, 82, 96), (252, 1), 1, null, null);
Table.States (321).Kernel := To_Vector ((0 => (252, 291, 0, True)));
Table.States (321).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 252, 1)));
Table.States (321).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (322), 56, 497);
Add_Action (Table.States (322), 76, 235);
Add_Action (Table.States (322), 84, 237);
Add_Action (Table.States (322), 101, 239);
Add_Action (Table.States (322), 102, 240);
Add_Error (Table.States (322));
Add_Goto (Table.States (322), 115, 241);
Add_Goto (Table.States (322), 322, 242);
Table.States (322).Kernel := To_Vector (((128, 239, 2, True), (215, 239, 3, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (322).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 56, 497)));
Add_Action (Table.States (323), 56, 498);
Add_Action (Table.States (323), 76, 235);
Add_Action (Table.States (323), 84, 237);
Add_Action (Table.States (323), 101, 239);
Add_Action (Table.States (323), 102, 240);
Add_Error (Table.States (323));
Add_Goto (Table.States (323), 115, 241);
Add_Goto (Table.States (323), 322, 242);
Table.States (323).Kernel := To_Vector (((128, 239, 2, True), (215, 239, 3, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (323).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 56, 498)));
Add_Action (Table.States (324), 56, 499);
Add_Action (Table.States (324), 76, 235);
Add_Action (Table.States (324), 84, 237);
Add_Action (Table.States (324), 101, 239);
Add_Action (Table.States (324), 102, 240);
Add_Error (Table.States (324));
Add_Goto (Table.States (324), 115, 241);
Add_Goto (Table.States (324), 322, 242);
Table.States (324).Kernel := To_Vector (((128, 239, 2, True), (215, 239, 3, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (324).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 56, 499)));
Add_Action (Table.States (325), 35, Reduce, (169, 2), 0, null, null);
Add_Action (Table.States (325), 74, Reduce, (169, 2), 0, null, null);
Add_Action (Table.States (325), 76, 377);
Add_Action (Table.States (325), 96, Reduce, (169, 2), 0, null, null);
Add_Error (Table.States (325));
Add_Goto (Table.States (325), 169, 500);
Table.States (325).Kernel := To_Vector (((201, 104, 3, False), (201, 104, 3, False), (201, 104, 1,
False)));
Table.States (325).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 169, 0)));
Add_Action (Table.States (326), 104, 119);
Add_Action (Table.States (326), 105, 33);
Add_Action (Table.States (326), 106, 34);
Add_Error (Table.States (326));
Add_Goto (Table.States (326), 128, 41);
Add_Goto (Table.States (326), 239, 501);
Add_Goto (Table.States (326), 272, 92);
Add_Goto (Table.States (326), 293, 97);
Table.States (326).Kernel := To_Vector ((0 => (204, 47, 5, False)));
Table.States (326).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (327), 35, 502);
Add_Action (Table.States (327), 74, 337);
Add_Action (Table.States (327), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (327));
Add_Goto (Table.States (327), 122, 503);
Table.States (327).Kernel := To_Vector (((200, 312, 4, False), (200, 312, 3, False), (200, 312, 3, False),
(200, 312, 1, False)));
Table.States (327).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (328), (29, 47, 48, 50, 69, 71, 74, 104), (211, 0), 2, null, null);
Table.States (328).Kernel := To_Vector ((0 => (211, 212, 0, True)));
Table.States (328).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 211, 2)));
Table.States (328).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (329), 7, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (329), 33, 504);
Add_Action (Table.States (329), 40, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (329), 45, 505);
Add_Action (Table.States (329), 74, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (329), 82, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (329), 96, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (329), 104, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (329), 105, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (329), 106, Reduce, (236, 3), 0, null, null);
Add_Error (Table.States (329));
Add_Goto (Table.States (329), 236, 506);
Table.States (329).Kernel := To_Vector (((198, 81, 3, False), (198, 81, 4, False), (198, 81, 2, False),
(198, 81, 3, False)));
Table.States (329).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 236, 0)));
Add_Action (Table.States (330), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (303, 3), 3, simple_statement_3'Access, null);
Table.States (330).Kernel := To_Vector ((0 => (303, 96, 0, False)));
Table.States (330).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 303, 3)));
Add_Action (Table.States (331), 4, 1);
Add_Action (Table.States (331), 5, 2);
Add_Action (Table.States (331), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (331), 15, 3);
Add_Action (Table.States (331), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (331), 18, 4);
Add_Action (Table.States (331), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (331), 23, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (331), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (331), 27, 5);
Add_Action (Table.States (331), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (331), 31, 9);
Add_Action (Table.States (331), 32, 10);
Add_Action (Table.States (331), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (331), 41, 13);
Add_Action (Table.States (331), 48, 16);
Add_Action (Table.States (331), 52, 20);
Add_Action (Table.States (331), 57, 21);
Add_Action (Table.States (331), 58, 22);
Add_Action (Table.States (331), 61, 24);
Add_Action (Table.States (331), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (331), 93, 31);
Add_Action (Table.States (331), 104, 360);
Add_Action (Table.States (331), 105, 33);
Add_Action (Table.States (331), 106, 34);
Add_Error (Table.States (331));
Add_Goto (Table.States (331), 113, 36);
Add_Goto (Table.States (331), 123, 38);
Add_Goto (Table.States (331), 126, 39);
Add_Goto (Table.States (331), 128, 41);
Add_Goto (Table.States (331), 131, 42);
Add_Goto (Table.States (331), 132, 43);
Add_Goto (Table.States (331), 133, 44);
Add_Goto (Table.States (331), 139, 47);
Add_Goto (Table.States (331), 151, 50);
Add_Goto (Table.States (331), 152, 51);
Add_Goto (Table.States (331), 161, 53);
Add_Goto (Table.States (331), 190, 57);
Add_Goto (Table.States (331), 196, 59);
Add_Goto (Table.States (331), 217, 68);
Add_Goto (Table.States (331), 222, 70);
Add_Goto (Table.States (331), 232, 72);
Add_Goto (Table.States (331), 239, 73);
Add_Goto (Table.States (331), 257, 83);
Add_Goto (Table.States (331), 261, 86);
Add_Goto (Table.States (331), 272, 92);
Add_Goto (Table.States (331), 276, 93);
Add_Goto (Table.States (331), 290, 96);
Add_Goto (Table.States (331), 293, 97);
Add_Goto (Table.States (331), 294, 98);
Add_Goto (Table.States (331), 298, 99);
Add_Goto (Table.States (331), 299, 361);
Add_Goto (Table.States (331), 300, 507);
Add_Goto (Table.States (331), 302, 100);
Add_Goto (Table.States (331), 303, 101);
Add_Goto (Table.States (331), 306, 363);
Add_Goto (Table.States (331), 323, 114);
Table.States (331).Kernel := To_Vector (((222, 68, 6, False), (222, 68, 4, False), (222, 68, 5, False),
(222, 68, 3, False)));
Table.States (331).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (332), 104, 119);
Add_Action (Table.States (332), 105, 33);
Add_Action (Table.States (332), 106, 34);
Add_Error (Table.States (332));
Add_Goto (Table.States (332), 128, 41);
Add_Goto (Table.States (332), 238, 508);
Add_Goto (Table.States (332), 239, 219);
Add_Goto (Table.States (332), 272, 92);
Add_Goto (Table.States (332), 293, 97);
Table.States (332).Kernel := To_Vector ((0 => (332, 74, 2, False)));
Table.States (332).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (333), 83, 381);
Add_Action (Table.States (333), 96, 509);
Add_Error (Table.States (333));
Table.States (333).Kernel := To_Vector (((238, 238, 2, True), (332, 238, 1, False)));
Table.States (333).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 509)));
Add_Action (Table.States (334), 35, 510);
Add_Conflict (Table.States (334), 35, (122, 1), 0, null, null);
Add_Action (Table.States (334), 74, 337);
Add_Action (Table.States (334), 76, 235);
Add_Action (Table.States (334), 84, 237);
Add_Action (Table.States (334), 101, 239);
Add_Action (Table.States (334), 102, 240);
Add_Error (Table.States (334));
Add_Goto (Table.States (334), 115, 241);
Add_Goto (Table.States (334), 122, 511);
Add_Goto (Table.States (334), 322, 242);
Table.States (334).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(247, 239, 4, False), (247, 239, 3, False), (248, 239, 3, False), (272, 239, 3, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True)));
Table.States (334).Minimal_Complete_Actions := To_Vector (((Reduce, 122, 0), (Shift, 35, 510)));
Add_Action (Table.States (335), 39, 512);
Add_Error (Table.States (335));
Table.States (335).Kernel := To_Vector ((0 => (213, 35, 3, False)));
Table.States (335).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 39, 512)));
end Subr_6;
procedure Subr_7
is begin
Add_Action (Table.States (336), 104, 119);
Add_Action (Table.States (336), 105, 33);
Add_Action (Table.States (336), 106, 34);
Add_Error (Table.States (336));
Add_Goto (Table.States (336), 128, 41);
Add_Goto (Table.States (336), 239, 513);
Add_Goto (Table.States (336), 272, 92);
Add_Goto (Table.States (336), 293, 97);
Table.States (336).Kernel := To_Vector ((0 => (250, 56, 2, False)));
Table.States (336).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (337), 3, 121);
Add_Action (Table.States (337), 35, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (337), 39, 122);
Add_Action (Table.States (337), 40, 261);
Add_Action (Table.States (337), 41, 124);
Add_Action (Table.States (337), 44, 263);
Add_Action (Table.States (337), 52, 125);
Add_Action (Table.States (337), 76, 126);
Add_Action (Table.States (337), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (337), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (337), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (337), 94, 127);
Add_Action (Table.States (337), 95, 128);
Add_Action (Table.States (337), 96, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (337), 103, 129);
Add_Action (Table.States (337), 104, 119);
Add_Action (Table.States (337), 105, 33);
Add_Action (Table.States (337), 106, 264);
Add_Error (Table.States (337));
Add_Goto (Table.States (337), 117, 130);
Add_Goto (Table.States (337), 124, 265);
Add_Goto (Table.States (337), 125, 514);
Add_Goto (Table.States (337), 128, 41);
Add_Goto (Table.States (337), 165, 269);
Add_Goto (Table.States (337), 166, 270);
Add_Goto (Table.States (337), 191, 408);
Add_Goto (Table.States (337), 197, 133);
Add_Goto (Table.States (337), 239, 274);
Add_Goto (Table.States (337), 258, 135);
Add_Goto (Table.States (337), 272, 92);
Add_Goto (Table.States (337), 275, 136);
Add_Goto (Table.States (337), 277, 276);
Add_Goto (Table.States (337), 282, 137);
Add_Goto (Table.States (337), 283, 138);
Add_Goto (Table.States (337), 284, 139);
Add_Goto (Table.States (337), 285, 140);
Add_Goto (Table.States (337), 286, 141);
Add_Goto (Table.States (337), 287, 142);
Add_Goto (Table.States (337), 293, 97);
Add_Goto (Table.States (337), 301, 277);
Add_Goto (Table.States (337), 320, 144);
Add_Goto (Table.States (337), 321, 145);
Add_Goto (Table.States (337), 330, 146);
Table.States (337).Kernel := To_Vector ((0 => (122, 74, 0, False)));
Table.States (337).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Add_Action (Table.States (338), 35, 515);
Add_Error (Table.States (338));
Table.States (338).Kernel := To_Vector (((251, 122, 3, False), (251, 122, 2, False)));
Table.States (338).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 515)));
Add_Action (Table.States (339), 3, 121);
Add_Action (Table.States (339), 15, 258);
Add_Action (Table.States (339), 28, 259);
Add_Action (Table.States (339), 32, 260);
Add_Action (Table.States (339), 39, 122);
Add_Action (Table.States (339), 40, 261);
Add_Action (Table.States (339), 41, 124);
Add_Action (Table.States (339), 44, 263);
Add_Action (Table.States (339), 52, 125);
Add_Action (Table.States (339), 76, 126);
Add_Action (Table.States (339), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (339), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (339), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (339), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (339), 94, 127);
Add_Action (Table.States (339), 95, 128);
Add_Action (Table.States (339), 103, 129);
Add_Action (Table.States (339), 104, 119);
Add_Action (Table.States (339), 105, 33);
Add_Action (Table.States (339), 106, 264);
Add_Error (Table.States (339));
Add_Goto (Table.States (339), 117, 130);
Add_Goto (Table.States (339), 124, 265);
Add_Goto (Table.States (339), 125, 516);
Add_Goto (Table.States (339), 128, 41);
Add_Goto (Table.States (339), 136, 267);
Add_Goto (Table.States (339), 153, 517);
Add_Goto (Table.States (339), 165, 269);
Add_Goto (Table.States (339), 166, 270);
Add_Goto (Table.States (339), 191, 408);
Add_Goto (Table.States (339), 197, 133);
Add_Goto (Table.States (339), 221, 273);
Add_Goto (Table.States (339), 239, 274);
Add_Goto (Table.States (339), 258, 135);
Add_Goto (Table.States (339), 272, 92);
Add_Goto (Table.States (339), 273, 275);
Add_Goto (Table.States (339), 275, 136);
Add_Goto (Table.States (339), 277, 276);
Add_Goto (Table.States (339), 282, 137);
Add_Goto (Table.States (339), 283, 138);
Add_Goto (Table.States (339), 284, 139);
Add_Goto (Table.States (339), 285, 140);
Add_Goto (Table.States (339), 286, 141);
Add_Goto (Table.States (339), 287, 142);
Add_Goto (Table.States (339), 293, 97);
Add_Goto (Table.States (339), 301, 277);
Add_Goto (Table.States (339), 320, 144);
Add_Goto (Table.States (339), 321, 145);
Add_Goto (Table.States (339), 330, 146);
Table.States (339).Kernel := To_Vector (((257, 76, 2, False), (257, 76, 4, False)));
Table.States (339).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Add_Action (Table.States (340), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (257, 2), 3, pragma_g_2'Access, null);
Table.States (340).Kernel := To_Vector ((0 => (257, 96, 0, False)));
Table.States (340).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 257, 3)));
Add_Action (Table.States (341), 71, Reduce, (163, 0), 1, null, null);
Add_Conflict (Table.States (341), 71, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (341), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (341), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (341), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (341), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (341));
Table.States (341).Kernel := To_Vector (((163, 104, 0, False), (239, 104, 0, False)));
Table.States (341).Minimal_Complete_Actions := To_Vector (((Reduce, 163, 1), (Reduce, 239, 1)));
Add_Action (Table.States (342), 83, 381);
Add_Action (Table.States (342), 96, 518);
Add_Error (Table.States (342));
Table.States (342).Kernel := To_Vector (((238, 238, 2, True), (332, 238, 1, False)));
Table.States (342).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 518)));
Add_Action (Table.States (343), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (343), 26, 385);
Add_Action (Table.States (343), 40, 386);
Add_Action (Table.States (343), 104, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (343), 105, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (343), 106, Reduce, (241, 1), 0, null, null);
Add_Error (Table.States (343));
Add_Goto (Table.States (343), 114, 387);
Add_Goto (Table.States (343), 241, 388);
Table.States (343).Kernel := To_Vector (((245, 81, 4, False), (245, 81, 5, False), (245, 81, 4, False)));
Table.States (343).Minimal_Complete_Actions := To_Vector (((Reduce, 241, 0), (Shift, 26, 385)));
Add_Action (Table.States (344), (21, 35, 56, 72, 74, 77, 82, 96), (253, 0), 1, null, null);
Table.States (344).Kernel := To_Vector ((0 => (253, 199, 0, False)));
Table.States (344).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 1)));
Add_Action (Table.States (345), (35, 56, 74, 96), (262, 0), 3, procedure_specification_0'Access,
procedure_specification_0_check'Access);
Table.States (345).Kernel := To_Vector ((0 => (262, 253, 0, False)));
Table.States (345).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 262, 3)));
Add_Action (Table.States (346), 35, 519);
Add_Conflict (Table.States (346), 35, (122, 1), 0, null, null);
Add_Action (Table.States (346), 74, 337);
Add_Error (Table.States (346));
Add_Goto (Table.States (346), 122, 520);
Table.States (346).Kernel := To_Vector (((264, 104, 3, False), (265, 104, 3, False)));
Table.States (346).Minimal_Complete_Actions := To_Vector (((Reduce, 122, 0), (Shift, 35, 519)));
Add_Action (Table.States (347), 35, Reduce, (169, 2), 0, null, null);
Add_Action (Table.States (347), 74, Reduce, (169, 2), 0, null, null);
Add_Action (Table.States (347), 76, 377);
Add_Error (Table.States (347));
Add_Goto (Table.States (347), 169, 521);
Table.States (347).Kernel := To_Vector (((271, 104, 6, False), (271, 104, 3, False)));
Table.States (347).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 169, 0)));
Add_Action (Table.States (348), 35, 522);
Add_Error (Table.States (348));
Table.States (348).Kernel := To_Vector (((304, 122, 6, False), (304, 122, 3, False)));
Table.States (348).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 522)));
Add_Action (Table.States (349), 3, 121);
Add_Action (Table.States (349), 39, 122);
Add_Action (Table.States (349), 40, 123);
Add_Action (Table.States (349), 41, 124);
Add_Action (Table.States (349), 52, 125);
Add_Action (Table.States (349), 76, 126);
Add_Action (Table.States (349), 94, 127);
Add_Action (Table.States (349), 95, 128);
Add_Action (Table.States (349), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (349), 103, 129);
Add_Action (Table.States (349), 104, 119);
Add_Action (Table.States (349), 105, 33);
Add_Action (Table.States (349), 106, 34);
Add_Error (Table.States (349));
Add_Goto (Table.States (349), 117, 130);
Add_Goto (Table.States (349), 128, 41);
Add_Goto (Table.States (349), 191, 131);
Add_Goto (Table.States (349), 192, 523);
Add_Goto (Table.States (349), 197, 133);
Add_Goto (Table.States (349), 239, 134);
Add_Goto (Table.States (349), 258, 135);
Add_Goto (Table.States (349), 272, 92);
Add_Goto (Table.States (349), 275, 136);
Add_Goto (Table.States (349), 282, 137);
Add_Goto (Table.States (349), 283, 138);
Add_Goto (Table.States (349), 284, 139);
Add_Goto (Table.States (349), 285, 140);
Add_Goto (Table.States (349), 286, 141);
Add_Goto (Table.States (349), 287, 142);
Add_Goto (Table.States (349), 293, 97);
Add_Goto (Table.States (349), 301, 143);
Add_Goto (Table.States (349), 320, 144);
Add_Goto (Table.States (349), 321, 145);
Add_Goto (Table.States (349), 330, 146);
Table.States (349).Kernel := To_Vector ((0 => (276, 74, 1, False)));
Table.States (349).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (350), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (276, 1), 3, raise_statement_1'Access, null);
Table.States (350).Kernel := To_Vector ((0 => (276, 96, 0, False)));
Table.States (350).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 276, 3)));
Add_Action (Table.States (351), 5, 524);
Add_Error (Table.States (351));
Table.States (351).Kernel := To_Vector ((0 => (290, 74, 2, False)));
Table.States (351).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 5, 524)));
Add_Action (Table.States (352), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (290, 1), 3, requeue_statement_1'Access, null);
Table.States (352).Kernel := To_Vector ((0 => (290, 96, 0, False)));
Table.States (352).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 290, 3)));
Add_Action (Table.States (353), 7, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 8, 401);
Add_Action (Table.States (353), 16, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 21, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 40, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 82, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 96, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 104, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 105, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (353), 106, Reduce, (118, 1), 0, null, null);
Add_Error (Table.States (353));
Add_Goto (Table.States (353), 118, 525);
Table.States (353).Kernel := To_Vector (((194, 81, 2, False), (194, 81, 1, False)));
Table.States (353).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 118, 0)));
Add_Action (Table.States (354), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (302, 0), 3, simple_return_statement_0'Access, null);
Table.States (354).Kernel := To_Vector ((0 => (302, 96, 0, False)));
Table.States (354).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 302, 3)));
Add_Action (Table.States (355), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (196, 1), 3, extended_return_statement_1'Access, null);
Table.States (355).Kernel := To_Vector ((0 => (196, 96, 0, False)));
Table.States (355).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 196, 3)));
Add_Action (Table.States (356), 4, 1);
Add_Action (Table.States (356), 5, 2);
Add_Action (Table.States (356), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (356), 15, 3);
Add_Action (Table.States (356), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (356), 18, 4);
Add_Action (Table.States (356), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (356), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (356), 27, 5);
Add_Action (Table.States (356), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (356), 31, 9);
Add_Action (Table.States (356), 32, 10);
Add_Action (Table.States (356), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (356), 41, 13);
Add_Action (Table.States (356), 48, 16);
Add_Action (Table.States (356), 52, 20);
Add_Action (Table.States (356), 57, 21);
Add_Action (Table.States (356), 58, 22);
Add_Action (Table.States (356), 61, 24);
Add_Action (Table.States (356), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (356), 93, 31);
Add_Action (Table.States (356), 104, 360);
Add_Action (Table.States (356), 105, 33);
Add_Action (Table.States (356), 106, 34);
Add_Error (Table.States (356));
Add_Goto (Table.States (356), 113, 36);
Add_Goto (Table.States (356), 123, 38);
Add_Goto (Table.States (356), 126, 39);
Add_Goto (Table.States (356), 128, 41);
Add_Goto (Table.States (356), 131, 42);
Add_Goto (Table.States (356), 132, 43);
Add_Goto (Table.States (356), 133, 44);
Add_Goto (Table.States (356), 139, 47);
Add_Goto (Table.States (356), 151, 50);
Add_Goto (Table.States (356), 152, 51);
Add_Goto (Table.States (356), 161, 53);
Add_Goto (Table.States (356), 190, 57);
Add_Goto (Table.States (356), 196, 59);
Add_Goto (Table.States (356), 217, 68);
Add_Goto (Table.States (356), 218, 526);
Add_Goto (Table.States (356), 222, 70);
Add_Goto (Table.States (356), 232, 72);
Add_Goto (Table.States (356), 239, 73);
Add_Goto (Table.States (356), 257, 83);
Add_Goto (Table.States (356), 261, 86);
Add_Goto (Table.States (356), 272, 92);
Add_Goto (Table.States (356), 276, 93);
Add_Goto (Table.States (356), 290, 96);
Add_Goto (Table.States (356), 293, 97);
Add_Goto (Table.States (356), 294, 98);
Add_Goto (Table.States (356), 298, 99);
Add_Goto (Table.States (356), 299, 361);
Add_Goto (Table.States (356), 300, 390);
Add_Goto (Table.States (356), 302, 100);
Add_Goto (Table.States (356), 303, 101);
Add_Goto (Table.States (356), 306, 363);
Add_Goto (Table.States (356), 323, 114);
Table.States (356).Kernel := To_Vector ((0 => (196, 21, 3, False)));
Table.States (356).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (357), 76, 235);
Add_Action (Table.States (357), 77, 527);
Add_Action (Table.States (357), 84, 237);
Add_Action (Table.States (357), 101, 239);
Add_Action (Table.States (357), 102, 240);
Add_Error (Table.States (357));
Add_Goto (Table.States (357), 115, 241);
Add_Goto (Table.States (357), 322, 242);
Table.States (357).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(315, 239, 7, False)));
Table.States (357).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 527)));
Add_Action (Table.States (358), (22, 24, 43), (295, 4), 2, select_alternative_4'Access, null);
Table.States (358).Kernel := To_Vector ((0 => (295, 96, 0, False)));
Table.States (358).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 295, 2)));
Add_Action (Table.States (359), 87, 528);
Add_Error (Table.States (359));
Table.States (359).Kernel := To_Vector (((295, 192, 4, False), (295, 192, 3, False), (295, 192, 3,
False)));
Table.States (359).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 528)));
Add_Action (Table.States (360), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (360), 81, 529);
Add_Action (Table.States (360), 82, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (360), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (360), 96, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (360), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (360), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (360));
Table.States (360).Kernel := To_Vector (((131, 104, 1, False), (239, 104, 0, False)));
Table.States (360).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Add_Action (Table.States (361), 4, 1);
Add_Action (Table.States (361), 5, 2);
Add_Action (Table.States (361), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (361), 15, 3);
Add_Action (Table.States (361), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (361), 18, 4);
Add_Action (Table.States (361), 22, Reduce, (300, 0), 1, null, null);
Add_Action (Table.States (361), 23, Reduce, (300, 0), 1, null, null);
Add_Action (Table.States (361), 24, Reduce, (300, 0), 1, null, null);
Add_Action (Table.States (361), 26, Reduce, (300, 0), 1, null, null);
Add_Action (Table.States (361), 27, 5);
Add_Action (Table.States (361), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (361), 31, 9);
Add_Action (Table.States (361), 32, 10);
Add_Action (Table.States (361), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (361), 41, 13);
Add_Action (Table.States (361), 43, Reduce, (300, 0), 1, null, null);
Add_Action (Table.States (361), 48, 16);
Add_Action (Table.States (361), 52, 20);
Add_Action (Table.States (361), 57, 21);
Add_Action (Table.States (361), 58, 22);
Add_Action (Table.States (361), 61, 24);
Add_Action (Table.States (361), 68, Reduce, (300, 0), 1, null, null);
Add_Action (Table.States (361), 72, Reduce, (300, 0), 1, null, null);
Add_Action (Table.States (361), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (361), 93, 31);
Add_Action (Table.States (361), 104, 360);
Add_Action (Table.States (361), 105, 33);
Add_Action (Table.States (361), 106, 34);
Add_Error (Table.States (361));
Add_Goto (Table.States (361), 113, 36);
Add_Goto (Table.States (361), 123, 38);
Add_Goto (Table.States (361), 126, 39);
Add_Goto (Table.States (361), 128, 41);
Add_Goto (Table.States (361), 131, 42);
Add_Goto (Table.States (361), 132, 43);
Add_Goto (Table.States (361), 133, 44);
Add_Goto (Table.States (361), 139, 47);
Add_Goto (Table.States (361), 151, 50);
Add_Goto (Table.States (361), 152, 51);
Add_Goto (Table.States (361), 161, 53);
Add_Goto (Table.States (361), 190, 57);
Add_Goto (Table.States (361), 196, 59);
Add_Goto (Table.States (361), 217, 68);
Add_Goto (Table.States (361), 222, 70);
Add_Goto (Table.States (361), 232, 72);
Add_Goto (Table.States (361), 239, 73);
Add_Goto (Table.States (361), 257, 83);
Add_Goto (Table.States (361), 261, 86);
Add_Goto (Table.States (361), 272, 92);
Add_Goto (Table.States (361), 276, 93);
Add_Goto (Table.States (361), 290, 96);
Add_Goto (Table.States (361), 293, 97);
Add_Goto (Table.States (361), 294, 98);
Add_Goto (Table.States (361), 298, 99);
Add_Goto (Table.States (361), 302, 100);
Add_Goto (Table.States (361), 303, 101);
Add_Goto (Table.States (361), 306, 530);
Add_Goto (Table.States (361), 323, 114);
Table.States (361).Kernel := To_Vector (((299, 299, 2, True), (300, 299, 0, False)));
Table.States (361).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 1)));
Add_Action (Table.States (362), (22, 24, 43), (295, 3), 2, null, null);
Table.States (362).Kernel := To_Vector ((0 => (295, 300, 0, False)));
Table.States (362).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 295, 2)));
Add_Action (Table.States (363), (4, 5, 13, 15, 17, 18, 22, 23, 24, 26, 27, 28, 31, 32, 37, 41, 43, 48, 52,
57, 58, 61, 68, 72, 73, 93, 104, 105, 106), (299, 1), 1, null, null);
Table.States (363).Kernel := To_Vector ((0 => (299, 306, 0, False)));
Table.States (363).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 299, 1)));
Add_Action (Table.States (364), 22, Reduce, (160, 0), 2, null, null);
Add_Action (Table.States (364), 24, Reduce, (160, 0), 2, null, null);
Add_Action (Table.States (364), 43, Reduce, (160, 0), 2, null, null);
Add_Action (Table.States (364), 68, Reduce, (324, 2), 2, null, null);
Add_Error (Table.States (364));
Table.States (364).Kernel := To_Vector (((160, 300, 0, False), (324, 300, 0, False)));
Table.States (364).Minimal_Complete_Actions := To_Vector (((Reduce, 160, 2), (Reduce, 324, 2)));
Add_Action (Table.States (365), 4, 1);
Add_Action (Table.States (365), 5, 2);
Add_Action (Table.States (365), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (365), 15, 3);
Add_Action (Table.States (365), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (365), 18, 4);
Add_Action (Table.States (365), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (365), 27, 5);
Add_Action (Table.States (365), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (365), 31, 9);
Add_Action (Table.States (365), 32, 10);
Add_Action (Table.States (365), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (365), 41, 13);
Add_Action (Table.States (365), 48, 16);
Add_Action (Table.States (365), 52, 20);
Add_Action (Table.States (365), 57, 21);
Add_Action (Table.States (365), 58, 22);
Add_Action (Table.States (365), 61, 24);
Add_Action (Table.States (365), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (365), 93, 31);
Add_Action (Table.States (365), 104, 360);
Add_Action (Table.States (365), 105, 33);
Add_Action (Table.States (365), 106, 34);
Add_Error (Table.States (365));
Add_Goto (Table.States (365), 113, 36);
Add_Goto (Table.States (365), 123, 38);
Add_Goto (Table.States (365), 126, 39);
Add_Goto (Table.States (365), 128, 41);
Add_Goto (Table.States (365), 131, 42);
Add_Goto (Table.States (365), 132, 43);
Add_Goto (Table.States (365), 133, 44);
Add_Goto (Table.States (365), 139, 47);
Add_Goto (Table.States (365), 151, 50);
Add_Goto (Table.States (365), 152, 51);
Add_Goto (Table.States (365), 161, 53);
Add_Goto (Table.States (365), 190, 57);
Add_Goto (Table.States (365), 196, 59);
Add_Goto (Table.States (365), 217, 68);
Add_Goto (Table.States (365), 222, 70);
Add_Goto (Table.States (365), 232, 72);
Add_Goto (Table.States (365), 239, 73);
Add_Goto (Table.States (365), 257, 83);
Add_Goto (Table.States (365), 261, 86);
Add_Goto (Table.States (365), 272, 92);
Add_Goto (Table.States (365), 276, 93);
Add_Goto (Table.States (365), 290, 96);
Add_Goto (Table.States (365), 293, 97);
Add_Goto (Table.States (365), 294, 98);
Add_Goto (Table.States (365), 298, 99);
Add_Goto (Table.States (365), 299, 361);
Add_Goto (Table.States (365), 300, 531);
Add_Goto (Table.States (365), 302, 100);
Add_Goto (Table.States (365), 303, 101);
Add_Goto (Table.States (365), 306, 363);
Add_Goto (Table.States (365), 323, 114);
Table.States (365).Kernel := To_Vector ((0 => (152, 22, 3, False)));
Table.States (365).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (366), 18, 4);
Add_Error (Table.States (366));
Add_Goto (Table.States (366), 160, 532);
Add_Goto (Table.States (366), 161, 533);
Table.States (366).Kernel := To_Vector ((0 => (323, 43, 5, False)));
Table.States (366).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 18, 4)));
Add_Action (Table.States (367), 22, Reduce, (178, 1), 2, null, null);
Add_Action (Table.States (367), 43, Reduce, (178, 1), 2, null, null);
Add_Action (Table.States (367), 68, Reduce, (324, 1), 2, null, null);
Add_Error (Table.States (367));
Table.States (367).Kernel := To_Vector (((178, 300, 0, False), (324, 300, 0, False)));
Table.States (367).Minimal_Complete_Actions := To_Vector (((Reduce, 178, 2), (Reduce, 324, 2)));
Add_Action (Table.States (368), 22, Reduce, (178, 0), 2, null, null);
Add_Action (Table.States (368), 43, Reduce, (178, 0), 2, null, null);
Add_Action (Table.States (368), 68, Reduce, (324, 0), 2, null, null);
Add_Error (Table.States (368));
Table.States (368).Kernel := To_Vector (((178, 300, 0, False), (324, 300, 0, False)));
Table.States (368).Minimal_Complete_Actions := To_Vector (((Reduce, 178, 2), (Reduce, 324, 2)));
Add_Action (Table.States (369), 4, 1);
Add_Action (Table.States (369), 18, 4);
Add_Action (Table.States (369), 67, 199);
Add_Action (Table.States (369), 72, 200);
Add_Error (Table.States (369));
Add_Goto (Table.States (369), 113, 201);
Add_Goto (Table.States (369), 160, 202);
Add_Goto (Table.States (369), 161, 533);
Add_Goto (Table.States (369), 295, 534);
Table.States (369).Kernel := To_Vector ((0 => (296, 43, 2, True)));
Table.States (369).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 67, 199)));
Table.States (369).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (370), 4, 1);
Add_Action (Table.States (370), 5, 2);
Add_Action (Table.States (370), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (370), 15, 3);
Add_Action (Table.States (370), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (370), 18, 4);
Add_Action (Table.States (370), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (370), 27, 5);
Add_Action (Table.States (370), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (370), 31, 9);
Add_Action (Table.States (370), 32, 10);
Add_Action (Table.States (370), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (370), 41, 13);
Add_Action (Table.States (370), 48, 16);
Add_Action (Table.States (370), 52, 20);
Add_Action (Table.States (370), 57, 21);
Add_Action (Table.States (370), 58, 22);
Add_Action (Table.States (370), 61, 24);
Add_Action (Table.States (370), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (370), 93, 31);
Add_Action (Table.States (370), 104, 360);
Add_Action (Table.States (370), 105, 33);
Add_Action (Table.States (370), 106, 34);
Add_Error (Table.States (370));
Add_Goto (Table.States (370), 113, 36);
Add_Goto (Table.States (370), 123, 38);
Add_Goto (Table.States (370), 126, 39);
Add_Goto (Table.States (370), 128, 41);
Add_Goto (Table.States (370), 131, 42);
Add_Goto (Table.States (370), 132, 43);
Add_Goto (Table.States (370), 133, 44);
Add_Goto (Table.States (370), 139, 47);
Add_Goto (Table.States (370), 151, 50);
Add_Goto (Table.States (370), 152, 51);
Add_Goto (Table.States (370), 161, 53);
Add_Goto (Table.States (370), 190, 57);
Add_Goto (Table.States (370), 196, 59);
Add_Goto (Table.States (370), 217, 68);
Add_Goto (Table.States (370), 222, 70);
Add_Goto (Table.States (370), 232, 72);
Add_Goto (Table.States (370), 239, 73);
Add_Goto (Table.States (370), 257, 83);
Add_Goto (Table.States (370), 261, 86);
Add_Goto (Table.States (370), 272, 92);
Add_Goto (Table.States (370), 276, 93);
Add_Goto (Table.States (370), 290, 96);
Add_Goto (Table.States (370), 293, 97);
Add_Goto (Table.States (370), 294, 98);
Add_Goto (Table.States (370), 298, 99);
Add_Goto (Table.States (370), 299, 361);
Add_Goto (Table.States (370), 300, 535);
Add_Goto (Table.States (370), 302, 100);
Add_Goto (Table.States (370), 303, 101);
Add_Goto (Table.States (370), 306, 363);
Add_Goto (Table.States (370), 323, 114);
Table.States (370).Kernel := To_Vector ((0 => (294, 22, 3, False)));
Table.States (370).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (371), 61, 536);
Add_Error (Table.States (371));
Table.States (371).Kernel := To_Vector ((0 => (294, 24, 2, False)));
Table.States (371).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 61, 536)));
Add_Action (Table.States (372), 5, 537);
Add_Error (Table.States (372));
Table.States (372).Kernel := To_Vector ((0 => (126, 68, 4, False)));
Table.States (372).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 5, 537)));
Add_Action (Table.States (373), 40, 483);
Add_Action (Table.States (373), 104, 119);
Add_Action (Table.States (373), 105, 33);
Add_Action (Table.States (373), 106, 34);
Add_Error (Table.States (373));
Add_Goto (Table.States (373), 128, 41);
Add_Goto (Table.States (373), 239, 484);
Add_Goto (Table.States (373), 272, 92);
Add_Goto (Table.States (373), 293, 97);
Add_Goto (Table.States (373), 314, 538);
Table.States (373).Kernel := To_Vector ((0 => (313, 35, 2, False)));
Table.States (373).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (374), 35, 539);
Add_Conflict (Table.States (374), 35, (122, 1), 0, null, null);
Add_Action (Table.States (374), 74, 337);
Add_Error (Table.States (374));
Add_Goto (Table.States (374), 122, 540);
Table.States (374).Kernel := To_Vector (((316, 104, 4, False), (317, 104, 3, False)));
Table.States (374).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 539)));
Add_Action (Table.States (375), 35, Reduce, (169, 2), 0, null, null);
Add_Action (Table.States (375), 74, Reduce, (169, 2), 0, null, null);
Add_Action (Table.States (375), 76, 377);
Add_Action (Table.States (375), 96, Reduce, (169, 2), 0, null, null);
Add_Error (Table.States (375));
Add_Goto (Table.States (375), 169, 541);
Table.States (375).Kernel := To_Vector (((319, 104, 6, False), (319, 104, 3, False), (319, 104, 1,
False)));
Table.States (375).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 169, 0)));
Add_Action (Table.States (376), 35, 542);
Add_Action (Table.States (376), 96, 543);
Add_Error (Table.States (376));
Table.States (376).Kernel := To_Vector (((305, 122, 6, False), (305, 122, 3, False), (305, 122, 1,
False)));
Table.States (376).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 543)));
Add_Action (Table.States (377), 77, Reduce, (170, 4), 0, null, null);
Add_Action (Table.States (377), 80, 544);
Add_Action (Table.States (377), 96, Reduce, (170, 4), 0, null, null);
Add_Action (Table.States (377), 104, 164);
Add_Error (Table.States (377));
Add_Goto (Table.States (377), 170, 545);
Add_Goto (Table.States (377), 171, 546);
Add_Goto (Table.States (377), 219, 547);
Table.States (377).Kernel := To_Vector (((169, 76, 2, False), (169, 76, 1, False)));
Table.States (377).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 171, 0)));
Add_Action (Table.States (378), 35, 548);
Add_Action (Table.States (378), 96, 549);
Add_Error (Table.States (378));
Table.States (378).Kernel := To_Vector (((206, 169, 3, False), (223, 169, 3, False), (223, 169, 1, False),
(259, 169, 6, False), (260, 169, 3, False)));
Table.States (378).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 549)));
Add_Action (Table.States (379), 104, 119);
Add_Action (Table.States (379), 105, 33);
Add_Action (Table.States (379), 106, 34);
Add_Error (Table.States (379));
Add_Goto (Table.States (379), 128, 41);
Add_Goto (Table.States (379), 238, 550);
Add_Goto (Table.States (379), 239, 219);
Add_Goto (Table.States (379), 272, 92);
Add_Goto (Table.States (379), 293, 97);
Table.States (379).Kernel := To_Vector ((0 => (331, 69, 2, False)));
Table.States (379).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (380), 83, 381);
Add_Action (Table.States (380), 96, 551);
Add_Error (Table.States (380));
Table.States (380).Kernel := To_Vector (((238, 238, 2, True), (331, 238, 1, False)));
Table.States (380).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 551)));
Add_Action (Table.States (381), 104, 119);
Add_Action (Table.States (381), 105, 33);
Add_Action (Table.States (381), 106, 34);
Add_Error (Table.States (381));
Add_Goto (Table.States (381), 128, 41);
Add_Goto (Table.States (381), 239, 552);
Add_Goto (Table.States (381), 272, 92);
Add_Goto (Table.States (381), 293, 97);
Table.States (381).Kernel := To_Vector ((0 => (238, 83, 1, True)));
Table.States (381).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Table.States (381).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (382), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (331, 2), 3,
use_clause_2'Access, null);
Table.States (382).Kernel := To_Vector ((0 => (331, 96, 0, False)));
Table.States (382).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 331, 3)));
Add_Action (Table.States (383), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (332, 3), 3,
with_clause_3'Access, null);
Table.States (383).Kernel := To_Vector ((0 => (332, 96, 0, False)));
Table.States (383).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 332, 3)));
Add_Action (Table.States (384), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (217, 0), 3, goto_label_0'Access, null);
Table.States (384).Kernel := To_Vector ((0 => (217, 90, 0, False)));
Table.States (384).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 217, 3)));
Add_Action (Table.States (385), 56, 553);
Add_Error (Table.States (385));
Table.States (385).Kernel := To_Vector ((0 => (245, 26, 3, False)));
Table.States (385).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 56, 553)));
Add_Action (Table.States (386), 41, 554);
Add_Error (Table.States (386));
Table.States (386).Kernel := To_Vector ((0 => (241, 40, 1, False)));
Table.States (386).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 41, 554)));
Add_Action (Table.States (387), 56, 555);
Add_Error (Table.States (387));
Table.States (387).Kernel := To_Vector ((0 => (245, 114, 3, False)));
Table.States (387).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 56, 555)));
Add_Action (Table.States (388), 7, 556);
Add_Action (Table.States (388), 104, 119);
Add_Action (Table.States (388), 105, 33);
Add_Action (Table.States (388), 106, 34);
Add_Error (Table.States (388));
Add_Goto (Table.States (388), 128, 41);
Add_Goto (Table.States (388), 239, 557);
Add_Goto (Table.States (388), 272, 92);
Add_Goto (Table.States (388), 293, 97);
Table.States (388).Kernel := To_Vector (((114, 241, 2, False), (114, 241, 3, True), (114, 241, 2, False),
(245, 241, 4, False)));
Table.States (388).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 7, 556)));
Add_Action (Table.States (389), 24, 558);
Add_Error (Table.States (389));
Table.States (389).Kernel := To_Vector ((0 => (133, 218, 2, False)));
Table.States (389).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 558)));
Add_Action (Table.States (390), 24, Reduce, (218, 1), 1, null, null);
Add_Action (Table.States (390), 26, 559);
Add_Error (Table.States (390));
Table.States (390).Kernel := To_Vector (((218, 300, 1, False), (218, 300, 0, False)));
Table.States (390).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 1)));
Add_Action (Table.States (391), (13, 24, 25, 28, 29, 30, 40, 46, 47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
(158, 2), 1, null, null);
Table.States (391).Kernel := To_Vector ((0 => (158, 157, 0, False)));
Table.States (391).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 158, 1)));
Add_Action (Table.States (392), 13, Reduce, (159, 0), 1, null, null);
Add_Action (Table.States (392), 24, Reduce, (159, 0), 1, null, null);
Add_Action (Table.States (392), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (392), 28, 183);
Add_Action (Table.States (392), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (392), 30, 8);
Add_Action (Table.States (392), 40, 12);
Add_Action (Table.States (392), 46, 14);
Add_Action (Table.States (392), 47, 15);
Add_Action (Table.States (392), 48, 16);
Add_Action (Table.States (392), 49, Reduce, (159, 0), 1, null, null);
Add_Action (Table.States (392), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (392), 51, 19);
Add_Action (Table.States (392), 63, 25);
Add_Action (Table.States (392), 66, 26);
Add_Action (Table.States (392), 69, 27);
Add_Action (Table.States (392), 71, 28);
Add_Action (Table.States (392), 104, 185);
Add_Error (Table.States (392));
Add_Goto (Table.States (392), 112, 35);
Add_Goto (Table.States (392), 121, 37);
Add_Goto (Table.States (392), 127, 40);
Add_Goto (Table.States (392), 134, 45);
Add_Goto (Table.States (392), 135, 46);
Add_Goto (Table.States (392), 157, 560);
Add_Goto (Table.States (392), 179, 54);
Add_Goto (Table.States (392), 182, 55);
Add_Goto (Table.States (392), 186, 56);
Add_Goto (Table.States (392), 193, 58);
Add_Goto (Table.States (392), 206, 60);
Add_Goto (Table.States (392), 207, 61);
Add_Goto (Table.States (392), 209, 62);
Add_Goto (Table.States (392), 210, 63);
Add_Goto (Table.States (392), 213, 64);
Add_Goto (Table.States (392), 214, 65);
Add_Goto (Table.States (392), 215, 66);
Add_Goto (Table.States (392), 216, 67);
Add_Goto (Table.States (392), 219, 69);
Add_Goto (Table.States (392), 223, 71);
Add_Goto (Table.States (392), 243, 74);
Add_Goto (Table.States (392), 244, 75);
Add_Goto (Table.States (392), 245, 76);
Add_Goto (Table.States (392), 246, 77);
Add_Goto (Table.States (392), 247, 78);
Add_Goto (Table.States (392), 248, 79);
Add_Goto (Table.States (392), 249, 80);
Add_Goto (Table.States (392), 250, 81);
Add_Goto (Table.States (392), 251, 82);
Add_Goto (Table.States (392), 257, 561);
Add_Goto (Table.States (392), 259, 84);
Add_Goto (Table.States (392), 260, 85);
Add_Goto (Table.States (392), 262, 87);
Add_Goto (Table.States (392), 263, 88);
Add_Goto (Table.States (392), 264, 89);
Add_Goto (Table.States (392), 265, 90);
Add_Goto (Table.States (392), 271, 91);
Add_Goto (Table.States (392), 281, 94);
Add_Goto (Table.States (392), 289, 95);
Add_Goto (Table.States (392), 304, 102);
Add_Goto (Table.States (392), 305, 103);
Add_Goto (Table.States (392), 307, 105);
Add_Goto (Table.States (392), 308, 106);
Add_Goto (Table.States (392), 309, 107);
Add_Goto (Table.States (392), 311, 108);
Add_Goto (Table.States (392), 313, 109);
Add_Goto (Table.States (392), 316, 111);
Add_Goto (Table.States (392), 317, 112);
Add_Goto (Table.States (392), 319, 113);
Add_Goto (Table.States (392), 325, 115);
Add_Goto (Table.States (392), 331, 116);
Table.States (392).Kernel := To_Vector (((158, 158, 3, True), (158, 158, 3, True), (159, 158, 0, False)));
Table.States (392).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 1)));
end Subr_7;
procedure Subr_8
is begin
Add_Action (Table.States (393), 13, 562);
Add_Error (Table.States (393));
Table.States (393).Kernel := To_Vector ((0 => (133, 159, 3, False)));
Table.States (393).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 562)));
Add_Action (Table.States (394), (13, 24, 25, 28, 29, 30, 40, 46, 47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
(158, 3), 1, null, null);
Table.States (394).Kernel := To_Vector ((0 => (158, 257, 0, False)));
Table.States (394).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 158, 1)));
Add_Action (Table.States (395), 33, 311);
Add_Action (Table.States (395), 42, 312);
Add_Action (Table.States (395), 81, 313);
Add_Error (Table.States (395));
Table.States (395).Kernel := To_Vector (((230, 104, 5, False), (230, 104, 4, False), (230, 104, 3, False),
(230, 104, 3, False), (230, 104, 2, False), (230, 104, 2, False)));
Table.States (395).Minimal_Complete_Actions := To_Vector (((Shift, 42, 312), (Shift, 33, 311)));
Add_Action (Table.States (396), 24, 563);
Add_Error (Table.States (396));
Table.States (396).Kernel := To_Vector ((0 => (232, 300, 3, False)));
Table.States (396).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 563)));
Add_Action (Table.States (397), 4, 1);
Add_Action (Table.States (397), 5, 2);
Add_Action (Table.States (397), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (397), 15, 3);
Add_Action (Table.States (397), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (397), 18, 4);
Add_Action (Table.States (397), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (397), 27, 5);
Add_Action (Table.States (397), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (397), 31, 9);
Add_Action (Table.States (397), 32, 10);
Add_Action (Table.States (397), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (397), 41, 13);
Add_Action (Table.States (397), 48, 16);
Add_Action (Table.States (397), 52, 20);
Add_Action (Table.States (397), 57, 21);
Add_Action (Table.States (397), 58, 22);
Add_Action (Table.States (397), 61, 24);
Add_Action (Table.States (397), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (397), 93, 31);
Add_Action (Table.States (397), 104, 360);
Add_Action (Table.States (397), 105, 33);
Add_Action (Table.States (397), 106, 34);
Add_Error (Table.States (397));
Add_Goto (Table.States (397), 113, 36);
Add_Goto (Table.States (397), 123, 38);
Add_Goto (Table.States (397), 126, 39);
Add_Goto (Table.States (397), 128, 41);
Add_Goto (Table.States (397), 131, 42);
Add_Goto (Table.States (397), 132, 43);
Add_Goto (Table.States (397), 133, 44);
Add_Goto (Table.States (397), 139, 47);
Add_Goto (Table.States (397), 151, 50);
Add_Goto (Table.States (397), 152, 51);
Add_Goto (Table.States (397), 161, 53);
Add_Goto (Table.States (397), 190, 57);
Add_Goto (Table.States (397), 196, 59);
Add_Goto (Table.States (397), 217, 68);
Add_Goto (Table.States (397), 222, 70);
Add_Goto (Table.States (397), 232, 72);
Add_Goto (Table.States (397), 239, 73);
Add_Goto (Table.States (397), 257, 83);
Add_Goto (Table.States (397), 261, 86);
Add_Goto (Table.States (397), 272, 92);
Add_Goto (Table.States (397), 276, 93);
Add_Goto (Table.States (397), 290, 96);
Add_Goto (Table.States (397), 293, 97);
Add_Goto (Table.States (397), 294, 98);
Add_Goto (Table.States (397), 298, 99);
Add_Goto (Table.States (397), 299, 361);
Add_Goto (Table.States (397), 300, 564);
Add_Goto (Table.States (397), 302, 100);
Add_Goto (Table.States (397), 303, 101);
Add_Goto (Table.States (397), 306, 363);
Add_Goto (Table.States (397), 323, 114);
Table.States (397).Kernel := To_Vector ((0 => (232, 37, 3, False)));
Table.States (397).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (398), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (398), 74, 337);
Add_Action (Table.States (398), 76, 235);
Add_Action (Table.States (398), 84, 237);
Add_Action (Table.States (398), 101, 239);
Add_Action (Table.States (398), 102, 240);
Add_Error (Table.States (398));
Add_Goto (Table.States (398), 115, 241);
Add_Goto (Table.States (398), 122, 338);
Add_Goto (Table.States (398), 322, 242);
Table.States (398).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(251, 239, 3, False), (251, 239, 2, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (398).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (399), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (214, 0), 3,
generic_package_declaration_0'Access, null);
Table.States (399).Kernel := To_Vector ((0 => (214, 96, 0, False)));
Table.States (399).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 214, 3)));
Add_Action (Table.States (400), 96, 565);
Add_Error (Table.States (400));
Table.States (400).Kernel := To_Vector ((0 => (216, 122, 1, False)));
Table.States (400).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 565)));
Add_Action (Table.States (401), (7, 11, 16, 21, 33, 40, 45, 74, 77, 82, 96, 104, 105, 106), (118, 0), 1,
null, null);
Table.States (401).Kernel := To_Vector ((0 => (118, 8, 0, False)));
Table.States (401).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 118, 1)));
Add_Action (Table.States (402), 82, 566);
Add_Error (Table.States (402));
Table.States (402).Kernel := To_Vector ((0 => (157, 16, 2, False)));
Table.States (402).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 82, 566)));
Add_Action (Table.States (403), 96, 567);
Add_Error (Table.States (403));
Table.States (403).Kernel := To_Vector ((0 => (186, 26, 1, False)));
Table.States (403).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 567)));
Add_Action (Table.States (404), 7, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 11, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 16, 568);
Add_Action (Table.States (404), 40, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 74, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 82, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 96, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 104, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 105, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (404), 106, Reduce, (154, 1), 0, null, null);
Add_Error (Table.States (404));
Add_Goto (Table.States (404), 154, 569);
Table.States (404).Kernel := To_Vector (((244, 118, 3, False), (244, 118, 4, False), (244, 118, 10, False),
(244, 118, 2, False), (244, 118, 3, False), (244, 118, 9, False)));
Table.States (404).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 154, 0)));
Add_Action (Table.States (405), (81, 83), (219, 0), 3, identifier_list_0'Access, null);
Table.States (405).Kernel := To_Vector ((0 => (219, 104, 0, True)));
Table.States (405).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 219, 3)));
Table.States (405).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (406), 77, 570);
Add_Action (Table.States (406), 83, 443);
Add_Error (Table.States (406));
Table.States (406).Kernel := To_Vector (((115, 125, 1, False), (125, 125, 1, True)));
Table.States (406).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 570)));
Add_Action (Table.States (407), 77, 571);
Add_Error (Table.States (407));
Table.States (407).Kernel := To_Vector ((0 => (115, 153, 1, False)));
Table.States (407).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 571)));
Add_Action (Table.States (408), 35, Reduce, (124, 4), 1, association_opt_4'Access, null);
Add_Action (Table.States (408), 77, Reduce, (124, 4), 1, association_opt_4'Access, null);
Add_Action (Table.States (408), 79, Reduce, (165, 0), 1, null, null);
Add_Action (Table.States (408), 83, Reduce, (124, 4), 1, association_opt_4'Access, null);
Add_Action (Table.States (408), 87, Reduce, (165, 0), 1, null, null);
Add_Action (Table.States (408), 96, Reduce, (124, 4), 1, association_opt_4'Access, null);
Add_Error (Table.States (408));
Table.States (408).Kernel := To_Vector (((124, 191, 0, False), (165, 191, 0, False)));
Table.States (408).Minimal_Complete_Actions := To_Vector (((Reduce, 124, 1), (Reduce, 165, 1)));
Add_Action (Table.States (409), 77, Reduce, (278, 1), 1, null, null);
Add_Action (Table.States (409), 79, Reduce, (165, 2), 1, null, null);
Add_Action (Table.States (409), 83, Reduce, (278, 1), 1, null, null);
Add_Action (Table.States (409), 87, Reduce, (165, 2), 1, null, null);
Add_Error (Table.States (409));
Table.States (409).Kernel := To_Vector (((165, 277, 0, False), (278, 277, 0, False)));
Table.States (409).Minimal_Complete_Actions := To_Vector (((Reduce, 165, 1), (Reduce, 278, 1)));
Add_Action (Table.States (410), 77, 572);
Add_Action (Table.States (410), 83, 573);
Add_Error (Table.States (410));
Table.States (410).Kernel := To_Vector (((239, 278, 1, True), (278, 278, 4, True)));
Table.States (410).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 572)));
Table.States (410).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (411), 96, 574);
Add_Error (Table.States (411));
Table.States (411).Kernel := To_Vector ((0 => (123, 192, 1, False)));
Table.States (411).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 574)));
Add_Action (Table.States (412), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (293, 3), 3,
selected_component_3'Access, null);
Table.States (412).Kernel := To_Vector ((0 => (293, 9, 0, True)));
Table.States (412).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 293, 3)));
Table.States (412).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (413), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (293, 0), 3,
selected_component_0'Access, selected_component_0_check'Access);
Table.States (413).Kernel := To_Vector ((0 => (293, 104, 0, True)));
Table.States (413).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 293, 3)));
Table.States (413).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (414), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (293, 2), 3,
selected_component_2'Access, selected_component_2_check'Access);
Table.States (414).Kernel := To_Vector ((0 => (293, 105, 0, True)));
Table.States (414).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 293, 3)));
Table.States (414).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (415), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (293, 1), 3,
selected_component_1'Access, null);
Table.States (415).Kernel := To_Vector ((0 => (293, 106, 0, True)));
Table.States (415).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 293, 3)));
Table.States (415).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (416), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (129, 1), 1, null, null);
Table.States (416).Kernel := To_Vector ((0 => (129, 7, 0, False)));
Table.States (416).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 129, 1)));
Add_Action (Table.States (417), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (129, 2), 1, null, null);
Table.States (417).Kernel := To_Vector ((0 => (129, 19, 0, False)));
Table.States (417).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 129, 1)));
Add_Action (Table.States (418), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (129, 3), 1, null, null);
Table.States (418).Kernel := To_Vector ((0 => (129, 20, 0, False)));
Table.States (418).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 129, 1)));
Add_Action (Table.States (419), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (129, 4), 1, null, null);
Table.States (419).Kernel := To_Vector ((0 => (129, 38, 0, False)));
Table.States (419).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 129, 1)));
Add_Action (Table.States (420), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (272, 0), 3,
qualified_expression_0'Access, null);
Table.States (420).Kernel := To_Vector ((0 => (272, 117, 0, True)));
Table.States (420).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 272, 3)));
Table.States (420).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (421), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (128, 0), 3, null, null);
Table.States (421).Kernel := To_Vector ((0 => (128, 129, 0, True)));
Table.States (421).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 128, 3)));
Table.States (421).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (422), 4, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 5, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 10, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 13, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 15, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 17, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 18, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 20, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 21, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 22, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 23, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 27, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 28, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 31, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 32, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 33, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 35, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 37, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 38, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 40, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 41, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 42, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 43, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 48, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 52, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 53, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 55, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 56, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 57, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 58, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 61, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 68, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 71, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 73, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 74, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 75, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 76, 235);
Add_Conflict (Table.States (422), 76, (129, 0), 1, null, null);
Add_Action (Table.States (422), 77, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 78, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 79, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 82, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 83, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 84, 237);
Add_Conflict (Table.States (422), 84, (129, 0), 1, null, null);
Add_Action (Table.States (422), 85, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 86, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 87, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 88, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 89, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 91, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 92, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 93, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 94, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 95, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 96, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 97, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 98, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 99, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 100, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 101, 239);
Add_Conflict (Table.States (422), 101, (129, 0), 1, null, null);
Add_Action (Table.States (422), 102, 240);
Add_Conflict (Table.States (422), 102, (129, 0), 1, null, null);
Add_Action (Table.States (422), 104, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 105, Reduce, (129, 0), 1, null, null);
Add_Action (Table.States (422), 106, Reduce, (129, 0), 1, null, null);
Add_Error (Table.States (422));
Add_Goto (Table.States (422), 115, 241);
Add_Goto (Table.States (422), 322, 242);
Table.States (422).Kernel := To_Vector (((128, 239, 2, True), (129, 239, 0, True), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (422).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 129, 1)));
Table.States (422).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (423), 74, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (423), 76, 575);
Add_Action (Table.States (423), 96, Reduce, (253, 1), 0, null, null);
Add_Error (Table.States (423));
Add_Goto (Table.States (423), 199, 344);
Add_Goto (Table.States (423), 253, 576);
Table.States (423).Kernel := To_Vector (((179, 104, 4, False), (179, 104, 1, False)));
Table.States (423).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 0)));
Add_Action (Table.States (424), 35, 577);
Add_Action (Table.States (424), 58, 317);
Add_Action (Table.States (424), 76, 318);
Add_Action (Table.States (424), 84, 237);
Add_Action (Table.States (424), 101, 239);
Add_Action (Table.States (424), 102, 240);
Add_Error (Table.States (424));
Add_Goto (Table.States (424), 115, 241);
Add_Goto (Table.States (424), 199, 319);
Add_Goto (Table.States (424), 252, 320);
Add_Goto (Table.States (424), 291, 321);
Add_Goto (Table.States (424), 322, 242);
Table.States (424).Kernel := To_Vector (((128, 239, 2, True), (207, 239, 1, False), (213, 239, 4, False),
(239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (424).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 58, 317)));
Add_Action (Table.States (425), 35, 578);
Add_Conflict (Table.States (425), 35, (253, 1), 0, null, null);
Add_Action (Table.States (425), 56, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (425), 74, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (425), 76, 318);
Add_Action (Table.States (425), 84, 237);
Add_Action (Table.States (425), 96, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (425), 101, 239);
Add_Action (Table.States (425), 102, 240);
Add_Error (Table.States (425));
Add_Goto (Table.States (425), 115, 241);
Add_Goto (Table.States (425), 199, 344);
Add_Goto (Table.States (425), 253, 345);
Add_Goto (Table.States (425), 322, 242);
Table.States (425).Kernel := To_Vector (((128, 239, 2, True), (213, 239, 4, False), (239, 239, 5, True),
(239, 239, 2, True), (262, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (425).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 0)));
Add_Action (Table.States (426), 76, 579);
Add_Error (Table.States (426));
Add_Goto (Table.States (426), 256, 580);
Table.States (426).Kernel := To_Vector ((0 => (193, 35, 3, False)));
Table.States (426).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 76, 579)));
Add_Action (Table.States (427), 41, 581);
Add_Error (Table.States (427));
Table.States (427).Kernel := To_Vector ((0 => (243, 35, 2, False)));
Table.States (427).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 41, 581)));
Add_Action (Table.States (428), 6, 582);
Add_Action (Table.States (428), 60, 583);
Add_Error (Table.States (428));
Table.States (428).Kernel := To_Vector (((112, 35, 2, False), (308, 35, 2, False)));
Table.States (428).Minimal_Complete_Actions := To_Vector (((Shift, 6, 582), (Shift, 60, 583)));
Add_Action (Table.States (429), 104, 119);
Add_Action (Table.States (429), 105, 33);
Add_Action (Table.States (429), 106, 34);
Add_Error (Table.States (429));
Add_Goto (Table.States (429), 128, 41);
Add_Goto (Table.States (429), 239, 584);
Add_Goto (Table.States (429), 272, 92);
Add_Goto (Table.States (429), 293, 97);
Table.States (429).Kernel := To_Vector ((0 => (311, 56, 2, False)));
Table.States (429).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (430), 35, 585);
Add_Action (Table.States (430), 96, 586);
Add_Error (Table.States (430));
Table.States (430).Kernel := To_Vector (((307, 122, 4, False), (309, 122, 1, False)));
Table.States (430).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 586)));
Add_Action (Table.States (431), 77, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (431), 96, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (431), 104, 164);
Add_Error (Table.States (431));
Add_Goto (Table.States (431), 219, 493);
Add_Goto (Table.States (431), 254, 494);
Add_Goto (Table.States (431), 255, 495);
Table.States (431).Kernel := To_Vector ((0 => (199, 76, 1, False)));
Table.States (431).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 255, 0)));
Add_Action (Table.States (432), 21, 587);
Add_Action (Table.States (432), 96, 588);
Add_Error (Table.States (432));
Table.States (432).Kernel := To_Vector (((113, 253, 3, False), (113, 253, 1, False)));
Table.States (432).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 588)));
Add_Action (Table.States (433), 3, 121);
Add_Action (Table.States (433), 10, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 20, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 21, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 22, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 23, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 35, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 37, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 39, 122);
Add_Action (Table.States (433), 40, 123);
Add_Action (Table.States (433), 41, 124);
Add_Action (Table.States (433), 43, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 52, 125);
Add_Action (Table.States (433), 53, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 68, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 75, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 76, 126);
Add_Action (Table.States (433), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 79, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 83, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 87, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 94, 127);
Add_Action (Table.States (433), 95, 128);
Add_Action (Table.States (433), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (433), 103, 129);
Add_Action (Table.States (433), 104, 119);
Add_Action (Table.States (433), 105, 33);
Add_Action (Table.States (433), 106, 34);
Add_Error (Table.States (433));
Add_Goto (Table.States (433), 117, 130);
Add_Goto (Table.States (433), 128, 41);
Add_Goto (Table.States (433), 191, 131);
Add_Goto (Table.States (433), 192, 589);
Add_Goto (Table.States (433), 197, 133);
Add_Goto (Table.States (433), 239, 134);
Add_Goto (Table.States (433), 258, 135);
Add_Goto (Table.States (433), 272, 92);
Add_Goto (Table.States (433), 275, 136);
Add_Goto (Table.States (433), 282, 137);
Add_Goto (Table.States (433), 283, 138);
Add_Goto (Table.States (433), 284, 139);
Add_Goto (Table.States (433), 285, 140);
Add_Goto (Table.States (433), 286, 141);
Add_Goto (Table.States (433), 287, 142);
Add_Goto (Table.States (433), 293, 97);
Add_Goto (Table.States (433), 301, 143);
Add_Goto (Table.States (433), 320, 144);
Add_Goto (Table.States (433), 321, 145);
Add_Goto (Table.States (433), 330, 146);
Table.States (433).Kernel := To_Vector ((0 => (275, 74, 0, True)));
Table.States (433).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Table.States (433).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (434), 35, 590);
Add_Error (Table.States (434));
Table.States (434).Kernel := To_Vector ((0 => (136, 192, 3, False)));
Table.States (434).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 590)));
Add_Action (Table.States (435), (1 => 104), (274, 0), 1, null, null);
Table.States (435).Kernel := To_Vector ((0 => (274, 9, 0, False)));
Table.States (435).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 274, 1)));
Add_Action (Table.States (436), (1 => 104), (274, 1), 1, null, null);
Table.States (436).Kernel := To_Vector ((0 => (274, 62, 0, False)));
Table.States (436).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 274, 1)));
Add_Action (Table.States (437), 104, 395);
Add_Error (Table.States (437));
Add_Goto (Table.States (437), 230, 591);
Table.States (437).Kernel := To_Vector ((0 => (273, 274, 4, False)));
Table.States (437).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 395)));
Add_Action (Table.States (438), 68, 592);
Add_Error (Table.States (438));
Table.States (438).Kernel := To_Vector (((221, 192, 4, False), (221, 192, 2, False), (221, 192, 3, False),
(221, 192, 1, False)));
Table.States (438).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 68, 592)));
Add_Action (Table.States (439), 10, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 33, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 35, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 38, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 40, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 43, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 55, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 74, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 75, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 77, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 78, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 79, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 83, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 85, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 86, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 87, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 88, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 89, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 91, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 92, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 94, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 95, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 96, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 97, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 98, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 99, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (439), 104, 119);
Add_Action (Table.States (439), 105, 33);
Add_Action (Table.States (439), 106, 34);
Add_Error (Table.States (439));
Add_Goto (Table.States (439), 128, 41);
Add_Goto (Table.States (439), 239, 593);
Add_Goto (Table.States (439), 272, 92);
Add_Goto (Table.States (439), 293, 97);
Table.States (439).Kernel := To_Vector (((165, 41, 1, False), (258, 41, 0, False)));
Table.States (439).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (440), 77, 594);
Add_Error (Table.States (440));
Table.States (440).Kernel := To_Vector ((0 => (117, 54, 1, False)));
Table.States (440).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 594)));
Add_Action (Table.States (441), 3, 121);
Add_Action (Table.States (441), 35, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (441), 39, 122);
Add_Action (Table.States (441), 40, 123);
Add_Action (Table.States (441), 41, 124);
Add_Action (Table.States (441), 52, 125);
Add_Action (Table.States (441), 76, 126);
Add_Action (Table.States (441), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (441), 80, 595);
Add_Action (Table.States (441), 83, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (441), 94, 127);
Add_Action (Table.States (441), 95, 128);
Add_Action (Table.States (441), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (441), 103, 129);
Add_Action (Table.States (441), 104, 119);
Add_Action (Table.States (441), 105, 33);
Add_Action (Table.States (441), 106, 34);
Add_Error (Table.States (441));
Add_Goto (Table.States (441), 117, 130);
Add_Goto (Table.States (441), 128, 41);
Add_Goto (Table.States (441), 191, 131);
Add_Goto (Table.States (441), 192, 596);
Add_Goto (Table.States (441), 197, 133);
Add_Goto (Table.States (441), 239, 134);
Add_Goto (Table.States (441), 258, 135);
Add_Goto (Table.States (441), 272, 92);
Add_Goto (Table.States (441), 275, 136);
Add_Goto (Table.States (441), 282, 137);
Add_Goto (Table.States (441), 283, 138);
Add_Goto (Table.States (441), 284, 139);
Add_Goto (Table.States (441), 285, 140);
Add_Goto (Table.States (441), 286, 141);
Add_Goto (Table.States (441), 287, 142);
Add_Goto (Table.States (441), 293, 97);
Add_Goto (Table.States (441), 301, 143);
Add_Goto (Table.States (441), 320, 144);
Add_Goto (Table.States (441), 321, 145);
Add_Goto (Table.States (441), 330, 146);
Table.States (441).Kernel := To_Vector (((124, 87, 0, False), (124, 87, 1, False)));
Table.States (441).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (442), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (117, 4), 3, aggregate_4'Access,
null);
Table.States (442).Kernel := To_Vector ((0 => (117, 77, 0, False)));
Table.States (442).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 117, 3)));
Add_Action (Table.States (443), 3, 121);
Add_Action (Table.States (443), 35, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (443), 39, 122);
Add_Action (Table.States (443), 40, 261);
Add_Action (Table.States (443), 41, 124);
Add_Action (Table.States (443), 44, 263);
Add_Action (Table.States (443), 52, 125);
Add_Action (Table.States (443), 76, 126);
Add_Action (Table.States (443), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (443), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (443), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (443), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (443), 94, 127);
Add_Action (Table.States (443), 95, 128);
Add_Action (Table.States (443), 96, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (443), 103, 129);
Add_Action (Table.States (443), 104, 119);
Add_Action (Table.States (443), 105, 33);
Add_Action (Table.States (443), 106, 264);
Add_Error (Table.States (443));
Add_Goto (Table.States (443), 117, 130);
Add_Goto (Table.States (443), 124, 597);
Add_Goto (Table.States (443), 128, 41);
Add_Goto (Table.States (443), 165, 269);
Add_Goto (Table.States (443), 166, 270);
Add_Goto (Table.States (443), 191, 408);
Add_Goto (Table.States (443), 197, 133);
Add_Goto (Table.States (443), 239, 274);
Add_Goto (Table.States (443), 258, 135);
Add_Goto (Table.States (443), 272, 92);
Add_Goto (Table.States (443), 275, 136);
Add_Goto (Table.States (443), 277, 276);
Add_Goto (Table.States (443), 282, 137);
Add_Goto (Table.States (443), 283, 138);
Add_Goto (Table.States (443), 284, 139);
Add_Goto (Table.States (443), 285, 140);
Add_Goto (Table.States (443), 286, 141);
Add_Goto (Table.States (443), 287, 142);
Add_Goto (Table.States (443), 293, 97);
Add_Goto (Table.States (443), 301, 277);
Add_Goto (Table.States (443), 320, 144);
Add_Goto (Table.States (443), 321, 145);
Add_Goto (Table.States (443), 330, 146);
Table.States (443).Kernel := To_Vector ((0 => (125, 83, 0, True)));
Table.States (443).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 124, 0)));
Table.States (443).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (444), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (117, 3), 3, aggregate_3'Access,
null);
Table.States (444).Kernel := To_Vector ((0 => (117, 77, 0, False)));
Table.States (444).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 117, 3)));
Add_Action (Table.States (445), 3, 121);
Add_Action (Table.States (445), 39, 122);
Add_Action (Table.States (445), 40, 261);
Add_Action (Table.States (445), 41, 124);
Add_Action (Table.States (445), 44, 263);
Add_Action (Table.States (445), 52, 125);
Add_Action (Table.States (445), 76, 126);
Add_Action (Table.States (445), 94, 127);
Add_Action (Table.States (445), 95, 128);
Add_Action (Table.States (445), 103, 129);
Add_Action (Table.States (445), 104, 119);
Add_Action (Table.States (445), 105, 33);
Add_Action (Table.States (445), 106, 34);
Add_Error (Table.States (445));
Add_Goto (Table.States (445), 117, 130);
Add_Goto (Table.States (445), 128, 41);
Add_Goto (Table.States (445), 165, 598);
Add_Goto (Table.States (445), 191, 599);
Add_Goto (Table.States (445), 197, 133);
Add_Goto (Table.States (445), 239, 274);
Add_Goto (Table.States (445), 258, 135);
Add_Goto (Table.States (445), 272, 92);
Add_Goto (Table.States (445), 275, 136);
Add_Goto (Table.States (445), 277, 276);
Add_Goto (Table.States (445), 282, 137);
Add_Goto (Table.States (445), 283, 138);
Add_Goto (Table.States (445), 284, 139);
Add_Goto (Table.States (445), 285, 140);
Add_Goto (Table.States (445), 286, 141);
Add_Goto (Table.States (445), 287, 142);
Add_Goto (Table.States (445), 293, 97);
Add_Goto (Table.States (445), 301, 277);
Add_Goto (Table.States (445), 320, 144);
Add_Goto (Table.States (445), 321, 145);
Add_Goto (Table.States (445), 330, 146);
Table.States (445).Kernel := To_Vector ((0 => (166, 79, 1, True)));
Table.States (445).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (445).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (446), 3, 121);
Add_Action (Table.States (446), 35, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (446), 39, 122);
Add_Action (Table.States (446), 40, 123);
Add_Action (Table.States (446), 41, 124);
Add_Action (Table.States (446), 52, 125);
Add_Action (Table.States (446), 76, 126);
Add_Action (Table.States (446), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (446), 80, 600);
Add_Action (Table.States (446), 83, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (446), 94, 127);
Add_Action (Table.States (446), 95, 128);
Add_Action (Table.States (446), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (446), 103, 129);
Add_Action (Table.States (446), 104, 119);
Add_Action (Table.States (446), 105, 33);
Add_Action (Table.States (446), 106, 34);
Add_Error (Table.States (446));
Add_Goto (Table.States (446), 117, 130);
Add_Goto (Table.States (446), 128, 41);
Add_Goto (Table.States (446), 191, 131);
Add_Goto (Table.States (446), 192, 601);
Add_Goto (Table.States (446), 197, 133);
Add_Goto (Table.States (446), 239, 134);
Add_Goto (Table.States (446), 258, 135);
Add_Goto (Table.States (446), 272, 92);
Add_Goto (Table.States (446), 275, 136);
Add_Goto (Table.States (446), 282, 137);
Add_Goto (Table.States (446), 283, 138);
Add_Goto (Table.States (446), 284, 139);
Add_Goto (Table.States (446), 285, 140);
Add_Goto (Table.States (446), 286, 141);
Add_Goto (Table.States (446), 287, 142);
Add_Goto (Table.States (446), 293, 97);
Add_Goto (Table.States (446), 301, 143);
Add_Goto (Table.States (446), 320, 144);
Add_Goto (Table.States (446), 321, 145);
Add_Goto (Table.States (446), 330, 146);
Table.States (446).Kernel := To_Vector (((124, 87, 0, False), (124, 87, 1, False)));
Table.States (446).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
end Subr_8;
procedure Subr_9
is begin
Add_Action (Table.States (447), 3, 121);
Add_Action (Table.States (447), 39, 122);
Add_Action (Table.States (447), 40, 261);
Add_Action (Table.States (447), 41, 602);
Add_Action (Table.States (447), 44, 263);
Add_Action (Table.States (447), 52, 125);
Add_Action (Table.States (447), 76, 126);
Add_Action (Table.States (447), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (447), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (447), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (447), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (447), 94, 127);
Add_Action (Table.States (447), 95, 128);
Add_Action (Table.States (447), 103, 129);
Add_Action (Table.States (447), 104, 119);
Add_Action (Table.States (447), 105, 33);
Add_Action (Table.States (447), 106, 264);
Add_Error (Table.States (447));
Add_Goto (Table.States (447), 117, 130);
Add_Goto (Table.States (447), 124, 265);
Add_Goto (Table.States (447), 125, 603);
Add_Goto (Table.States (447), 128, 41);
Add_Goto (Table.States (447), 165, 269);
Add_Goto (Table.States (447), 166, 270);
Add_Goto (Table.States (447), 191, 408);
Add_Goto (Table.States (447), 197, 133);
Add_Goto (Table.States (447), 239, 274);
Add_Goto (Table.States (447), 258, 135);
Add_Goto (Table.States (447), 272, 92);
Add_Goto (Table.States (447), 275, 136);
Add_Goto (Table.States (447), 277, 276);
Add_Goto (Table.States (447), 282, 137);
Add_Goto (Table.States (447), 283, 138);
Add_Goto (Table.States (447), 284, 139);
Add_Goto (Table.States (447), 285, 140);
Add_Goto (Table.States (447), 286, 141);
Add_Goto (Table.States (447), 287, 142);
Add_Goto (Table.States (447), 293, 97);
Add_Goto (Table.States (447), 301, 277);
Add_Goto (Table.States (447), 320, 144);
Add_Goto (Table.States (447), 321, 145);
Add_Goto (Table.States (447), 330, 146);
Table.States (447).Kernel := To_Vector (((117, 74, 3, False), (117, 74, 1, False)));
Table.States (447).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Add_Action (Table.States (448), 7, 416);
Add_Action (Table.States (448), 19, 417);
Add_Action (Table.States (448), 20, 418);
Add_Action (Table.States (448), 38, 419);
Add_Action (Table.States (448), 53, 604);
Add_Action (Table.States (448), 76, 126);
Add_Action (Table.States (448), 104, 119);
Add_Action (Table.States (448), 105, 33);
Add_Action (Table.States (448), 106, 34);
Add_Error (Table.States (448));
Add_Goto (Table.States (448), 117, 420);
Add_Goto (Table.States (448), 128, 41);
Add_Goto (Table.States (448), 129, 421);
Add_Goto (Table.States (448), 239, 422);
Add_Goto (Table.States (448), 272, 92);
Add_Goto (Table.States (448), 293, 97);
Table.States (448).Kernel := To_Vector (((128, 322, 1, True), (272, 322, 2, True), (277, 322, 3, False),
(277, 322, 1, False)));
Table.States (448).Minimal_Complete_Actions := To_Vector (((Shift, 104, 119), (Shift, 53, 604)));
Table.States (448).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (449), 3, 121);
Add_Action (Table.States (449), 39, 122);
Add_Action (Table.States (449), 40, 123);
Add_Action (Table.States (449), 41, 124);
Add_Action (Table.States (449), 76, 126);
Add_Action (Table.States (449), 94, 127);
Add_Action (Table.States (449), 95, 128);
Add_Action (Table.States (449), 103, 129);
Add_Action (Table.States (449), 104, 119);
Add_Action (Table.States (449), 105, 33);
Add_Action (Table.States (449), 106, 34);
Add_Error (Table.States (449));
Add_Goto (Table.States (449), 117, 130);
Add_Goto (Table.States (449), 128, 41);
Add_Goto (Table.States (449), 197, 133);
Add_Goto (Table.States (449), 239, 134);
Add_Goto (Table.States (449), 258, 135);
Add_Goto (Table.States (449), 272, 92);
Add_Goto (Table.States (449), 293, 97);
Add_Goto (Table.States (449), 301, 605);
Add_Goto (Table.States (449), 320, 144);
Add_Goto (Table.States (449), 321, 145);
Add_Goto (Table.States (449), 330, 146);
Table.States (449).Kernel := To_Vector ((0 => (277, 85, 1, False)));
Table.States (449).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (450), 3, 121);
Add_Action (Table.States (450), 39, 122);
Add_Action (Table.States (450), 40, 261);
Add_Action (Table.States (450), 41, 124);
Add_Action (Table.States (450), 44, 263);
Add_Action (Table.States (450), 52, 125);
Add_Action (Table.States (450), 76, 126);
Add_Action (Table.States (450), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (450), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (450), 94, 127);
Add_Action (Table.States (450), 95, 128);
Add_Action (Table.States (450), 103, 129);
Add_Action (Table.States (450), 104, 119);
Add_Action (Table.States (450), 105, 33);
Add_Action (Table.States (450), 106, 34);
Add_Error (Table.States (450));
Add_Goto (Table.States (450), 117, 130);
Add_Goto (Table.States (450), 128, 41);
Add_Goto (Table.States (450), 165, 269);
Add_Goto (Table.States (450), 166, 606);
Add_Goto (Table.States (450), 191, 599);
Add_Goto (Table.States (450), 197, 133);
Add_Goto (Table.States (450), 239, 274);
Add_Goto (Table.States (450), 258, 135);
Add_Goto (Table.States (450), 272, 92);
Add_Goto (Table.States (450), 275, 136);
Add_Goto (Table.States (450), 277, 276);
Add_Goto (Table.States (450), 282, 137);
Add_Goto (Table.States (450), 283, 138);
Add_Goto (Table.States (450), 284, 139);
Add_Goto (Table.States (450), 285, 140);
Add_Goto (Table.States (450), 286, 141);
Add_Goto (Table.States (450), 287, 142);
Add_Goto (Table.States (450), 293, 97);
Add_Goto (Table.States (450), 301, 277);
Add_Goto (Table.States (450), 320, 144);
Add_Goto (Table.States (450), 321, 145);
Add_Goto (Table.States (450), 330, 146);
Table.States (450).Kernel := To_Vector ((0 => (140, 72, 1, False)));
Table.States (450).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 166, 0)));
Add_Action (Table.States (451), (24, 72), (141, 1), 1, null, null);
Table.States (451).Kernel := To_Vector ((0 => (141, 140, 0, False)));
Table.States (451).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 141, 1)));
Add_Action (Table.States (452), 24, 607);
Add_Action (Table.States (452), 72, 450);
Add_Error (Table.States (452));
Add_Goto (Table.States (452), 140, 608);
Table.States (452).Kernel := To_Vector (((139, 141, 3, False), (141, 141, 2, True)));
Table.States (452).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 607)));
Add_Action (Table.States (453), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99), (197, 0), 3, null, null);
Table.States (453).Kernel := To_Vector ((0 => (197, 258, 0, False)));
Table.States (453).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 197, 3)));
Add_Action (Table.States (454), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (282,
0), 3, null, null);
Table.States (454).Kernel := To_Vector ((0 => (282, 287, 0, True)));
Table.States (454).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 282, 3)));
Table.States (454).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (455), 3, 121);
Add_Action (Table.States (455), 39, 122);
Add_Action (Table.States (455), 40, 123);
Add_Action (Table.States (455), 41, 124);
Add_Action (Table.States (455), 52, 125);
Add_Action (Table.States (455), 76, 126);
Add_Action (Table.States (455), 94, 127);
Add_Action (Table.States (455), 95, 128);
Add_Action (Table.States (455), 103, 129);
Add_Action (Table.States (455), 104, 119);
Add_Action (Table.States (455), 105, 33);
Add_Action (Table.States (455), 106, 34);
Add_Error (Table.States (455));
Add_Goto (Table.States (455), 117, 130);
Add_Goto (Table.States (455), 128, 41);
Add_Goto (Table.States (455), 197, 133);
Add_Goto (Table.States (455), 239, 134);
Add_Goto (Table.States (455), 258, 135);
Add_Goto (Table.States (455), 272, 92);
Add_Goto (Table.States (455), 275, 136);
Add_Goto (Table.States (455), 287, 609);
Add_Goto (Table.States (455), 293, 97);
Add_Goto (Table.States (455), 301, 143);
Add_Goto (Table.States (455), 320, 144);
Add_Goto (Table.States (455), 321, 145);
Add_Goto (Table.States (455), 330, 146);
Table.States (455).Kernel := To_Vector ((0 => (283, 68, 1, True)));
Table.States (455).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (455).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (456), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (284,
0), 3, null, null);
Table.States (456).Kernel := To_Vector ((0 => (284, 287, 0, True)));
Table.States (456).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 284, 3)));
Table.States (456).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (457), 3, 121);
Add_Action (Table.States (457), 39, 122);
Add_Action (Table.States (457), 40, 123);
Add_Action (Table.States (457), 41, 124);
Add_Action (Table.States (457), 52, 125);
Add_Action (Table.States (457), 76, 126);
Add_Action (Table.States (457), 94, 127);
Add_Action (Table.States (457), 95, 128);
Add_Action (Table.States (457), 103, 129);
Add_Action (Table.States (457), 104, 119);
Add_Action (Table.States (457), 105, 33);
Add_Action (Table.States (457), 106, 34);
Add_Error (Table.States (457));
Add_Goto (Table.States (457), 117, 130);
Add_Goto (Table.States (457), 128, 41);
Add_Goto (Table.States (457), 197, 133);
Add_Goto (Table.States (457), 239, 134);
Add_Goto (Table.States (457), 258, 135);
Add_Goto (Table.States (457), 272, 92);
Add_Goto (Table.States (457), 275, 136);
Add_Goto (Table.States (457), 287, 610);
Add_Goto (Table.States (457), 293, 97);
Add_Goto (Table.States (457), 301, 143);
Add_Goto (Table.States (457), 320, 144);
Add_Goto (Table.States (457), 321, 145);
Add_Goto (Table.States (457), 330, 146);
Table.States (457).Kernel := To_Vector ((0 => (285, 22, 1, True)));
Table.States (457).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (457).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (458), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (286,
0), 3, null, null);
Table.States (458).Kernel := To_Vector ((0 => (286, 287, 0, True)));
Table.States (458).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 286, 3)));
Table.States (458).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (459), 3, 121);
Add_Action (Table.States (459), 39, 122);
Add_Action (Table.States (459), 40, 123);
Add_Action (Table.States (459), 41, 124);
Add_Action (Table.States (459), 52, 125);
Add_Action (Table.States (459), 76, 126);
Add_Action (Table.States (459), 94, 127);
Add_Action (Table.States (459), 95, 128);
Add_Action (Table.States (459), 103, 129);
Add_Action (Table.States (459), 104, 119);
Add_Action (Table.States (459), 105, 33);
Add_Action (Table.States (459), 106, 34);
Add_Error (Table.States (459));
Add_Goto (Table.States (459), 117, 130);
Add_Goto (Table.States (459), 128, 41);
Add_Goto (Table.States (459), 197, 133);
Add_Goto (Table.States (459), 239, 134);
Add_Goto (Table.States (459), 258, 135);
Add_Goto (Table.States (459), 272, 92);
Add_Goto (Table.States (459), 275, 136);
Add_Goto (Table.States (459), 287, 611);
Add_Goto (Table.States (459), 293, 97);
Add_Goto (Table.States (459), 301, 143);
Add_Goto (Table.States (459), 320, 144);
Add_Goto (Table.States (459), 321, 145);
Add_Goto (Table.States (459), 330, 146);
Table.States (459).Kernel := To_Vector ((0 => (283, 68, 1, True)));
Table.States (459).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (459).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (460), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (282,
1), 3, null, null);
Table.States (460).Kernel := To_Vector ((0 => (282, 287, 0, True)));
Table.States (460).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 282, 3)));
Table.States (460).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (461), 3, 121);
Add_Action (Table.States (461), 39, 122);
Add_Action (Table.States (461), 40, 123);
Add_Action (Table.States (461), 41, 124);
Add_Action (Table.States (461), 52, 125);
Add_Action (Table.States (461), 76, 126);
Add_Action (Table.States (461), 94, 127);
Add_Action (Table.States (461), 95, 128);
Add_Action (Table.States (461), 103, 129);
Add_Action (Table.States (461), 104, 119);
Add_Action (Table.States (461), 105, 33);
Add_Action (Table.States (461), 106, 34);
Add_Error (Table.States (461));
Add_Goto (Table.States (461), 117, 130);
Add_Goto (Table.States (461), 128, 41);
Add_Goto (Table.States (461), 197, 133);
Add_Goto (Table.States (461), 239, 134);
Add_Goto (Table.States (461), 258, 135);
Add_Goto (Table.States (461), 272, 92);
Add_Goto (Table.States (461), 275, 136);
Add_Goto (Table.States (461), 287, 612);
Add_Goto (Table.States (461), 293, 97);
Add_Goto (Table.States (461), 301, 143);
Add_Goto (Table.States (461), 320, 144);
Add_Goto (Table.States (461), 321, 145);
Add_Goto (Table.States (461), 330, 146);
Table.States (461).Kernel := To_Vector ((0 => (285, 22, 1, True)));
Table.States (461).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (461).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (462), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (284,
1), 3, null, null);
Table.States (462).Kernel := To_Vector ((0 => (284, 287, 0, True)));
Table.States (462).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 284, 3)));
Table.States (462).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (463), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (286,
1), 3, null, null);
Table.States (463).Kernel := To_Vector ((0 => (286, 287, 0, True)));
Table.States (463).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 286, 3)));
Table.States (463).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (464), 10, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 20, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 21, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 22, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 23, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 35, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 37, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 43, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 53, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 68, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 74, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 75, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 77, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 79, 613);
Add_Conflict (Table.States (464), 79, (287, 1), 3, null, null);
Add_Action (Table.States (464), 83, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 87, Reduce, (287, 1), 3, null, null);
Add_Action (Table.States (464), 96, Reduce, (287, 1), 3, null, null);
Add_Error (Table.States (464));
Table.States (464).Kernel := To_Vector (((233, 233, 2, True), (287, 233, 0, False)));
Table.States (464).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 287, 3)));
Add_Action (Table.States (465), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (233,
1), 1, null, null);
Table.States (465).Kernel := To_Vector ((0 => (233, 234, 0, False)));
Table.States (465).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 233, 1)));
Add_Action (Table.States (466), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (234,
1), 1, null, null);
Table.States (466).Kernel := To_Vector ((0 => (234, 277, 0, False)));
Table.States (466).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 234, 1)));
Add_Action (Table.States (467), 10, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 20, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 21, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 22, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 23, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 35, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 37, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 43, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 53, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 68, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 74, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 75, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 77, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 79, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 83, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 85, 449);
Add_Action (Table.States (467), 87, Reduce, (234, 0), 1, null, null);
Add_Action (Table.States (467), 96, Reduce, (234, 0), 1, null, null);
Add_Error (Table.States (467));
Table.States (467).Kernel := To_Vector (((234, 301, 0, False), (277, 301, 2, False)));
Table.States (467).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 234, 1)));
Add_Action (Table.States (468), 3, 121);
Add_Action (Table.States (468), 39, 122);
Add_Action (Table.States (468), 40, 123);
Add_Action (Table.States (468), 41, 124);
Add_Action (Table.States (468), 76, 126);
Add_Action (Table.States (468), 94, 127);
Add_Action (Table.States (468), 95, 128);
Add_Action (Table.States (468), 103, 129);
Add_Action (Table.States (468), 104, 119);
Add_Action (Table.States (468), 105, 33);
Add_Action (Table.States (468), 106, 34);
Add_Error (Table.States (468));
Add_Goto (Table.States (468), 117, 130);
Add_Goto (Table.States (468), 128, 41);
Add_Goto (Table.States (468), 197, 133);
Add_Goto (Table.States (468), 233, 614);
Add_Goto (Table.States (468), 234, 465);
Add_Goto (Table.States (468), 239, 274);
Add_Goto (Table.States (468), 258, 135);
Add_Goto (Table.States (468), 272, 92);
Add_Goto (Table.States (468), 277, 466);
Add_Goto (Table.States (468), 293, 97);
Add_Goto (Table.States (468), 301, 467);
Add_Goto (Table.States (468), 320, 144);
Add_Goto (Table.States (468), 321, 145);
Add_Goto (Table.States (468), 330, 146);
Table.States (468).Kernel := To_Vector ((0 => (287, 33, 1, False)));
Table.States (468).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (469), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (287,
2), 3, null, null);
Table.States (469).Kernel := To_Vector ((0 => (287, 301, 0, False)));
Table.States (469).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 287, 3)));
Add_Action (Table.States (470), (10, 20, 21, 22, 23, 33, 35, 37, 38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 99), (320, 0), 3, null, null);
Table.States (470).Kernel := To_Vector ((0 => (320, 197, 0, True)));
Table.States (470).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 320, 3)));
Table.States (470).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (471), 10, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 20, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 21, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 22, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 23, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 33, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 35, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 37, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 38, 297);
Add_Action (Table.States (471), 40, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 42, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 43, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 53, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 55, 298);
Add_Action (Table.States (471), 68, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 74, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 75, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 77, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 78, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 79, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 82, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 83, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 85, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 86, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 87, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 88, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 89, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 91, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 92, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 94, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 95, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 96, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 97, 299);
Add_Action (Table.States (471), 98, Reduce, (321, 0), 3, null, null);
Add_Action (Table.States (471), 99, 300);
Add_Error (Table.States (471));
Add_Goto (Table.States (471), 237, 301);
Table.States (471).Kernel := To_Vector (((320, 320, 2, True), (321, 320, 0, True)));
Table.States (471).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 321, 3)));
Table.States (471).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (472), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (161, 0), 4, delay_statement_0'Access, null);
Table.States (472).Kernel := To_Vector ((0 => (161, 96, 0, False)));
Table.States (472).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 161, 4)));
Add_Action (Table.States (473), 96, 615);
Add_Error (Table.States (473));
Table.States (473).Kernel := To_Vector ((0 => (190, 192, 1, False)));
Table.States (473).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 615)));
Add_Action (Table.States (474), 39, 122);
Add_Action (Table.States (474), 41, 616);
Add_Action (Table.States (474), 76, 126);
Add_Action (Table.States (474), 103, 129);
Add_Action (Table.States (474), 104, 119);
Add_Action (Table.States (474), 105, 33);
Add_Action (Table.States (474), 106, 34);
Add_Error (Table.States (474));
Add_Goto (Table.States (474), 117, 130);
Add_Goto (Table.States (474), 128, 41);
Add_Goto (Table.States (474), 239, 134);
Add_Goto (Table.States (474), 258, 256);
Add_Goto (Table.States (474), 272, 92);
Add_Goto (Table.States (474), 293, 97);
Table.States (474).Kernel := To_Vector (((197, 40, 1, False), (314, 40, 6, False), (314, 40, 2, False)));
Table.States (474).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (475), 3, 121);
Add_Action (Table.States (475), 39, 122);
Add_Action (Table.States (475), 40, 474);
Add_Action (Table.States (475), 41, 124);
Add_Action (Table.States (475), 76, 126);
Add_Action (Table.States (475), 94, 127);
Add_Action (Table.States (475), 95, 128);
Add_Action (Table.States (475), 103, 129);
Add_Action (Table.States (475), 104, 119);
Add_Action (Table.States (475), 105, 33);
Add_Action (Table.States (475), 106, 34);
Add_Error (Table.States (475));
Add_Goto (Table.States (475), 117, 130);
Add_Goto (Table.States (475), 128, 41);
Add_Goto (Table.States (475), 167, 617);
Add_Goto (Table.States (475), 197, 133);
Add_Goto (Table.States (475), 239, 477);
Add_Goto (Table.States (475), 258, 135);
Add_Goto (Table.States (475), 272, 92);
Add_Goto (Table.States (475), 277, 478);
Add_Goto (Table.States (475), 293, 97);
Add_Goto (Table.States (475), 301, 479);
Add_Goto (Table.States (475), 314, 480);
Add_Goto (Table.States (475), 320, 144);
Add_Goto (Table.States (475), 321, 145);
Add_Goto (Table.States (475), 330, 146);
Table.States (475).Kernel := To_Vector ((0 => (230, 59, 1, False)));
Table.States (475).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (476), (37, 87), (230, 5), 3, iterator_specification_5'Access, null);
Table.States (476).Kernel := To_Vector ((0 => (230, 167, 0, False)));
Table.States (476).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 230, 3)));
Add_Action (Table.States (477), 10, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 33, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 37, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (477), 38, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 40, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 43, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 53, 618);
Add_Action (Table.States (477), 55, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 75, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 76, 619);
Add_Action (Table.States (477), 77, Reduce, (258, 3), 1, null, null);
Add_Conflict (Table.States (477), 77, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (477), 78, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 79, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 83, Reduce, (258, 3), 1, null, null);
Add_Conflict (Table.States (477), 83, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (477), 84, 237);
Add_Action (Table.States (477), 85, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 86, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 87, Reduce, (258, 3), 1, null, null);
Add_Conflict (Table.States (477), 87, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (477), 88, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 89, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 91, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 92, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 94, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 95, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 97, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 98, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 99, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 100, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (477), 101, 239);
Add_Action (Table.States (477), 102, 240);
Add_Error (Table.States (477));
Add_Goto (Table.States (477), 115, 241);
Add_Goto (Table.States (477), 155, 620);
Add_Goto (Table.States (477), 224, 621);
Add_Goto (Table.States (477), 322, 448);
Table.States (477).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(258, 239, 0, False), (272, 239, 3, True), (277, 239, 4, False), (277, 239, 2, False), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (314, 239, 4, False), (314, 239, 0, False)));
Table.States (477).Minimal_Complete_Actions := To_Vector (((Reduce, 258, 1), (Reduce, 314, 1)));
Add_Action (Table.States (478), (37, 77, 83, 87), (167, 1), 1, null, null);
Table.States (478).Kernel := To_Vector ((0 => (167, 277, 0, False)));
Table.States (478).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 167, 1)));
Add_Action (Table.States (479), 85, 449);
Add_Error (Table.States (479));
Table.States (479).Kernel := To_Vector ((0 => (277, 301, 2, False)));
Table.States (479).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 85, 449)));
Add_Action (Table.States (480), (37, 77, 83, 87), (167, 0), 1, null, null);
Table.States (480).Kernel := To_Vector ((0 => (167, 314, 0, False)));
Table.States (480).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 167, 1)));
Add_Action (Table.States (481), 104, 119);
Add_Action (Table.States (481), 105, 33);
Add_Action (Table.States (481), 106, 34);
Add_Error (Table.States (481));
Add_Goto (Table.States (481), 128, 41);
Add_Goto (Table.States (481), 239, 622);
Add_Goto (Table.States (481), 272, 92);
Add_Goto (Table.States (481), 293, 97);
Table.States (481).Kernel := To_Vector ((0 => (230, 59, 1, False)));
Table.States (481).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (482), 37, Reduce, (230, 4), 3, null, null);
Add_Action (Table.States (482), 76, 235);
Add_Action (Table.States (482), 84, 237);
Add_Action (Table.States (482), 87, Reduce, (230, 4), 3, null, null);
Add_Action (Table.States (482), 101, 239);
Add_Action (Table.States (482), 102, 240);
Add_Error (Table.States (482));
Add_Goto (Table.States (482), 115, 241);
Add_Goto (Table.States (482), 322, 242);
Table.States (482).Kernel := To_Vector (((128, 239, 2, True), (230, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (482).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 230, 3)));
Add_Action (Table.States (483), 41, 623);
Add_Error (Table.States (483));
Table.States (483).Kernel := To_Vector (((314, 40, 6, False), (314, 40, 2, False)));
Table.States (483).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 41, 623)));
Add_Action (Table.States (484), 10, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (484), 21, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (484), 42, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (484), 53, 618);
Add_Action (Table.States (484), 74, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (484), 76, 619);
Add_Action (Table.States (484), 82, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (484), 84, 237);
Add_Action (Table.States (484), 96, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (484), 101, 239);
Add_Action (Table.States (484), 102, 240);
Add_Error (Table.States (484));
Add_Goto (Table.States (484), 115, 241);
Add_Goto (Table.States (484), 155, 620);
Add_Goto (Table.States (484), 224, 621);
Add_Goto (Table.States (484), 322, 242);
Table.States (484).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(314, 239, 4, False), (314, 239, 0, False)));
Table.States (484).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 314, 1)));
Add_Action (Table.States (485), 42, 624);
Add_Error (Table.States (485));
Table.States (485).Kernel := To_Vector (((230, 314, 3, False), (230, 314, 2, False)));
Table.States (485).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 42, 624)));
Add_Action (Table.States (486), 96, 625);
Add_Error (Table.States (486));
Table.States (486).Kernel := To_Vector ((0 => (121, 192, 1, False)));
Table.States (486).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 625)));
Add_Action (Table.States (487), 3, 121);
Add_Action (Table.States (487), 39, 122);
Add_Action (Table.States (487), 40, 123);
Add_Action (Table.States (487), 41, 124);
Add_Action (Table.States (487), 52, 125);
Add_Action (Table.States (487), 76, 126);
Add_Action (Table.States (487), 94, 127);
Add_Action (Table.States (487), 95, 128);
Add_Action (Table.States (487), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (487), 103, 129);
Add_Action (Table.States (487), 104, 119);
Add_Action (Table.States (487), 105, 33);
Add_Action (Table.States (487), 106, 34);
Add_Error (Table.States (487));
Add_Goto (Table.States (487), 117, 130);
Add_Goto (Table.States (487), 128, 41);
Add_Goto (Table.States (487), 191, 131);
Add_Goto (Table.States (487), 192, 626);
Add_Goto (Table.States (487), 197, 133);
Add_Goto (Table.States (487), 239, 134);
Add_Goto (Table.States (487), 258, 135);
Add_Goto (Table.States (487), 272, 92);
Add_Goto (Table.States (487), 275, 136);
Add_Goto (Table.States (487), 282, 137);
Add_Goto (Table.States (487), 283, 138);
Add_Goto (Table.States (487), 284, 139);
Add_Goto (Table.States (487), 285, 140);
Add_Goto (Table.States (487), 286, 141);
Add_Goto (Table.States (487), 287, 142);
Add_Goto (Table.States (487), 293, 97);
Add_Goto (Table.States (487), 301, 143);
Add_Goto (Table.States (487), 320, 144);
Add_Goto (Table.States (487), 321, 145);
Add_Goto (Table.States (487), 330, 146);
Table.States (487).Kernel := To_Vector ((0 => (127, 12, 1, False)));
Table.States (487).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (488), 12, 627);
Add_Action (Table.States (488), 104, Reduce, (235, 1), 0, null, null);
Add_Error (Table.States (488));
Add_Goto (Table.States (488), 235, 628);
Table.States (488).Kernel := To_Vector ((0 => (281, 54, 11, False)));
Table.States (488).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 235, 0)));
Add_Action (Table.States (489), 96, 629);
Add_Error (Table.States (489));
Table.States (489).Kernel := To_Vector ((0 => (182, 117, 1, False)));
Table.States (489).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 629)));
Add_Action (Table.States (490), (21, 35, 56, 74, 77, 82, 96), (291, 1), 2, result_profile_1'Access, null);
Table.States (490).Kernel := To_Vector ((0 => (291, 114, 0, True)));
Table.States (490).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 291, 2)));
Table.States (490).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (491), 7, 556);
Add_Action (Table.States (491), 21, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (491), 35, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (491), 56, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (491), 74, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (491), 77, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (491), 82, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (491), 96, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (491), 104, 119);
Add_Action (Table.States (491), 105, 33);
Add_Action (Table.States (491), 106, 34);
Add_Error (Table.States (491));
Add_Goto (Table.States (491), 128, 41);
Add_Goto (Table.States (491), 239, 630);
Add_Goto (Table.States (491), 240, 631);
Add_Goto (Table.States (491), 272, 92);
Add_Goto (Table.States (491), 293, 97);
Table.States (491).Kernel := To_Vector (((114, 241, 2, False), (114, 241, 3, True), (114, 241, 2, False),
(291, 241, 0, False)));
Table.States (491).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 240, 0)));
Add_Action (Table.States (492), 10, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 33, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 38, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 40, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 43, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 53, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 55, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 75, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 77, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 78, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 79, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 81, Reduce, (219, 1), 1, identifier_list_1'Access, null);
Add_Action (Table.States (492), 83, Reduce, (219, 1), 1, identifier_list_1'Access, null);
Add_Conflict (Table.States (492), 83, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 85, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 86, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 87, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 88, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 89, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 91, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 92, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 94, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 95, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 97, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 98, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 99, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 100, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (492), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (492));
Table.States (492).Kernel := To_Vector (((219, 104, 0, False), (239, 104, 0, False)));
Table.States (492).Minimal_Complete_Actions := To_Vector (((Reduce, 219, 1), (Reduce, 239, 1)));
end Subr_9;
procedure Subr_10
is begin
Add_Action (Table.States (493), 81, 632);
Add_Action (Table.States (493), 83, 234);
Add_Error (Table.States (493));
Table.States (493).Kernel := To_Vector (((219, 219, 2, True), (254, 219, 3, False), (254, 219, 2, False),
(254, 219, 4, False), (254, 219, 3, False)));
Table.States (493).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 81, 632)));
Add_Action (Table.States (494), (77, 96), (255, 1), 1, null, null);
Table.States (494).Kernel := To_Vector ((0 => (255, 254, 0, False)));
Table.States (494).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 255, 1)));
Add_Action (Table.States (495), 77, 633);
Add_Action (Table.States (495), 96, 634);
Add_Error (Table.States (495));
Table.States (495).Kernel := To_Vector (((199, 255, 1, False), (255, 255, 1, True)));
Table.States (495).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 633)));
Add_Action (Table.States (496), (21, 35, 56, 74, 77, 82, 96), (252, 0), 2,
parameter_and_result_profile_0'Access, null);
Table.States (496).Kernel := To_Vector ((0 => (252, 291, 0, True)));
Table.States (496).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 252, 2)));
Table.States (496).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (497), 104, 119);
Add_Action (Table.States (497), 105, 33);
Add_Action (Table.States (497), 106, 34);
Add_Error (Table.States (497));
Add_Goto (Table.States (497), 128, 41);
Add_Goto (Table.States (497), 239, 635);
Add_Goto (Table.States (497), 272, 92);
Add_Goto (Table.States (497), 293, 97);
Table.States (497).Kernel := To_Vector ((0 => (215, 56, 2, False)));
Table.States (497).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (498), 104, 119);
Add_Action (Table.States (498), 105, 33);
Add_Action (Table.States (498), 106, 34);
Add_Error (Table.States (498));
Add_Goto (Table.States (498), 128, 41);
Add_Goto (Table.States (498), 239, 636);
Add_Goto (Table.States (498), 272, 92);
Add_Goto (Table.States (498), 293, 97);
Table.States (498).Kernel := To_Vector ((0 => (215, 56, 2, False)));
Table.States (498).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (499), 104, 119);
Add_Action (Table.States (499), 105, 33);
Add_Action (Table.States (499), 106, 34);
Add_Error (Table.States (499));
Add_Goto (Table.States (499), 128, 41);
Add_Goto (Table.States (499), 239, 637);
Add_Goto (Table.States (499), 272, 92);
Add_Goto (Table.States (499), 293, 97);
Table.States (499).Kernel := To_Vector ((0 => (215, 56, 2, False)));
Table.States (499).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (500), 35, 638);
Add_Action (Table.States (500), 74, 337);
Add_Action (Table.States (500), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (500));
Add_Goto (Table.States (500), 122, 639);
Table.States (500).Kernel := To_Vector (((201, 169, 3, False), (201, 169, 3, False), (201, 169, 1,
False)));
Table.States (500).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (501), 35, 640);
Add_Action (Table.States (501), 76, 235);
Add_Action (Table.States (501), 84, 237);
Add_Action (Table.States (501), 101, 239);
Add_Action (Table.States (501), 102, 240);
Add_Error (Table.States (501));
Add_Goto (Table.States (501), 115, 241);
Add_Goto (Table.States (501), 322, 242);
Table.States (501).Kernel := To_Vector (((128, 239, 2, True), (204, 239, 4, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (501).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 640)));
Add_Action (Table.States (502), 6, 641);
Add_Action (Table.States (502), 41, 642);
Add_Action (Table.States (502), 80, 643);
Add_Action (Table.States (502), 104, 119);
Add_Action (Table.States (502), 105, 33);
Add_Action (Table.States (502), 106, 34);
Add_Error (Table.States (502));
Add_Goto (Table.States (502), 128, 41);
Add_Goto (Table.States (502), 239, 644);
Add_Goto (Table.States (502), 272, 92);
Add_Goto (Table.States (502), 293, 97);
Add_Goto (Table.States (502), 310, 645);
Table.States (502).Kernel := To_Vector (((200, 35, 3, False), (200, 35, 2, False), (200, 35, 2, False)));
Table.States (502).Minimal_Complete_Actions := To_Vector (((Shift, 104, 119), (Shift, 6, 641)));
Add_Action (Table.States (503), 96, 646);
Add_Error (Table.States (503));
Table.States (503).Kernel := To_Vector ((0 => (200, 122, 1, False)));
Table.States (503).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 646)));
Add_Action (Table.States (504), 7, Reduce, (236, 0), 1, null, null);
Add_Action (Table.States (504), 40, Reduce, (236, 0), 1, null, null);
Add_Action (Table.States (504), 45, 647);
Add_Action (Table.States (504), 74, Reduce, (236, 0), 1, null, null);
Add_Action (Table.States (504), 82, Reduce, (236, 0), 1, null, null);
Add_Action (Table.States (504), 96, Reduce, (236, 0), 1, null, null);
Add_Action (Table.States (504), 104, Reduce, (236, 0), 1, null, null);
Add_Action (Table.States (504), 105, Reduce, (236, 0), 1, null, null);
Add_Action (Table.States (504), 106, Reduce, (236, 0), 1, null, null);
Add_Error (Table.States (504));
Table.States (504).Kernel := To_Vector (((236, 33, 0, False), (236, 33, 1, False)));
Table.States (504).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 236, 1)));
Add_Action (Table.States (505), (7, 40, 74, 82, 96, 104, 105, 106), (236, 2), 1, null, null);
Table.States (505).Kernel := To_Vector ((0 => (236, 45, 0, False)));
Table.States (505).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 236, 1)));
Add_Action (Table.States (506), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (506), 40, 386);
Add_Action (Table.States (506), 104, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (506), 105, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (506), 106, Reduce, (241, 1), 0, null, null);
Add_Error (Table.States (506));
Add_Goto (Table.States (506), 114, 648);
Add_Goto (Table.States (506), 241, 649);
Table.States (506).Kernel := To_Vector (((198, 236, 3, False), (198, 236, 4, False), (198, 236, 2, False),
(198, 236, 3, False)));
Table.States (506).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 241, 0)));
Add_Action (Table.States (507), 22, 650);
Add_Action (Table.States (507), 23, 651);
Add_Action (Table.States (507), 24, 652);
Add_Error (Table.States (507));
Add_Goto (Table.States (507), 174, 653);
Add_Goto (Table.States (507), 175, 654);
Table.States (507).Kernel := To_Vector (((222, 300, 6, False), (222, 300, 4, False), (222, 300, 5, False),
(222, 300, 3, False)));
Table.States (507).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 652)));
Add_Action (Table.States (508), 83, 381);
Add_Action (Table.States (508), 96, 655);
Add_Error (Table.States (508));
Table.States (508).Kernel := To_Vector (((238, 238, 2, True), (332, 238, 1, False)));
Table.States (508).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 655)));
Add_Action (Table.States (509), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (332, 1), 4,
with_clause_1'Access, null);
Table.States (509).Kernel := To_Vector ((0 => (332, 96, 0, False)));
Table.States (509).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 332, 4)));
Add_Action (Table.States (510), 60, 656);
Add_Error (Table.States (510));
Table.States (510).Kernel := To_Vector ((0 => (248, 35, 2, False)));
Table.States (510).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 60, 656)));
Add_Action (Table.States (511), 35, 657);
Add_Error (Table.States (511));
Table.States (511).Kernel := To_Vector (((247, 122, 4, False), (247, 122, 3, False)));
Table.States (511).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 657)));
Add_Action (Table.States (512), 104, 119);
Add_Action (Table.States (512), 105, 33);
Add_Action (Table.States (512), 106, 34);
Add_Error (Table.States (512));
Add_Goto (Table.States (512), 128, 41);
Add_Goto (Table.States (512), 239, 658);
Add_Goto (Table.States (512), 272, 92);
Add_Goto (Table.States (512), 293, 97);
Table.States (512).Kernel := To_Vector ((0 => (213, 39, 2, False)));
Table.States (512).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (513), 74, 337);
Add_Action (Table.States (513), 76, 235);
Add_Action (Table.States (513), 84, 237);
Add_Action (Table.States (513), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (513), 101, 239);
Add_Action (Table.States (513), 102, 240);
Add_Error (Table.States (513));
Add_Goto (Table.States (513), 115, 241);
Add_Goto (Table.States (513), 122, 659);
Add_Goto (Table.States (513), 322, 242);
Table.States (513).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(250, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (513).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (514), 35, Reduce, (122, 0), 2, aspect_specification_opt_0'Access, null);
Add_Action (Table.States (514), 83, 443);
Add_Action (Table.States (514), 96, Reduce, (122, 0), 2, aspect_specification_opt_0'Access, null);
Add_Error (Table.States (514));
Table.States (514).Kernel := To_Vector (((122, 125, 0, False), (125, 125, 1, True)));
Table.States (514).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 2)));
Add_Action (Table.States (515), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (515), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (515), 28, 183);
Add_Action (Table.States (515), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (515), 30, 8);
Add_Action (Table.States (515), 40, 12);
Add_Action (Table.States (515), 46, 14);
Add_Action (Table.States (515), 47, 15);
Add_Action (Table.States (515), 48, 16);
Add_Action (Table.States (515), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (515), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (515), 51, 19);
Add_Action (Table.States (515), 63, 25);
Add_Action (Table.States (515), 66, 26);
Add_Action (Table.States (515), 69, 27);
Add_Action (Table.States (515), 71, 28);
Add_Action (Table.States (515), 104, 185);
Add_Error (Table.States (515));
Add_Goto (Table.States (515), 112, 35);
Add_Goto (Table.States (515), 121, 37);
Add_Goto (Table.States (515), 127, 40);
Add_Goto (Table.States (515), 134, 45);
Add_Goto (Table.States (515), 135, 46);
Add_Goto (Table.States (515), 157, 391);
Add_Goto (Table.States (515), 158, 392);
Add_Goto (Table.States (515), 159, 660);
Add_Goto (Table.States (515), 179, 54);
Add_Goto (Table.States (515), 182, 55);
Add_Goto (Table.States (515), 186, 56);
Add_Goto (Table.States (515), 193, 58);
Add_Goto (Table.States (515), 206, 60);
Add_Goto (Table.States (515), 207, 61);
Add_Goto (Table.States (515), 209, 62);
Add_Goto (Table.States (515), 210, 63);
Add_Goto (Table.States (515), 213, 64);
Add_Goto (Table.States (515), 214, 65);
Add_Goto (Table.States (515), 215, 66);
Add_Goto (Table.States (515), 216, 67);
Add_Goto (Table.States (515), 219, 69);
Add_Goto (Table.States (515), 223, 71);
Add_Goto (Table.States (515), 243, 74);
Add_Goto (Table.States (515), 244, 75);
Add_Goto (Table.States (515), 245, 76);
Add_Goto (Table.States (515), 246, 77);
Add_Goto (Table.States (515), 247, 78);
Add_Goto (Table.States (515), 248, 79);
Add_Goto (Table.States (515), 249, 80);
Add_Goto (Table.States (515), 250, 81);
Add_Goto (Table.States (515), 251, 82);
Add_Goto (Table.States (515), 257, 394);
Add_Goto (Table.States (515), 259, 84);
Add_Goto (Table.States (515), 260, 85);
Add_Goto (Table.States (515), 262, 87);
Add_Goto (Table.States (515), 263, 88);
Add_Goto (Table.States (515), 264, 89);
Add_Goto (Table.States (515), 265, 90);
Add_Goto (Table.States (515), 271, 91);
Add_Goto (Table.States (515), 281, 94);
Add_Goto (Table.States (515), 289, 95);
Add_Goto (Table.States (515), 304, 102);
Add_Goto (Table.States (515), 305, 103);
Add_Goto (Table.States (515), 307, 105);
Add_Goto (Table.States (515), 308, 106);
Add_Goto (Table.States (515), 309, 107);
Add_Goto (Table.States (515), 311, 108);
Add_Goto (Table.States (515), 313, 109);
Add_Goto (Table.States (515), 316, 111);
Add_Goto (Table.States (515), 317, 112);
Add_Goto (Table.States (515), 319, 113);
Add_Goto (Table.States (515), 325, 115);
Add_Goto (Table.States (515), 331, 116);
Table.States (515).Kernel := To_Vector (((251, 35, 2, False), (251, 35, 1, False)));
Table.States (515).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (516), 77, 661);
Add_Action (Table.States (516), 83, 443);
Add_Error (Table.States (516));
Table.States (516).Kernel := To_Vector (((125, 125, 1, True), (257, 125, 2, False)));
Table.States (516).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 661)));
Add_Action (Table.States (517), 77, 662);
Add_Error (Table.States (517));
Table.States (517).Kernel := To_Vector ((0 => (257, 153, 2, False)));
Table.States (517).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 662)));
Add_Action (Table.States (518), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (332, 2), 4,
with_clause_2'Access, null);
Table.States (518).Kernel := To_Vector ((0 => (332, 96, 0, False)));
Table.States (518).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 332, 4)));
Add_Action (Table.States (519), 60, 663);
Add_Error (Table.States (519));
Table.States (519).Kernel := To_Vector ((0 => (265, 35, 2, False)));
Table.States (519).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 60, 663)));
Add_Action (Table.States (520), 35, 664);
Add_Error (Table.States (520));
Table.States (520).Kernel := To_Vector ((0 => (264, 122, 3, False)));
Table.States (520).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 664)));
Add_Action (Table.States (521), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (521), 74, 337);
Add_Error (Table.States (521));
Add_Goto (Table.States (521), 122, 665);
Table.States (521).Kernel := To_Vector (((271, 169, 6, False), (271, 169, 3, False)));
Table.States (521).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (522), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (522), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (522), 28, 183);
Add_Action (Table.States (522), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (522), 30, 8);
Add_Action (Table.States (522), 39, 666);
Add_Action (Table.States (522), 40, 12);
Add_Action (Table.States (522), 46, 14);
Add_Action (Table.States (522), 47, 15);
Add_Action (Table.States (522), 48, 16);
Add_Action (Table.States (522), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (522), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (522), 51, 19);
Add_Action (Table.States (522), 63, 25);
Add_Action (Table.States (522), 66, 26);
Add_Action (Table.States (522), 69, 27);
Add_Action (Table.States (522), 71, 28);
Add_Action (Table.States (522), 104, 185);
Add_Error (Table.States (522));
Add_Goto (Table.States (522), 112, 35);
Add_Goto (Table.States (522), 121, 37);
Add_Goto (Table.States (522), 127, 40);
Add_Goto (Table.States (522), 134, 45);
Add_Goto (Table.States (522), 135, 46);
Add_Goto (Table.States (522), 157, 391);
Add_Goto (Table.States (522), 158, 392);
Add_Goto (Table.States (522), 159, 667);
Add_Goto (Table.States (522), 179, 54);
Add_Goto (Table.States (522), 182, 55);
Add_Goto (Table.States (522), 186, 56);
Add_Goto (Table.States (522), 193, 58);
Add_Goto (Table.States (522), 206, 60);
Add_Goto (Table.States (522), 207, 61);
Add_Goto (Table.States (522), 209, 62);
Add_Goto (Table.States (522), 210, 63);
Add_Goto (Table.States (522), 213, 64);
Add_Goto (Table.States (522), 214, 65);
Add_Goto (Table.States (522), 215, 66);
Add_Goto (Table.States (522), 216, 67);
Add_Goto (Table.States (522), 219, 69);
Add_Goto (Table.States (522), 223, 71);
Add_Goto (Table.States (522), 243, 74);
Add_Goto (Table.States (522), 244, 75);
Add_Goto (Table.States (522), 245, 76);
Add_Goto (Table.States (522), 246, 77);
Add_Goto (Table.States (522), 247, 78);
Add_Goto (Table.States (522), 248, 79);
Add_Goto (Table.States (522), 249, 80);
Add_Goto (Table.States (522), 250, 81);
Add_Goto (Table.States (522), 251, 82);
Add_Goto (Table.States (522), 257, 394);
Add_Goto (Table.States (522), 259, 84);
Add_Goto (Table.States (522), 260, 85);
Add_Goto (Table.States (522), 262, 87);
Add_Goto (Table.States (522), 263, 88);
Add_Goto (Table.States (522), 264, 89);
Add_Goto (Table.States (522), 265, 90);
Add_Goto (Table.States (522), 266, 668);
Add_Goto (Table.States (522), 271, 91);
Add_Goto (Table.States (522), 281, 94);
Add_Goto (Table.States (522), 289, 95);
Add_Goto (Table.States (522), 304, 102);
Add_Goto (Table.States (522), 305, 103);
Add_Goto (Table.States (522), 307, 105);
Add_Goto (Table.States (522), 308, 106);
Add_Goto (Table.States (522), 309, 107);
Add_Goto (Table.States (522), 311, 108);
Add_Goto (Table.States (522), 313, 109);
Add_Goto (Table.States (522), 316, 111);
Add_Goto (Table.States (522), 317, 112);
Add_Goto (Table.States (522), 319, 113);
Add_Goto (Table.States (522), 325, 115);
Add_Goto (Table.States (522), 331, 116);
Table.States (522).Kernel := To_Vector (((304, 35, 5, False), (304, 35, 2, False)));
Table.States (522).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (523), 96, 669);
Add_Error (Table.States (523));
Table.States (523).Kernel := To_Vector ((0 => (276, 192, 1, False)));
Table.States (523).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 669)));
Add_Action (Table.States (524), 96, 670);
Add_Error (Table.States (524));
Table.States (524).Kernel := To_Vector ((0 => (290, 5, 1, False)));
Table.States (524).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 670)));
Add_Action (Table.States (525), 7, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (525), 16, 568);
Add_Action (Table.States (525), 21, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (525), 40, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (525), 82, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (525), 96, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (525), 104, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (525), 105, Reduce, (154, 1), 0, null, null);
Add_Action (Table.States (525), 106, Reduce, (154, 1), 0, null, null);
Add_Error (Table.States (525));
Add_Goto (Table.States (525), 154, 671);
Table.States (525).Kernel := To_Vector (((194, 118, 2, False), (194, 118, 1, False)));
Table.States (525).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 154, 0)));
Add_Action (Table.States (526), 24, 672);
Add_Error (Table.States (526));
Table.States (526).Kernel := To_Vector ((0 => (196, 218, 3, False)));
Table.States (526).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 672)));
Add_Action (Table.States (527), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (527), 40, 12);
Add_Action (Table.States (527), 46, 14);
Add_Action (Table.States (527), 47, 673);
Add_Action (Table.States (527), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (527), 51, 674);
Add_Action (Table.States (527), 66, 675);
Add_Error (Table.States (527));
Add_Goto (Table.States (527), 207, 61);
Add_Goto (Table.States (527), 246, 676);
Add_Goto (Table.States (527), 247, 78);
Add_Goto (Table.States (527), 262, 87);
Add_Goto (Table.States (527), 263, 677);
Add_Goto (Table.States (527), 264, 89);
Add_Goto (Table.States (527), 307, 105);
Add_Goto (Table.States (527), 316, 111);
Table.States (527).Kernel := To_Vector ((0 => (315, 77, 6, False)));
Table.States (527).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 246, 0)));
Add_Action (Table.States (528), 4, 1);
Add_Action (Table.States (528), 18, 4);
Add_Action (Table.States (528), 67, 678);
Add_Error (Table.States (528));
Add_Goto (Table.States (528), 113, 679);
Add_Goto (Table.States (528), 160, 680);
Add_Goto (Table.States (528), 161, 533);
Table.States (528).Kernel := To_Vector (((295, 87, 3, False), (295, 87, 2, False), (295, 87, 2, False)));
Table.States (528).Minimal_Complete_Actions := To_Vector (((Shift, 67, 678), (Shift, 18, 4)));
Add_Action (Table.States (529), (13, 17, 28, 37, 73), (131, 0), 2, block_label_0'Access,
block_label_0_check'Access);
Table.States (529).Kernel := To_Vector ((0 => (131, 81, 0, False)));
Table.States (529).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 131, 2)));
Add_Action (Table.States (530), (4, 5, 13, 15, 17, 18, 22, 23, 24, 26, 27, 28, 31, 32, 37, 41, 43, 48, 52,
57, 58, 61, 68, 72, 73, 93, 104, 105, 106), (299, 0), 2, null, null);
Table.States (530).Kernel := To_Vector ((0 => (299, 306, 0, True)));
Table.States (530).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 299, 2)));
Table.States (530).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (531), 24, 681);
Add_Error (Table.States (531));
Table.States (531).Kernel := To_Vector ((0 => (152, 300, 3, False)));
Table.States (531).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 681)));
Add_Action (Table.States (532), 24, 682);
Add_Error (Table.States (532));
Table.States (532).Kernel := To_Vector ((0 => (323, 160, 3, False)));
Table.States (532).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 682)));
Add_Action (Table.States (533), 4, 1);
Add_Action (Table.States (533), 5, 2);
Add_Action (Table.States (533), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (533), 15, 3);
Add_Action (Table.States (533), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (533), 18, 4);
Add_Action (Table.States (533), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (533), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (533), 27, 5);
Add_Action (Table.States (533), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (533), 31, 9);
Add_Action (Table.States (533), 32, 10);
Add_Action (Table.States (533), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (533), 41, 13);
Add_Action (Table.States (533), 43, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (533), 48, 16);
Add_Action (Table.States (533), 52, 20);
Add_Action (Table.States (533), 57, 21);
Add_Action (Table.States (533), 58, 22);
Add_Action (Table.States (533), 61, 24);
Add_Action (Table.States (533), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (533), 93, 31);
Add_Action (Table.States (533), 104, 360);
Add_Action (Table.States (533), 105, 33);
Add_Action (Table.States (533), 106, 34);
Add_Error (Table.States (533));
Add_Goto (Table.States (533), 113, 36);
Add_Goto (Table.States (533), 123, 38);
Add_Goto (Table.States (533), 126, 39);
Add_Goto (Table.States (533), 128, 41);
Add_Goto (Table.States (533), 131, 42);
Add_Goto (Table.States (533), 132, 43);
Add_Goto (Table.States (533), 133, 44);
Add_Goto (Table.States (533), 139, 47);
Add_Goto (Table.States (533), 151, 50);
Add_Goto (Table.States (533), 152, 51);
Add_Goto (Table.States (533), 161, 53);
Add_Goto (Table.States (533), 190, 57);
Add_Goto (Table.States (533), 196, 59);
Add_Goto (Table.States (533), 217, 68);
Add_Goto (Table.States (533), 222, 70);
Add_Goto (Table.States (533), 232, 72);
Add_Goto (Table.States (533), 239, 73);
Add_Goto (Table.States (533), 257, 83);
Add_Goto (Table.States (533), 261, 86);
Add_Goto (Table.States (533), 272, 92);
Add_Goto (Table.States (533), 276, 93);
Add_Goto (Table.States (533), 290, 96);
Add_Goto (Table.States (533), 293, 97);
Add_Goto (Table.States (533), 294, 98);
Add_Goto (Table.States (533), 298, 99);
Add_Goto (Table.States (533), 299, 361);
Add_Goto (Table.States (533), 300, 683);
Add_Goto (Table.States (533), 302, 100);
Add_Goto (Table.States (533), 303, 101);
Add_Goto (Table.States (533), 306, 363);
Add_Goto (Table.States (533), 323, 114);
Table.States (533).Kernel := To_Vector ((0 => (160, 161, 0, False)));
Table.States (533).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (534), (22, 24, 43), (296, 0), 3, select_alternative_list_0'Access, null);
Table.States (534).Kernel := To_Vector ((0 => (296, 295, 0, True)));
Table.States (534).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 296, 3)));
Table.States (534).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (535), 24, 684);
Add_Error (Table.States (535));
Table.States (535).Kernel := To_Vector ((0 => (294, 300, 3, False)));
Table.States (535).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 684)));
Add_Action (Table.States (536), 96, 685);
Add_Error (Table.States (536));
Table.States (536).Kernel := To_Vector ((0 => (294, 61, 1, False)));
Table.States (536).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 685)));
Add_Action (Table.States (537), 4, 1);
Add_Action (Table.States (537), 5, 2);
Add_Action (Table.States (537), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (537), 15, 3);
Add_Action (Table.States (537), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (537), 18, 4);
Add_Action (Table.States (537), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (537), 27, 5);
Add_Action (Table.States (537), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (537), 31, 9);
Add_Action (Table.States (537), 32, 10);
Add_Action (Table.States (537), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (537), 41, 13);
Add_Action (Table.States (537), 48, 16);
Add_Action (Table.States (537), 52, 20);
Add_Action (Table.States (537), 57, 21);
Add_Action (Table.States (537), 58, 22);
Add_Action (Table.States (537), 61, 24);
Add_Action (Table.States (537), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (537), 93, 31);
Add_Action (Table.States (537), 104, 360);
Add_Action (Table.States (537), 105, 33);
Add_Action (Table.States (537), 106, 34);
Add_Error (Table.States (537));
Add_Goto (Table.States (537), 113, 36);
Add_Goto (Table.States (537), 123, 38);
Add_Goto (Table.States (537), 126, 39);
Add_Goto (Table.States (537), 128, 41);
Add_Goto (Table.States (537), 131, 42);
Add_Goto (Table.States (537), 132, 43);
Add_Goto (Table.States (537), 133, 44);
Add_Goto (Table.States (537), 139, 47);
Add_Goto (Table.States (537), 151, 50);
Add_Goto (Table.States (537), 152, 51);
Add_Goto (Table.States (537), 161, 53);
Add_Goto (Table.States (537), 190, 57);
Add_Goto (Table.States (537), 196, 59);
Add_Goto (Table.States (537), 217, 68);
Add_Goto (Table.States (537), 222, 70);
Add_Goto (Table.States (537), 232, 72);
Add_Goto (Table.States (537), 239, 73);
Add_Goto (Table.States (537), 257, 83);
Add_Goto (Table.States (537), 261, 86);
Add_Goto (Table.States (537), 272, 92);
Add_Goto (Table.States (537), 276, 93);
Add_Goto (Table.States (537), 290, 96);
Add_Goto (Table.States (537), 293, 97);
Add_Goto (Table.States (537), 294, 98);
Add_Goto (Table.States (537), 298, 99);
Add_Goto (Table.States (537), 299, 361);
Add_Goto (Table.States (537), 300, 686);
Add_Goto (Table.States (537), 302, 100);
Add_Goto (Table.States (537), 303, 101);
Add_Goto (Table.States (537), 306, 363);
Add_Goto (Table.States (537), 323, 114);
Table.States (537).Kernel := To_Vector ((0 => (126, 5, 3, False)));
Table.States (537).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (538), 74, 337);
Add_Action (Table.States (538), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (538));
Add_Goto (Table.States (538), 122, 687);
Table.States (538).Kernel := To_Vector ((0 => (313, 314, 1, False)));
Table.States (538).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (539), 60, 688);
Add_Error (Table.States (539));
Table.States (539).Kernel := To_Vector ((0 => (317, 35, 2, False)));
Table.States (539).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 60, 688)));
Add_Action (Table.States (540), 35, 689);
Add_Error (Table.States (540));
Table.States (540).Kernel := To_Vector ((0 => (316, 122, 4, False)));
Table.States (540).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 689)));
Add_Action (Table.States (541), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (541), 74, 337);
Add_Action (Table.States (541), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (541));
Add_Goto (Table.States (541), 122, 690);
Table.States (541).Kernel := To_Vector (((319, 169, 6, False), (319, 169, 3, False), (319, 169, 1,
False)));
Table.States (541).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (542), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (542), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (542), 28, 183);
Add_Action (Table.States (542), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (542), 30, 8);
Add_Action (Table.States (542), 39, 691);
Add_Action (Table.States (542), 40, 12);
Add_Action (Table.States (542), 46, 14);
Add_Action (Table.States (542), 47, 15);
Add_Action (Table.States (542), 48, 16);
Add_Action (Table.States (542), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (542), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (542), 51, 19);
Add_Action (Table.States (542), 63, 25);
Add_Action (Table.States (542), 66, 26);
Add_Action (Table.States (542), 69, 27);
Add_Action (Table.States (542), 71, 28);
Add_Action (Table.States (542), 104, 185);
Add_Error (Table.States (542));
Add_Goto (Table.States (542), 112, 35);
Add_Goto (Table.States (542), 121, 37);
Add_Goto (Table.States (542), 127, 40);
Add_Goto (Table.States (542), 134, 45);
Add_Goto (Table.States (542), 135, 46);
Add_Goto (Table.States (542), 157, 391);
Add_Goto (Table.States (542), 158, 392);
Add_Goto (Table.States (542), 159, 692);
Add_Goto (Table.States (542), 179, 54);
Add_Goto (Table.States (542), 182, 55);
Add_Goto (Table.States (542), 186, 56);
Add_Goto (Table.States (542), 193, 58);
Add_Goto (Table.States (542), 206, 60);
Add_Goto (Table.States (542), 207, 61);
Add_Goto (Table.States (542), 209, 62);
Add_Goto (Table.States (542), 210, 63);
Add_Goto (Table.States (542), 213, 64);
Add_Goto (Table.States (542), 214, 65);
Add_Goto (Table.States (542), 215, 66);
Add_Goto (Table.States (542), 216, 67);
Add_Goto (Table.States (542), 219, 69);
Add_Goto (Table.States (542), 223, 71);
Add_Goto (Table.States (542), 243, 74);
Add_Goto (Table.States (542), 244, 75);
Add_Goto (Table.States (542), 245, 76);
Add_Goto (Table.States (542), 246, 77);
Add_Goto (Table.States (542), 247, 78);
Add_Goto (Table.States (542), 248, 79);
Add_Goto (Table.States (542), 249, 80);
Add_Goto (Table.States (542), 250, 81);
Add_Goto (Table.States (542), 251, 82);
Add_Goto (Table.States (542), 257, 394);
Add_Goto (Table.States (542), 259, 84);
Add_Goto (Table.States (542), 260, 85);
Add_Goto (Table.States (542), 262, 87);
Add_Goto (Table.States (542), 263, 88);
Add_Goto (Table.States (542), 264, 89);
Add_Goto (Table.States (542), 265, 90);
Add_Goto (Table.States (542), 271, 91);
Add_Goto (Table.States (542), 281, 94);
Add_Goto (Table.States (542), 289, 95);
Add_Goto (Table.States (542), 304, 102);
Add_Goto (Table.States (542), 305, 103);
Add_Goto (Table.States (542), 307, 105);
Add_Goto (Table.States (542), 308, 106);
Add_Goto (Table.States (542), 309, 107);
Add_Goto (Table.States (542), 311, 108);
Add_Goto (Table.States (542), 313, 109);
Add_Goto (Table.States (542), 316, 111);
Add_Goto (Table.States (542), 317, 112);
Add_Goto (Table.States (542), 318, 693);
Add_Goto (Table.States (542), 319, 113);
Add_Goto (Table.States (542), 325, 115);
Add_Goto (Table.States (542), 331, 116);
Table.States (542).Kernel := To_Vector (((305, 35, 5, False), (305, 35, 2, False)));
Table.States (542).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 318, 0)));
Add_Action (Table.States (543), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (305, 2), 4,
single_task_declaration_2'Access, null);
Table.States (543).Kernel := To_Vector ((0 => (305, 96, 0, False)));
Table.States (543).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 305, 4)));
Add_Action (Table.States (544), 77, 694);
Add_Error (Table.States (544));
Table.States (544).Kernel := To_Vector ((0 => (169, 80, 1, False)));
Table.States (544).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 694)));
Add_Action (Table.States (545), (77, 96), (171, 1), 1, null, null);
Table.States (545).Kernel := To_Vector ((0 => (171, 170, 0, False)));
Table.States (545).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 171, 1)));
Add_Action (Table.States (546), 77, 695);
Add_Action (Table.States (546), 96, 696);
Add_Error (Table.States (546));
Table.States (546).Kernel := To_Vector (((169, 171, 1, False), (171, 171, 1, True)));
Table.States (546).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 695)));
Add_Action (Table.States (547), 81, 697);
Add_Action (Table.States (547), 83, 234);
Add_Error (Table.States (547));
Table.States (547).Kernel := To_Vector (((170, 219, 3, False), (170, 219, 4, False), (170, 219, 2, False),
(170, 219, 3, False), (219, 219, 2, True)));
Table.States (547).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 81, 697)));
Add_Action (Table.States (548), 6, 698);
Add_Action (Table.States (548), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (548), 11, 699);
Add_Action (Table.States (548), 19, 700);
Add_Action (Table.States (548), 20, 701);
Add_Action (Table.States (548), 34, 702);
Add_Action (Table.States (548), 36, 703);
Add_Action (Table.States (548), 38, 704);
Add_Action (Table.States (548), 39, Reduce, (109, 5), 0, null, null);
Add_Conflict (Table.States (548), 39, (110, 3), 0, null, null);
Add_Action (Table.States (548), 40, 386);
Add_Action (Table.States (548), 41, Reduce, (111, 5), 0, null, null);
Add_Action (Table.States (548), 49, Reduce, (111, 5), 0, null, null);
Add_Action (Table.States (548), 51, 706);
Add_Action (Table.States (548), 53, 707);
Add_Action (Table.States (548), 54, Reduce, (111, 5), 0, null, null);
Add_Action (Table.States (548), 64, 709);
Add_Action (Table.States (548), 65, 710);
Add_Action (Table.States (548), 66, 711);
Add_Action (Table.States (548), 76, 712);
Add_Error (Table.States (548));
Add_Goto (Table.States (548), 109, 713);
Add_Goto (Table.States (548), 110, 714);
Add_Goto (Table.States (548), 111, 715);
Add_Goto (Table.States (548), 114, 716);
Add_Goto (Table.States (548), 120, 717);
Add_Goto (Table.States (548), 162, 718);
Add_Goto (Table.States (548), 183, 719);
Add_Goto (Table.States (548), 228, 720);
Add_Goto (Table.States (548), 241, 721);
Add_Goto (Table.States (548), 326, 722);
Table.States (548).Kernel := To_Vector (((206, 35, 2, False), (223, 35, 2, False), (259, 35, 5, False),
(260, 35, 2, False)));
Table.States (548).Minimal_Complete_Actions := To_Vector (((Shift, 38, 704), (Shift, 65, 710), (Reduce,
111, 0)));
Add_Action (Table.States (549), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (223, 1), 4,
incomplete_type_declaration_1'Access, null);
Table.States (549).Kernel := To_Vector ((0 => (223, 96, 0, False)));
Table.States (549).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 223, 4)));
Add_Action (Table.States (550), 83, 381);
Add_Action (Table.States (550), 96, 723);
Add_Error (Table.States (550));
Table.States (550).Kernel := To_Vector (((238, 238, 2, True), (331, 238, 1, False)));
Table.States (550).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 723)));
Add_Action (Table.States (551), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (331, 1), 4,
use_clause_1'Access, null);
Table.States (551).Kernel := To_Vector ((0 => (331, 96, 0, False)));
Table.States (551).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 331, 4)));
end Subr_10;
procedure Subr_11
is begin
Add_Action (Table.States (552), 76, 235);
Add_Action (Table.States (552), 83, Reduce, (238, 0), 3, null, null);
Add_Action (Table.States (552), 84, 237);
Add_Action (Table.States (552), 96, Reduce, (238, 0), 3, null, null);
Add_Action (Table.States (552), 101, 239);
Add_Action (Table.States (552), 102, 240);
Add_Error (Table.States (552));
Add_Goto (Table.States (552), 115, 241);
Add_Goto (Table.States (552), 322, 242);
Table.States (552).Kernel := To_Vector (((128, 239, 2, True), (238, 239, 0, True), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (552).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 238, 3)));
Table.States (552).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (553), 104, 119);
Add_Action (Table.States (553), 105, 33);
Add_Action (Table.States (553), 106, 34);
Add_Error (Table.States (553));
Add_Goto (Table.States (553), 128, 41);
Add_Goto (Table.States (553), 239, 724);
Add_Goto (Table.States (553), 272, 92);
Add_Goto (Table.States (553), 293, 97);
Table.States (553).Kernel := To_Vector ((0 => (245, 56, 2, False)));
Table.States (553).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (554), (7, 21, 35, 56, 74, 77, 82, 96, 104, 105, 106), (241, 0), 2, null, null);
Table.States (554).Kernel := To_Vector ((0 => (241, 41, 0, False)));
Table.States (554).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 241, 2)));
Add_Action (Table.States (555), 104, 119);
Add_Action (Table.States (555), 105, 33);
Add_Action (Table.States (555), 106, 34);
Add_Error (Table.States (555));
Add_Goto (Table.States (555), 128, 41);
Add_Goto (Table.States (555), 239, 725);
Add_Goto (Table.States (555), 272, 92);
Add_Goto (Table.States (555), 293, 97);
Table.States (555).Kernel := To_Vector ((0 => (245, 56, 2, False)));
Table.States (555).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (556), 9, 726);
Add_Action (Table.States (556), 16, 727);
Add_Action (Table.States (556), 29, Reduce, (270, 1), 0, null, null);
Add_Action (Table.States (556), 50, Reduce, (270, 1), 0, null, null);
Add_Action (Table.States (556), 51, 728);
Add_Action (Table.States (556), 104, Reduce, (208, 2), 0, null, null);
Add_Action (Table.States (556), 105, Reduce, (208, 2), 0, null, null);
Add_Action (Table.States (556), 106, Reduce, (208, 2), 0, null, null);
Add_Error (Table.States (556));
Add_Goto (Table.States (556), 208, 729);
Add_Goto (Table.States (556), 270, 730);
Table.States (556).Kernel := To_Vector (((114, 7, 1, False), (114, 7, 2, True), (114, 7, 1, False)));
Table.States (556).Minimal_Complete_Actions := To_Vector (((Reduce, 270, 0), (Reduce, 208, 0)));
Table.States (556).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (557), 56, 731);
Add_Action (Table.States (557), 76, 235);
Add_Action (Table.States (557), 84, 237);
Add_Action (Table.States (557), 101, 239);
Add_Action (Table.States (557), 102, 240);
Add_Error (Table.States (557));
Add_Goto (Table.States (557), 115, 241);
Add_Goto (Table.States (557), 322, 242);
Table.States (557).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(245, 239, 3, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (557).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 56, 731)));
Add_Action (Table.States (558), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (558), 104, 149);
Add_Error (Table.States (558));
Add_Goto (Table.States (558), 220, 732);
Table.States (558).Kernel := To_Vector ((0 => (133, 24, 1, False)));
Table.States (558).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (559), 24, Reduce, (189, 1), 0, null, null);
Add_Action (Table.States (559), 48, 16);
Add_Action (Table.States (559), 72, 733);
Add_Error (Table.States (559));
Add_Goto (Table.States (559), 187, 734);
Add_Goto (Table.States (559), 188, 735);
Add_Goto (Table.States (559), 189, 736);
Add_Goto (Table.States (559), 257, 737);
Table.States (559).Kernel := To_Vector ((0 => (218, 26, 0, False)));
Table.States (559).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 189, 0)));
Add_Action (Table.States (560), (13, 24, 25, 28, 29, 30, 40, 46, 47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
(158, 0), 2, null, null);
Table.States (560).Kernel := To_Vector ((0 => (158, 157, 0, True)));
Table.States (560).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 158, 2)));
Table.States (560).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (561), (13, 24, 25, 28, 29, 30, 40, 46, 47, 48, 49, 50, 51, 63, 66, 69, 71, 104),
(158, 1), 2, null, null);
Table.States (561).Kernel := To_Vector ((0 => (158, 257, 0, True)));
Table.States (561).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 158, 2)));
Table.States (561).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (562), 4, 1);
Add_Action (Table.States (562), 5, 2);
Add_Action (Table.States (562), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (562), 15, 3);
Add_Action (Table.States (562), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (562), 18, 4);
Add_Action (Table.States (562), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (562), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (562), 27, 5);
Add_Action (Table.States (562), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (562), 31, 9);
Add_Action (Table.States (562), 32, 10);
Add_Action (Table.States (562), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (562), 41, 13);
Add_Action (Table.States (562), 48, 16);
Add_Action (Table.States (562), 52, 20);
Add_Action (Table.States (562), 57, 21);
Add_Action (Table.States (562), 58, 22);
Add_Action (Table.States (562), 61, 24);
Add_Action (Table.States (562), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (562), 93, 31);
Add_Action (Table.States (562), 104, 360);
Add_Action (Table.States (562), 105, 33);
Add_Action (Table.States (562), 106, 34);
Add_Error (Table.States (562));
Add_Goto (Table.States (562), 113, 36);
Add_Goto (Table.States (562), 123, 38);
Add_Goto (Table.States (562), 126, 39);
Add_Goto (Table.States (562), 128, 41);
Add_Goto (Table.States (562), 131, 42);
Add_Goto (Table.States (562), 132, 43);
Add_Goto (Table.States (562), 133, 44);
Add_Goto (Table.States (562), 139, 47);
Add_Goto (Table.States (562), 151, 50);
Add_Goto (Table.States (562), 152, 51);
Add_Goto (Table.States (562), 161, 53);
Add_Goto (Table.States (562), 190, 57);
Add_Goto (Table.States (562), 196, 59);
Add_Goto (Table.States (562), 217, 68);
Add_Goto (Table.States (562), 218, 738);
Add_Goto (Table.States (562), 222, 70);
Add_Goto (Table.States (562), 232, 72);
Add_Goto (Table.States (562), 239, 73);
Add_Goto (Table.States (562), 257, 83);
Add_Goto (Table.States (562), 261, 86);
Add_Goto (Table.States (562), 272, 92);
Add_Goto (Table.States (562), 276, 93);
Add_Goto (Table.States (562), 290, 96);
Add_Goto (Table.States (562), 293, 97);
Add_Goto (Table.States (562), 294, 98);
Add_Goto (Table.States (562), 298, 99);
Add_Goto (Table.States (562), 299, 361);
Add_Goto (Table.States (562), 300, 390);
Add_Goto (Table.States (562), 302, 100);
Add_Goto (Table.States (562), 303, 101);
Add_Goto (Table.States (562), 306, 363);
Add_Goto (Table.States (562), 323, 114);
Table.States (562).Kernel := To_Vector ((0 => (133, 13, 2, False)));
Table.States (562).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (563), 37, 739);
Add_Error (Table.States (563));
Table.States (563).Kernel := To_Vector ((0 => (232, 24, 2, False)));
Table.States (563).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 739)));
Add_Action (Table.States (564), 24, 740);
Add_Error (Table.States (564));
Table.States (564).Kernel := To_Vector ((0 => (232, 300, 3, False)));
Table.States (564).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 740)));
Add_Action (Table.States (565), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (216, 0), 4,
generic_subprogram_declaration_0'Access, null);
Table.States (565).Kernel := To_Vector ((0 => (216, 96, 0, False)));
Table.States (565).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 216, 4)));
Add_Action (Table.States (566), 3, 121);
Add_Action (Table.States (566), 39, 122);
Add_Action (Table.States (566), 40, 123);
Add_Action (Table.States (566), 41, 124);
Add_Action (Table.States (566), 52, 125);
Add_Action (Table.States (566), 76, 126);
Add_Action (Table.States (566), 94, 127);
Add_Action (Table.States (566), 95, 128);
Add_Action (Table.States (566), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (566), 103, 129);
Add_Action (Table.States (566), 104, 119);
Add_Action (Table.States (566), 105, 33);
Add_Action (Table.States (566), 106, 34);
Add_Error (Table.States (566));
Add_Goto (Table.States (566), 117, 130);
Add_Goto (Table.States (566), 128, 41);
Add_Goto (Table.States (566), 191, 131);
Add_Goto (Table.States (566), 192, 741);
Add_Goto (Table.States (566), 197, 133);
Add_Goto (Table.States (566), 239, 134);
Add_Goto (Table.States (566), 258, 135);
Add_Goto (Table.States (566), 272, 92);
Add_Goto (Table.States (566), 275, 136);
Add_Goto (Table.States (566), 282, 137);
Add_Goto (Table.States (566), 283, 138);
Add_Goto (Table.States (566), 284, 139);
Add_Goto (Table.States (566), 285, 140);
Add_Goto (Table.States (566), 286, 141);
Add_Goto (Table.States (566), 287, 142);
Add_Goto (Table.States (566), 293, 97);
Add_Goto (Table.States (566), 301, 143);
Add_Goto (Table.States (566), 320, 144);
Add_Goto (Table.States (566), 321, 145);
Add_Goto (Table.States (566), 330, 146);
Table.States (566).Kernel := To_Vector ((0 => (157, 82, 1, False)));
Table.States (566).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (567), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (186, 0), 4,
exception_declaration_0'Access, null);
Table.States (567).Kernel := To_Vector ((0 => (186, 96, 0, False)));
Table.States (567).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 186, 4)));
Add_Action (Table.States (568), (7, 11, 21, 40, 74, 82, 96, 104, 105, 106), (154, 0), 1, null, null);
Table.States (568).Kernel := To_Vector ((0 => (154, 16, 0, False)));
Table.States (568).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 154, 1)));
Add_Action (Table.States (569), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (569), 11, 699);
Add_Action (Table.States (569), 40, 742);
Add_Action (Table.States (569), 104, 119);
Add_Action (Table.States (569), 105, 33);
Add_Action (Table.States (569), 106, 34);
Add_Error (Table.States (569));
Add_Goto (Table.States (569), 114, 743);
Add_Goto (Table.States (569), 120, 744);
Add_Goto (Table.States (569), 128, 41);
Add_Goto (Table.States (569), 239, 484);
Add_Goto (Table.States (569), 241, 721);
Add_Goto (Table.States (569), 272, 92);
Add_Goto (Table.States (569), 293, 97);
Add_Goto (Table.States (569), 314, 745);
Table.States (569).Kernel := To_Vector (((244, 154, 3, False), (244, 154, 4, False), (244, 154, 10, False),
(244, 154, 2, False), (244, 154, 3, False), (244, 154, 9, False)));
Table.States (569).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (570), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (115, 0), 3,
actual_parameter_part_0'Access, null);
Table.States (570).Kernel := To_Vector ((0 => (115, 77, 0, False)));
Table.States (570).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 115, 3)));
Add_Action (Table.States (571), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (115, 1), 3,
actual_parameter_part_1'Access, null);
Table.States (571).Kernel := To_Vector ((0 => (115, 77, 0, False)));
Table.States (571).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 115, 3)));
Add_Action (Table.States (572), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (239, 0), 4, name_0'Access,
null);
Table.States (572).Kernel := To_Vector ((0 => (239, 77, 0, True)));
Table.States (572).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 4)));
Table.States (572).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (573), 3, 121);
Add_Action (Table.States (573), 39, 122);
Add_Action (Table.States (573), 40, 123);
Add_Action (Table.States (573), 41, 124);
Add_Action (Table.States (573), 76, 126);
Add_Action (Table.States (573), 94, 127);
Add_Action (Table.States (573), 95, 128);
Add_Action (Table.States (573), 103, 129);
Add_Action (Table.States (573), 104, 119);
Add_Action (Table.States (573), 105, 33);
Add_Action (Table.States (573), 106, 34);
Add_Error (Table.States (573));
Add_Goto (Table.States (573), 117, 130);
Add_Goto (Table.States (573), 128, 41);
Add_Goto (Table.States (573), 197, 133);
Add_Goto (Table.States (573), 239, 274);
Add_Goto (Table.States (573), 258, 135);
Add_Goto (Table.States (573), 272, 92);
Add_Goto (Table.States (573), 277, 746);
Add_Goto (Table.States (573), 293, 97);
Add_Goto (Table.States (573), 301, 479);
Add_Goto (Table.States (573), 320, 144);
Add_Goto (Table.States (573), 321, 145);
Add_Goto (Table.States (573), 330, 146);
Table.States (573).Kernel := To_Vector ((0 => (278, 83, 3, True)));
Table.States (573).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Table.States (573).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (574), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (123, 0), 4, assignment_statement_0'Access, null);
Table.States (574).Kernel := To_Vector ((0 => (123, 96, 0, False)));
Table.States (574).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 123, 4)));
Add_Action (Table.States (575), 3, 121);
Add_Action (Table.States (575), 39, 122);
Add_Action (Table.States (575), 40, 474);
Add_Action (Table.States (575), 41, 124);
Add_Action (Table.States (575), 76, 126);
Add_Action (Table.States (575), 77, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (575), 94, 127);
Add_Action (Table.States (575), 95, 128);
Add_Action (Table.States (575), 96, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (575), 103, 129);
Add_Action (Table.States (575), 104, 492);
Add_Action (Table.States (575), 105, 33);
Add_Action (Table.States (575), 106, 34);
Add_Error (Table.States (575));
Add_Goto (Table.States (575), 117, 130);
Add_Goto (Table.States (575), 128, 41);
Add_Goto (Table.States (575), 167, 747);
Add_Goto (Table.States (575), 197, 133);
Add_Goto (Table.States (575), 219, 493);
Add_Goto (Table.States (575), 239, 477);
Add_Goto (Table.States (575), 254, 494);
Add_Goto (Table.States (575), 255, 495);
Add_Goto (Table.States (575), 258, 135);
Add_Goto (Table.States (575), 272, 92);
Add_Goto (Table.States (575), 277, 478);
Add_Goto (Table.States (575), 293, 97);
Add_Goto (Table.States (575), 301, 479);
Add_Goto (Table.States (575), 314, 480);
Add_Goto (Table.States (575), 320, 144);
Add_Goto (Table.States (575), 321, 145);
Add_Goto (Table.States (575), 330, 146);
Table.States (575).Kernel := To_Vector (((179, 76, 3, False), (199, 76, 1, False)));
Table.States (575).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 255, 0)));
Add_Action (Table.States (576), 74, 337);
Add_Action (Table.States (576), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (576));
Add_Goto (Table.States (576), 122, 748);
Table.States (576).Kernel := To_Vector ((0 => (179, 253, 1, False)));
Table.States (576).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (577), 39, 749);
Add_Error (Table.States (577));
Table.States (577).Kernel := To_Vector ((0 => (213, 35, 3, False)));
Table.States (577).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 39, 749)));
Add_Action (Table.States (578), 39, 750);
Add_Error (Table.States (578));
Table.States (578).Kernel := To_Vector ((0 => (213, 35, 3, False)));
Table.States (578).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 39, 750)));
Add_Action (Table.States (579), 3, 121);
Add_Action (Table.States (579), 15, 258);
Add_Action (Table.States (579), 28, 259);
Add_Action (Table.States (579), 32, 260);
Add_Action (Table.States (579), 39, 122);
Add_Action (Table.States (579), 40, 261);
Add_Action (Table.States (579), 41, 124);
Add_Action (Table.States (579), 44, 263);
Add_Action (Table.States (579), 52, 125);
Add_Action (Table.States (579), 76, 126);
Add_Action (Table.States (579), 77, Reduce, (124, 5), 0, null, null);
Add_Conflict (Table.States (579), 77, (192, 1), 0, null, null);
Add_Action (Table.States (579), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (579), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (579), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (579), 94, 127);
Add_Action (Table.States (579), 95, 128);
Add_Action (Table.States (579), 103, 129);
Add_Action (Table.States (579), 104, 119);
Add_Action (Table.States (579), 105, 33);
Add_Action (Table.States (579), 106, 264);
Add_Error (Table.States (579));
Add_Goto (Table.States (579), 117, 130);
Add_Goto (Table.States (579), 124, 265);
Add_Goto (Table.States (579), 125, 751);
Add_Goto (Table.States (579), 128, 41);
Add_Goto (Table.States (579), 136, 267);
Add_Goto (Table.States (579), 153, 752);
Add_Goto (Table.States (579), 165, 269);
Add_Goto (Table.States (579), 166, 270);
Add_Goto (Table.States (579), 191, 271);
Add_Goto (Table.States (579), 192, 753);
Add_Goto (Table.States (579), 197, 133);
Add_Goto (Table.States (579), 221, 273);
Add_Goto (Table.States (579), 239, 274);
Add_Goto (Table.States (579), 258, 135);
Add_Goto (Table.States (579), 272, 92);
Add_Goto (Table.States (579), 273, 275);
Add_Goto (Table.States (579), 275, 136);
Add_Goto (Table.States (579), 277, 276);
Add_Goto (Table.States (579), 282, 137);
Add_Goto (Table.States (579), 283, 138);
Add_Goto (Table.States (579), 284, 139);
Add_Goto (Table.States (579), 285, 140);
Add_Goto (Table.States (579), 286, 141);
Add_Goto (Table.States (579), 287, 142);
Add_Goto (Table.States (579), 293, 97);
Add_Goto (Table.States (579), 301, 277);
Add_Goto (Table.States (579), 320, 144);
Add_Goto (Table.States (579), 321, 145);
Add_Goto (Table.States (579), 330, 146);
Table.States (579).Kernel := To_Vector (((256, 76, 1, False), (256, 76, 1, False), (256, 76, 3, False)));
Table.States (579).Minimal_Complete_Actions := To_Vector (((Reduce, 192, 0), (Reduce, 125, 0)));
Add_Action (Table.States (580), 74, 337);
Add_Action (Table.States (580), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (580));
Add_Goto (Table.States (580), 122, 754);
Table.States (580).Kernel := To_Vector ((0 => (193, 256, 1, False)));
Table.States (580).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (581), 74, 337);
Add_Action (Table.States (581), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (581));
Add_Goto (Table.States (581), 122, 755);
Table.States (581).Kernel := To_Vector ((0 => (243, 41, 1, False)));
Table.States (581).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (582), 74, 337);
Add_Action (Table.States (582), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (582));
Add_Goto (Table.States (582), 122, 756);
Table.States (582).Kernel := To_Vector ((0 => (112, 6, 1, False)));
Table.States (582).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (583), 74, 337);
Add_Action (Table.States (583), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (583));
Add_Goto (Table.States (583), 122, 757);
Table.States (583).Kernel := To_Vector ((0 => (308, 60, 1, False)));
Table.States (583).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (584), 74, 337);
Add_Action (Table.States (584), 76, 235);
Add_Action (Table.States (584), 84, 237);
Add_Action (Table.States (584), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (584), 101, 239);
Add_Action (Table.States (584), 102, 240);
Add_Error (Table.States (584));
Add_Goto (Table.States (584), 115, 241);
Add_Goto (Table.States (584), 122, 758);
Add_Goto (Table.States (584), 322, 242);
Table.States (584).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(311, 239, 1, False)));
Table.States (584).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (585), 13, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (585), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (585), 28, 183);
Add_Action (Table.States (585), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (585), 30, 8);
Add_Action (Table.States (585), 40, 12);
Add_Action (Table.States (585), 46, 14);
Add_Action (Table.States (585), 47, 15);
Add_Action (Table.States (585), 48, 16);
Add_Action (Table.States (585), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (585), 51, 19);
Add_Action (Table.States (585), 63, 25);
Add_Action (Table.States (585), 66, 26);
Add_Action (Table.States (585), 69, 27);
Add_Action (Table.States (585), 71, 28);
Add_Action (Table.States (585), 104, 185);
Add_Error (Table.States (585));
Add_Goto (Table.States (585), 112, 35);
Add_Goto (Table.States (585), 121, 37);
Add_Goto (Table.States (585), 127, 40);
Add_Goto (Table.States (585), 134, 45);
Add_Goto (Table.States (585), 135, 46);
Add_Goto (Table.States (585), 157, 391);
Add_Goto (Table.States (585), 158, 392);
Add_Goto (Table.States (585), 159, 759);
Add_Goto (Table.States (585), 179, 54);
Add_Goto (Table.States (585), 182, 55);
Add_Goto (Table.States (585), 186, 56);
Add_Goto (Table.States (585), 193, 58);
Add_Goto (Table.States (585), 206, 60);
Add_Goto (Table.States (585), 207, 61);
Add_Goto (Table.States (585), 209, 62);
Add_Goto (Table.States (585), 210, 63);
Add_Goto (Table.States (585), 213, 64);
Add_Goto (Table.States (585), 214, 65);
Add_Goto (Table.States (585), 215, 66);
Add_Goto (Table.States (585), 216, 67);
Add_Goto (Table.States (585), 219, 69);
Add_Goto (Table.States (585), 223, 71);
Add_Goto (Table.States (585), 243, 74);
Add_Goto (Table.States (585), 244, 75);
Add_Goto (Table.States (585), 245, 76);
Add_Goto (Table.States (585), 246, 77);
Add_Goto (Table.States (585), 247, 78);
Add_Goto (Table.States (585), 248, 79);
Add_Goto (Table.States (585), 249, 80);
Add_Goto (Table.States (585), 250, 81);
Add_Goto (Table.States (585), 251, 82);
Add_Goto (Table.States (585), 257, 394);
Add_Goto (Table.States (585), 259, 84);
Add_Goto (Table.States (585), 260, 85);
Add_Goto (Table.States (585), 262, 87);
Add_Goto (Table.States (585), 263, 88);
Add_Goto (Table.States (585), 264, 89);
Add_Goto (Table.States (585), 265, 90);
Add_Goto (Table.States (585), 271, 91);
Add_Goto (Table.States (585), 281, 94);
Add_Goto (Table.States (585), 289, 95);
Add_Goto (Table.States (585), 304, 102);
Add_Goto (Table.States (585), 305, 103);
Add_Goto (Table.States (585), 307, 105);
Add_Goto (Table.States (585), 308, 106);
Add_Goto (Table.States (585), 309, 107);
Add_Goto (Table.States (585), 311, 108);
Add_Goto (Table.States (585), 313, 109);
Add_Goto (Table.States (585), 316, 111);
Add_Goto (Table.States (585), 317, 112);
Add_Goto (Table.States (585), 319, 113);
Add_Goto (Table.States (585), 325, 115);
Add_Goto (Table.States (585), 331, 116);
Table.States (585).Kernel := To_Vector ((0 => (307, 35, 3, False)));
Table.States (585).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (586), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (309, 0), 4,
subprogram_declaration_0'Access, null);
Table.States (586).Kernel := To_Vector ((0 => (309, 96, 0, False)));
Table.States (586).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 309, 4)));
Add_Action (Table.States (587), 4, 1);
Add_Action (Table.States (587), 5, 2);
Add_Action (Table.States (587), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (587), 15, 3);
Add_Action (Table.States (587), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (587), 18, 4);
Add_Action (Table.States (587), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (587), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (587), 27, 5);
Add_Action (Table.States (587), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (587), 31, 9);
Add_Action (Table.States (587), 32, 10);
Add_Action (Table.States (587), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (587), 41, 13);
Add_Action (Table.States (587), 48, 16);
Add_Action (Table.States (587), 52, 20);
Add_Action (Table.States (587), 57, 21);
Add_Action (Table.States (587), 58, 22);
Add_Action (Table.States (587), 61, 24);
Add_Action (Table.States (587), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (587), 93, 31);
Add_Action (Table.States (587), 104, 360);
Add_Action (Table.States (587), 105, 33);
Add_Action (Table.States (587), 106, 34);
Add_Error (Table.States (587));
Add_Goto (Table.States (587), 113, 36);
Add_Goto (Table.States (587), 123, 38);
Add_Goto (Table.States (587), 126, 39);
Add_Goto (Table.States (587), 128, 41);
Add_Goto (Table.States (587), 131, 42);
Add_Goto (Table.States (587), 132, 43);
Add_Goto (Table.States (587), 133, 44);
Add_Goto (Table.States (587), 139, 47);
Add_Goto (Table.States (587), 151, 50);
Add_Goto (Table.States (587), 152, 51);
Add_Goto (Table.States (587), 161, 53);
Add_Goto (Table.States (587), 190, 57);
Add_Goto (Table.States (587), 196, 59);
Add_Goto (Table.States (587), 217, 68);
Add_Goto (Table.States (587), 218, 760);
Add_Goto (Table.States (587), 222, 70);
Add_Goto (Table.States (587), 232, 72);
Add_Goto (Table.States (587), 239, 73);
Add_Goto (Table.States (587), 257, 83);
Add_Goto (Table.States (587), 261, 86);
Add_Goto (Table.States (587), 272, 92);
Add_Goto (Table.States (587), 276, 93);
Add_Goto (Table.States (587), 290, 96);
Add_Goto (Table.States (587), 293, 97);
Add_Goto (Table.States (587), 294, 98);
Add_Goto (Table.States (587), 298, 99);
Add_Goto (Table.States (587), 299, 361);
Add_Goto (Table.States (587), 300, 390);
Add_Goto (Table.States (587), 302, 100);
Add_Goto (Table.States (587), 303, 101);
Add_Goto (Table.States (587), 306, 363);
Add_Goto (Table.States (587), 323, 114);
Table.States (587).Kernel := To_Vector ((0 => (113, 21, 2, False)));
Table.States (587).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (588), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (113, 1), 5, accept_statement_1'Access, null);
Table.States (588).Kernel := To_Vector ((0 => (113, 96, 0, False)));
Table.States (588).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 113, 5)));
Add_Action (Table.States (589), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (275,
0), 4, raise_expression_0'Access, null);
Table.States (589).Kernel := To_Vector ((0 => (275, 192, 0, True)));
Table.States (589).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 275, 4)));
Table.States (589).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (590), 72, 761);
Add_Error (Table.States (590));
Add_Goto (Table.States (590), 137, 762);
Add_Goto (Table.States (590), 138, 763);
Table.States (590).Kernel := To_Vector ((0 => (136, 35, 2, False)));
Table.States (590).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 72, 761)));
Add_Action (Table.States (591), 87, 764);
Add_Error (Table.States (591));
Table.States (591).Kernel := To_Vector ((0 => (273, 230, 1, False)));
Table.States (591).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 764)));
Add_Action (Table.States (592), 3, 121);
Add_Action (Table.States (592), 22, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (592), 23, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (592), 39, 122);
Add_Action (Table.States (592), 40, 123);
Add_Action (Table.States (592), 41, 124);
Add_Action (Table.States (592), 52, 125);
Add_Action (Table.States (592), 76, 126);
Add_Action (Table.States (592), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (592), 94, 127);
Add_Action (Table.States (592), 95, 128);
Add_Action (Table.States (592), 103, 129);
Add_Action (Table.States (592), 104, 119);
Add_Action (Table.States (592), 105, 33);
Add_Action (Table.States (592), 106, 34);
Add_Error (Table.States (592));
Add_Goto (Table.States (592), 117, 130);
Add_Goto (Table.States (592), 128, 41);
Add_Goto (Table.States (592), 191, 131);
Add_Goto (Table.States (592), 192, 765);
Add_Goto (Table.States (592), 197, 133);
Add_Goto (Table.States (592), 239, 134);
Add_Goto (Table.States (592), 258, 135);
Add_Goto (Table.States (592), 272, 92);
Add_Goto (Table.States (592), 275, 136);
Add_Goto (Table.States (592), 282, 137);
Add_Goto (Table.States (592), 283, 138);
Add_Goto (Table.States (592), 284, 139);
Add_Goto (Table.States (592), 285, 140);
Add_Goto (Table.States (592), 286, 141);
Add_Goto (Table.States (592), 287, 142);
Add_Goto (Table.States (592), 293, 97);
Add_Goto (Table.States (592), 301, 143);
Add_Goto (Table.States (592), 320, 144);
Add_Goto (Table.States (592), 321, 145);
Add_Goto (Table.States (592), 330, 146);
Table.States (592).Kernel := To_Vector (((221, 68, 3, False), (221, 68, 1, False), (221, 68, 2, False),
(221, 68, 0, False)));
Table.States (592).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (593), 76, 235);
Add_Action (Table.States (593), 79, Reduce, (165, 1), 3, null, null);
Add_Action (Table.States (593), 84, 237);
Add_Action (Table.States (593), 87, Reduce, (165, 1), 3, null, null);
Add_Action (Table.States (593), 101, 239);
Add_Action (Table.States (593), 102, 240);
Add_Error (Table.States (593));
Add_Goto (Table.States (593), 115, 241);
Add_Goto (Table.States (593), 322, 242);
Table.States (593).Kernel := To_Vector (((128, 239, 2, True), (165, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (593).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 165, 3)));
Add_Action (Table.States (594), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (117, 2), 4, null, null);
Table.States (594).Kernel := To_Vector ((0 => (117, 77, 0, False)));
Table.States (594).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 117, 4)));
Add_Action (Table.States (595), (35, 77, 83, 96), (124, 1), 3, null, null);
Table.States (595).Kernel := To_Vector ((0 => (124, 80, 0, False)));
Table.States (595).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 124, 3)));
Add_Action (Table.States (596), (35, 77, 83, 96), (124, 0), 3, association_opt_0'Access, null);
Table.States (596).Kernel := To_Vector ((0 => (124, 192, 0, False)));
Table.States (596).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 124, 3)));
Add_Action (Table.States (597), (35, 77, 83, 96), (125, 0), 3, null, null);
Table.States (597).Kernel := To_Vector ((0 => (125, 124, 0, True)));
Table.States (597).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 3)));
Table.States (597).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (598), (79, 87), (166, 0), 3, null, null);
Table.States (598).Kernel := To_Vector ((0 => (166, 165, 0, True)));
Table.States (598).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 166, 3)));
Table.States (598).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (599), (79, 87), (165, 0), 1, null, null);
Table.States (599).Kernel := To_Vector ((0 => (165, 191, 0, False)));
Table.States (599).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 165, 1)));
Add_Action (Table.States (600), (35, 77, 83, 96), (124, 3), 3, association_opt_3'Access, null);
Table.States (600).Kernel := To_Vector ((0 => (124, 80, 0, False)));
Table.States (600).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 124, 3)));
Add_Action (Table.States (601), (35, 77, 83, 96), (124, 2), 3, association_opt_2'Access, null);
Table.States (601).Kernel := To_Vector ((0 => (124, 192, 0, False)));
Table.States (601).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 124, 3)));
Add_Action (Table.States (602), 10, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 33, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 38, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 40, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 43, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 54, 766);
Add_Action (Table.States (602), 55, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 75, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 77, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 78, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 79, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 83, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 85, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 86, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 87, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 88, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 89, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 91, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 92, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 94, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 95, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 97, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 98, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 99, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (602), 100, Reduce, (258, 1), 1, null, null);
Add_Error (Table.States (602));
Table.States (602).Kernel := To_Vector (((117, 41, 2, False), (258, 41, 0, False)));
Table.States (602).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (603), 77, 767);
Add_Action (Table.States (603), 83, 443);
Add_Error (Table.States (603));
Table.States (603).Kernel := To_Vector (((117, 125, 1, False), (125, 125, 1, True)));
Table.States (603).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 767)));
Add_Action (Table.States (604), 10, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 20, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 21, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 22, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 23, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 35, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 37, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 42, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 43, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 53, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 68, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 74, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 75, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 76, 768);
Add_Action (Table.States (604), 77, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 79, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 82, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 83, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 87, Reduce, (277, 1), 3, null, null);
Add_Action (Table.States (604), 96, Reduce, (277, 1), 3, null, null);
Add_Error (Table.States (604));
Table.States (604).Kernel := To_Vector (((277, 53, 2, False), (277, 53, 0, False)));
Table.States (604).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 277, 3)));
end Subr_11;
procedure Subr_12
is begin
Add_Action (Table.States (605), (10, 20, 21, 22, 23, 35, 37, 42, 43, 53, 68, 74, 75, 77, 79, 82, 83, 87,
96), (277, 2), 3, null, null);
Table.States (605).Kernel := To_Vector ((0 => (277, 301, 0, False)));
Table.States (605).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 277, 3)));
Add_Action (Table.States (606), 79, 445);
Add_Action (Table.States (606), 87, 769);
Add_Error (Table.States (606));
Table.States (606).Kernel := To_Vector (((140, 166, 1, False), (166, 166, 2, True)));
Table.States (606).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 769)));
Add_Action (Table.States (607), 15, 770);
Add_Error (Table.States (607));
Table.States (607).Kernel := To_Vector ((0 => (139, 24, 2, False)));
Table.States (607).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 15, 770)));
Add_Action (Table.States (608), (24, 72), (141, 0), 2, null, null);
Table.States (608).Kernel := To_Vector ((0 => (141, 140, 0, True)));
Table.States (608).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 141, 2)));
Table.States (608).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (609), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (283,
0), 4, null, null);
Table.States (609).Kernel := To_Vector ((0 => (283, 287, 0, True)));
Table.States (609).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 283, 4)));
Table.States (609).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (610), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (285,
0), 4, null, null);
Table.States (610).Kernel := To_Vector ((0 => (285, 287, 0, True)));
Table.States (610).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 285, 4)));
Table.States (610).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (611), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (283,
1), 4, null, null);
Table.States (611).Kernel := To_Vector ((0 => (283, 287, 0, True)));
Table.States (611).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 283, 4)));
Table.States (611).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (612), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (285,
1), 4, null, null);
Table.States (612).Kernel := To_Vector ((0 => (285, 287, 0, True)));
Table.States (612).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 285, 4)));
Table.States (612).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (613), 3, 121);
Add_Action (Table.States (613), 39, 122);
Add_Action (Table.States (613), 40, 123);
Add_Action (Table.States (613), 41, 124);
Add_Action (Table.States (613), 76, 126);
Add_Action (Table.States (613), 94, 127);
Add_Action (Table.States (613), 95, 128);
Add_Action (Table.States (613), 103, 129);
Add_Action (Table.States (613), 104, 119);
Add_Action (Table.States (613), 105, 33);
Add_Action (Table.States (613), 106, 34);
Add_Error (Table.States (613));
Add_Goto (Table.States (613), 117, 130);
Add_Goto (Table.States (613), 128, 41);
Add_Goto (Table.States (613), 197, 133);
Add_Goto (Table.States (613), 234, 771);
Add_Goto (Table.States (613), 239, 274);
Add_Goto (Table.States (613), 258, 135);
Add_Goto (Table.States (613), 272, 92);
Add_Goto (Table.States (613), 277, 466);
Add_Goto (Table.States (613), 293, 97);
Add_Goto (Table.States (613), 301, 467);
Add_Goto (Table.States (613), 320, 144);
Add_Goto (Table.States (613), 321, 145);
Add_Goto (Table.States (613), 330, 146);
Table.States (613).Kernel := To_Vector ((0 => (233, 79, 1, True)));
Table.States (613).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Table.States (613).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (614), 10, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 20, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 21, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 22, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 23, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 35, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 37, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 43, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 53, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 68, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 74, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 75, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 77, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 79, 613);
Add_Conflict (Table.States (614), 79, (287, 0), 4, null, null);
Add_Action (Table.States (614), 83, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 87, Reduce, (287, 0), 4, null, null);
Add_Action (Table.States (614), 96, Reduce, (287, 0), 4, null, null);
Add_Error (Table.States (614));
Table.States (614).Kernel := To_Vector (((233, 233, 2, True), (287, 233, 0, False)));
Table.States (614).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 287, 4)));
Add_Action (Table.States (615), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (190, 0), 5, exit_statement_0'Access, null);
Table.States (615).Kernel := To_Vector ((0 => (190, 96, 0, False)));
Table.States (615).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 190, 5)));
Add_Action (Table.States (616), 38, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 55, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 78, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 85, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 94, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 95, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 97, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 99, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (616), 104, 119);
Add_Action (Table.States (616), 105, 33);
Add_Action (Table.States (616), 106, 34);
Add_Error (Table.States (616));
Add_Goto (Table.States (616), 128, 41);
Add_Goto (Table.States (616), 239, 772);
Add_Goto (Table.States (616), 272, 92);
Add_Goto (Table.States (616), 293, 97);
Table.States (616).Kernel := To_Vector (((258, 41, 0, False), (314, 41, 5, False), (314, 41, 1, False)));
Table.States (616).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (617), (37, 87), (230, 2), 4, iterator_specification_2'Access, null);
Table.States (617).Kernel := To_Vector ((0 => (230, 167, 0, False)));
Table.States (617).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 230, 4)));
Add_Action (Table.States (618), 3, 121);
Add_Action (Table.States (618), 39, 122);
Add_Action (Table.States (618), 40, 123);
Add_Action (Table.States (618), 41, 124);
Add_Action (Table.States (618), 76, 126);
Add_Action (Table.States (618), 94, 127);
Add_Action (Table.States (618), 95, 128);
Add_Action (Table.States (618), 103, 129);
Add_Action (Table.States (618), 104, 119);
Add_Action (Table.States (618), 105, 33);
Add_Action (Table.States (618), 106, 34);
Add_Error (Table.States (618));
Add_Goto (Table.States (618), 117, 130);
Add_Goto (Table.States (618), 128, 41);
Add_Goto (Table.States (618), 197, 133);
Add_Goto (Table.States (618), 239, 274);
Add_Goto (Table.States (618), 258, 135);
Add_Goto (Table.States (618), 272, 92);
Add_Goto (Table.States (618), 277, 773);
Add_Goto (Table.States (618), 293, 97);
Add_Goto (Table.States (618), 301, 479);
Add_Goto (Table.States (618), 320, 144);
Add_Goto (Table.States (618), 321, 145);
Add_Goto (Table.States (618), 330, 146);
Table.States (618).Kernel := To_Vector ((0 => (155, 53, 3, False)));
Table.States (618).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (619), 3, 121);
Add_Action (Table.States (619), 15, 258);
Add_Action (Table.States (619), 28, 259);
Add_Action (Table.States (619), 32, 260);
Add_Action (Table.States (619), 39, 122);
Add_Action (Table.States (619), 40, 774);
Add_Action (Table.States (619), 41, 124);
Add_Action (Table.States (619), 44, 263);
Add_Action (Table.States (619), 52, 125);
Add_Action (Table.States (619), 76, 126);
Add_Action (Table.States (619), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (619), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (619), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (619), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (619), 94, 127);
Add_Action (Table.States (619), 95, 128);
Add_Action (Table.States (619), 103, 129);
Add_Action (Table.States (619), 104, 119);
Add_Action (Table.States (619), 105, 33);
Add_Action (Table.States (619), 106, 264);
Add_Error (Table.States (619));
Add_Goto (Table.States (619), 117, 130);
Add_Goto (Table.States (619), 124, 265);
Add_Goto (Table.States (619), 125, 406);
Add_Goto (Table.States (619), 128, 41);
Add_Goto (Table.States (619), 136, 267);
Add_Goto (Table.States (619), 153, 407);
Add_Goto (Table.States (619), 165, 269);
Add_Goto (Table.States (619), 166, 270);
Add_Goto (Table.States (619), 167, 775);
Add_Goto (Table.States (619), 168, 776);
Add_Goto (Table.States (619), 191, 408);
Add_Goto (Table.States (619), 197, 133);
Add_Goto (Table.States (619), 221, 273);
Add_Goto (Table.States (619), 239, 477);
Add_Goto (Table.States (619), 258, 135);
Add_Goto (Table.States (619), 272, 92);
Add_Goto (Table.States (619), 273, 275);
Add_Goto (Table.States (619), 275, 136);
Add_Goto (Table.States (619), 277, 777);
Add_Goto (Table.States (619), 278, 410);
Add_Goto (Table.States (619), 282, 137);
Add_Goto (Table.States (619), 283, 138);
Add_Goto (Table.States (619), 284, 139);
Add_Goto (Table.States (619), 285, 140);
Add_Goto (Table.States (619), 286, 141);
Add_Goto (Table.States (619), 287, 142);
Add_Goto (Table.States (619), 293, 97);
Add_Goto (Table.States (619), 301, 277);
Add_Goto (Table.States (619), 314, 480);
Add_Goto (Table.States (619), 320, 144);
Add_Goto (Table.States (619), 321, 145);
Add_Goto (Table.States (619), 330, 146);
Table.States (619).Kernel := To_Vector (((115, 76, 1, False), (115, 76, 3, False), (224, 76, 4, False),
(239, 76, 4, True)));
Table.States (619).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Table.States (619).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (620), (10, 21, 37, 42, 74, 77, 82, 83, 87, 96), (314, 2), 2,
subtype_indication_2'Access, null);
Table.States (620).Kernel := To_Vector ((0 => (314, 155, 0, False)));
Table.States (620).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 314, 2)));
Add_Action (Table.States (621), (10, 21, 37, 42, 74, 77, 82, 83, 87, 96), (155, 1), 1, null, null);
Table.States (621).Kernel := To_Vector ((0 => (155, 224, 0, False)));
Table.States (621).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 155, 1)));
Add_Action (Table.States (622), 37, Reduce, (230, 3), 4, null, null);
Add_Action (Table.States (622), 76, 235);
Add_Action (Table.States (622), 84, 237);
Add_Action (Table.States (622), 87, Reduce, (230, 3), 4, null, null);
Add_Action (Table.States (622), 101, 239);
Add_Action (Table.States (622), 102, 240);
Add_Error (Table.States (622));
Add_Goto (Table.States (622), 115, 241);
Add_Goto (Table.States (622), 322, 242);
Table.States (622).Kernel := To_Vector (((128, 239, 2, True), (230, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (622).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 230, 4)));
Add_Action (Table.States (623), 104, 119);
Add_Action (Table.States (623), 105, 33);
Add_Action (Table.States (623), 106, 34);
Add_Error (Table.States (623));
Add_Goto (Table.States (623), 128, 41);
Add_Goto (Table.States (623), 239, 772);
Add_Goto (Table.States (623), 272, 92);
Add_Goto (Table.States (623), 293, 97);
Table.States (623).Kernel := To_Vector (((314, 41, 5, False), (314, 41, 1, False)));
Table.States (623).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (624), 59, 778);
Add_Action (Table.States (624), 104, 119);
Add_Action (Table.States (624), 105, 33);
Add_Action (Table.States (624), 106, 34);
Add_Error (Table.States (624));
Add_Goto (Table.States (624), 128, 41);
Add_Goto (Table.States (624), 239, 779);
Add_Goto (Table.States (624), 272, 92);
Add_Goto (Table.States (624), 293, 97);
Table.States (624).Kernel := To_Vector (((230, 42, 2, False), (230, 42, 1, False)));
Table.States (624).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (625), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 74, 93, 104, 105, 106, 107), (121, 0), 5,
aspect_clause_0'Access, null);
Table.States (625).Kernel := To_Vector ((0 => (121, 96, 0, False)));
Table.States (625).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 121, 5)));
Add_Action (Table.States (626), 96, 780);
Add_Error (Table.States (626));
Table.States (626).Kernel := To_Vector ((0 => (127, 192, 1, False)));
Table.States (626).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 780)));
Add_Action (Table.States (627), 38, 781);
Add_Error (Table.States (627));
Table.States (627).Kernel := To_Vector ((0 => (235, 12, 2, False)));
Table.States (627).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 781)));
Add_Action (Table.States (628), 104, 782);
Add_Error (Table.States (628));
Add_Goto (Table.States (628), 144, 783);
Add_Goto (Table.States (628), 145, 784);
Table.States (628).Kernel := To_Vector ((0 => (281, 235, 11, False)));
Table.States (628).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 782)));
Add_Action (Table.States (629), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 74, 93, 104, 105, 106, 107), (182, 0), 5,
enumeration_representation_clause_0'Access, null);
Table.States (629).Kernel := To_Vector ((0 => (182, 96, 0, False)));
Table.States (629).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 182, 5)));
Add_Action (Table.States (630), 21, Reduce, (240, 0), 1, null, name_opt_0_check'Access);
Add_Action (Table.States (630), 35, Reduce, (240, 0), 1, null, name_opt_0_check'Access);
Add_Action (Table.States (630), 56, Reduce, (240, 0), 1, null, name_opt_0_check'Access);
Add_Action (Table.States (630), 74, Reduce, (240, 0), 1, null, name_opt_0_check'Access);
Add_Action (Table.States (630), 76, 235);
Add_Action (Table.States (630), 77, Reduce, (240, 0), 1, null, name_opt_0_check'Access);
Add_Action (Table.States (630), 82, Reduce, (240, 0), 1, null, name_opt_0_check'Access);
Add_Action (Table.States (630), 84, 237);
Add_Action (Table.States (630), 96, Reduce, (240, 0), 1, null, name_opt_0_check'Access);
Add_Action (Table.States (630), 101, 239);
Add_Action (Table.States (630), 102, 240);
Add_Error (Table.States (630));
Add_Goto (Table.States (630), 115, 241);
Add_Goto (Table.States (630), 322, 242);
Table.States (630).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(240, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (630).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 240, 1)));
Add_Action (Table.States (631), (21, 35, 56, 74, 77, 82, 96), (291, 0), 3, result_profile_0'Access, null);
Table.States (631).Kernel := To_Vector ((0 => (291, 240, 0, False)));
Table.States (631).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 291, 3)));
Add_Action (Table.States (632), 7, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 8, 401);
Add_Action (Table.States (632), 33, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 40, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 45, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 77, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 82, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 96, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 104, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 105, Reduce, (118, 1), 0, null, null);
Add_Action (Table.States (632), 106, Reduce, (118, 1), 0, null, null);
Add_Error (Table.States (632));
Add_Goto (Table.States (632), 118, 785);
Table.States (632).Kernel := To_Vector (((254, 81, 2, False), (254, 81, 1, False), (254, 81, 3, False),
(254, 81, 2, False)));
Table.States (632).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 118, 0)));
Add_Action (Table.States (633), (21, 35, 56, 58, 72, 74, 77, 82, 96), (199, 0), 3, formal_part_0'Access,
null);
Table.States (633).Kernel := To_Vector ((0 => (199, 77, 0, False)));
Table.States (633).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 199, 3)));
Add_Action (Table.States (634), 77, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (634), 96, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (634), 104, 164);
Add_Error (Table.States (634));
Add_Goto (Table.States (634), 219, 493);
Add_Goto (Table.States (634), 254, 786);
Table.States (634).Kernel := To_Vector ((0 => (255, 96, 0, True)));
Table.States (634).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 254, 0)));
Table.States (634).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (635), 74, 337);
Add_Action (Table.States (635), 76, 235);
Add_Action (Table.States (635), 84, 237);
Add_Action (Table.States (635), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (635), 101, 239);
Add_Action (Table.States (635), 102, 240);
Add_Error (Table.States (635));
Add_Goto (Table.States (635), 115, 241);
Add_Goto (Table.States (635), 122, 787);
Add_Goto (Table.States (635), 322, 242);
Table.States (635).Kernel := To_Vector (((128, 239, 2, True), (215, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (635).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (636), 74, 337);
Add_Action (Table.States (636), 76, 235);
Add_Action (Table.States (636), 84, 237);
Add_Action (Table.States (636), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (636), 101, 239);
Add_Action (Table.States (636), 102, 240);
Add_Error (Table.States (636));
Add_Goto (Table.States (636), 115, 241);
Add_Goto (Table.States (636), 122, 788);
Add_Goto (Table.States (636), 322, 242);
Table.States (636).Kernel := To_Vector (((128, 239, 2, True), (215, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (636).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (637), 74, 337);
Add_Action (Table.States (637), 76, 235);
Add_Action (Table.States (637), 84, 237);
Add_Action (Table.States (637), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (637), 101, 239);
Add_Action (Table.States (637), 102, 240);
Add_Error (Table.States (637));
Add_Goto (Table.States (637), 115, 241);
Add_Goto (Table.States (637), 122, 789);
Add_Goto (Table.States (637), 322, 242);
Table.States (637).Kernel := To_Vector (((128, 239, 2, True), (215, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (637).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (638), 6, 790);
Add_Action (Table.States (638), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (638), 11, 699);
Add_Action (Table.States (638), 19, 791);
Add_Action (Table.States (638), 20, 792);
Add_Action (Table.States (638), 34, 702);
Add_Action (Table.States (638), 36, 793);
Add_Action (Table.States (638), 38, 794);
Add_Action (Table.States (638), 39, Reduce, (109, 5), 0, null, null);
Add_Action (Table.States (638), 40, 386);
Add_Action (Table.States (638), 49, Reduce, (111, 5), 0, null, null);
Add_Action (Table.States (638), 51, 706);
Add_Action (Table.States (638), 53, 795);
Add_Action (Table.States (638), 64, 709);
Add_Action (Table.States (638), 65, 796);
Add_Action (Table.States (638), 66, 711);
Add_Action (Table.States (638), 76, 797);
Add_Error (Table.States (638));
Add_Goto (Table.States (638), 109, 798);
Add_Goto (Table.States (638), 111, 799);
Add_Goto (Table.States (638), 114, 800);
Add_Goto (Table.States (638), 120, 801);
Add_Goto (Table.States (638), 202, 802);
Add_Goto (Table.States (638), 203, 803);
Add_Goto (Table.States (638), 228, 804);
Add_Goto (Table.States (638), 241, 721);
Table.States (638).Kernel := To_Vector (((201, 35, 2, False), (201, 35, 2, False)));
Table.States (638).Minimal_Complete_Actions := To_Vector (((Reduce, 111, 0), (Shift, 65, 796)));
Add_Action (Table.States (639), 96, 805);
Add_Error (Table.States (639));
Table.States (639).Kernel := To_Vector ((0 => (201, 122, 1, False)));
Table.States (639).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 805)));
Add_Action (Table.States (640), 39, 806);
Add_Error (Table.States (640));
Table.States (640).Kernel := To_Vector ((0 => (204, 35, 3, False)));
Table.States (640).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 39, 806)));
Add_Action (Table.States (641), 41, 642);
Add_Action (Table.States (641), 74, 337);
Add_Action (Table.States (641), 80, 643);
Add_Action (Table.States (641), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (641), 104, 119);
Add_Action (Table.States (641), 105, 33);
Add_Action (Table.States (641), 106, 34);
Add_Error (Table.States (641));
Add_Goto (Table.States (641), 122, 807);
Add_Goto (Table.States (641), 128, 41);
Add_Goto (Table.States (641), 239, 644);
Add_Goto (Table.States (641), 272, 92);
Add_Goto (Table.States (641), 293, 97);
Add_Goto (Table.States (641), 310, 808);
Table.States (641).Kernel := To_Vector (((200, 6, 2, False), (200, 6, 1, False)));
Table.States (641).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (642), (74, 96), (310, 2), 1, null, null);
Table.States (642).Kernel := To_Vector ((0 => (310, 41, 0, False)));
Table.States (642).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 310, 1)));
Add_Action (Table.States (643), (74, 96), (310, 1), 1, null, null);
Table.States (643).Kernel := To_Vector ((0 => (310, 80, 0, False)));
Table.States (643).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 310, 1)));
Add_Action (Table.States (644), 74, Reduce, (310, 0), 1, subprogram_default_0'Access, null);
Add_Action (Table.States (644), 76, 235);
Add_Action (Table.States (644), 84, 237);
Add_Action (Table.States (644), 96, Reduce, (310, 0), 1, subprogram_default_0'Access, null);
Add_Action (Table.States (644), 101, 239);
Add_Action (Table.States (644), 102, 240);
Add_Error (Table.States (644));
Add_Goto (Table.States (644), 115, 241);
Add_Goto (Table.States (644), 322, 242);
Table.States (644).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(310, 239, 0, False)));
Table.States (644).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 310, 1)));
Add_Action (Table.States (645), 74, 337);
Add_Action (Table.States (645), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (645));
Add_Goto (Table.States (645), 122, 809);
Table.States (645).Kernel := To_Vector ((0 => (200, 310, 1, False)));
Table.States (645).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (646), (29, 47, 48, 50, 69, 71, 74, 104), (200, 3), 4,
formal_subprogram_declaration_3'Access, null);
Table.States (646).Kernel := To_Vector ((0 => (200, 96, 0, False)));
Table.States (646).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 200, 4)));
Add_Action (Table.States (647), (7, 40, 74, 82, 96, 104, 105, 106), (236, 1), 2, null, null);
Table.States (647).Kernel := To_Vector ((0 => (236, 45, 0, False)));
Table.States (647).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 236, 2)));
Add_Action (Table.States (648), 74, 337);
Add_Action (Table.States (648), 82, 810);
Add_Action (Table.States (648), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (648));
Add_Goto (Table.States (648), 122, 811);
Table.States (648).Kernel := To_Vector (((198, 114, 2, False), (198, 114, 1, False)));
Table.States (648).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (649), 7, 556);
Add_Action (Table.States (649), 104, 119);
Add_Action (Table.States (649), 105, 33);
Add_Action (Table.States (649), 106, 34);
Add_Error (Table.States (649));
Add_Goto (Table.States (649), 128, 41);
Add_Goto (Table.States (649), 239, 812);
Add_Goto (Table.States (649), 272, 92);
Add_Goto (Table.States (649), 293, 97);
Table.States (649).Kernel := To_Vector (((114, 241, 2, False), (114, 241, 3, True), (114, 241, 2, False),
(198, 241, 3, False), (198, 241, 2, False)));
Table.States (649).Minimal_Complete_Actions := To_Vector (((Shift, 7, 556), (Shift, 104, 119)));
Add_Action (Table.States (650), 4, 1);
Add_Action (Table.States (650), 5, 2);
Add_Action (Table.States (650), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (650), 15, 3);
Add_Action (Table.States (650), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (650), 18, 4);
Add_Action (Table.States (650), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (650), 27, 5);
Add_Action (Table.States (650), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (650), 31, 9);
Add_Action (Table.States (650), 32, 10);
Add_Action (Table.States (650), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (650), 41, 13);
Add_Action (Table.States (650), 48, 16);
Add_Action (Table.States (650), 52, 20);
Add_Action (Table.States (650), 57, 21);
Add_Action (Table.States (650), 58, 22);
Add_Action (Table.States (650), 61, 24);
Add_Action (Table.States (650), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (650), 93, 31);
Add_Action (Table.States (650), 104, 360);
Add_Action (Table.States (650), 105, 33);
Add_Action (Table.States (650), 106, 34);
Add_Error (Table.States (650));
Add_Goto (Table.States (650), 113, 36);
Add_Goto (Table.States (650), 123, 38);
Add_Goto (Table.States (650), 126, 39);
Add_Goto (Table.States (650), 128, 41);
Add_Goto (Table.States (650), 131, 42);
Add_Goto (Table.States (650), 132, 43);
Add_Goto (Table.States (650), 133, 44);
Add_Goto (Table.States (650), 139, 47);
Add_Goto (Table.States (650), 151, 50);
Add_Goto (Table.States (650), 152, 51);
Add_Goto (Table.States (650), 161, 53);
Add_Goto (Table.States (650), 190, 57);
Add_Goto (Table.States (650), 196, 59);
Add_Goto (Table.States (650), 217, 68);
Add_Goto (Table.States (650), 222, 70);
Add_Goto (Table.States (650), 232, 72);
Add_Goto (Table.States (650), 239, 73);
Add_Goto (Table.States (650), 257, 83);
Add_Goto (Table.States (650), 261, 86);
Add_Goto (Table.States (650), 272, 92);
Add_Goto (Table.States (650), 276, 93);
Add_Goto (Table.States (650), 290, 96);
Add_Goto (Table.States (650), 293, 97);
Add_Goto (Table.States (650), 294, 98);
Add_Goto (Table.States (650), 298, 99);
Add_Goto (Table.States (650), 299, 361);
Add_Goto (Table.States (650), 300, 813);
Add_Goto (Table.States (650), 302, 100);
Add_Goto (Table.States (650), 303, 101);
Add_Goto (Table.States (650), 306, 363);
Add_Goto (Table.States (650), 323, 114);
Table.States (650).Kernel := To_Vector ((0 => (222, 22, 3, False)));
Table.States (650).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (651), 3, 121);
Add_Action (Table.States (651), 39, 122);
Add_Action (Table.States (651), 40, 123);
Add_Action (Table.States (651), 41, 124);
Add_Action (Table.States (651), 52, 125);
Add_Action (Table.States (651), 68, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (651), 76, 126);
Add_Action (Table.States (651), 94, 127);
Add_Action (Table.States (651), 95, 128);
Add_Action (Table.States (651), 103, 129);
Add_Action (Table.States (651), 104, 119);
Add_Action (Table.States (651), 105, 33);
Add_Action (Table.States (651), 106, 34);
Add_Error (Table.States (651));
Add_Goto (Table.States (651), 117, 130);
Add_Goto (Table.States (651), 128, 41);
Add_Goto (Table.States (651), 191, 131);
Add_Goto (Table.States (651), 192, 814);
Add_Goto (Table.States (651), 197, 133);
Add_Goto (Table.States (651), 239, 134);
Add_Goto (Table.States (651), 258, 135);
Add_Goto (Table.States (651), 272, 92);
Add_Goto (Table.States (651), 275, 136);
Add_Goto (Table.States (651), 282, 137);
Add_Goto (Table.States (651), 283, 138);
Add_Goto (Table.States (651), 284, 139);
Add_Goto (Table.States (651), 285, 140);
Add_Goto (Table.States (651), 286, 141);
Add_Goto (Table.States (651), 287, 142);
Add_Goto (Table.States (651), 293, 97);
Add_Goto (Table.States (651), 301, 143);
Add_Goto (Table.States (651), 320, 144);
Add_Goto (Table.States (651), 321, 145);
Add_Goto (Table.States (651), 330, 146);
Table.States (651).Kernel := To_Vector ((0 => (174, 23, 1, False)));
Table.States (651).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (652), 32, 815);
Add_Error (Table.States (652));
Table.States (652).Kernel := To_Vector ((0 => (222, 24, 2, False)));
Table.States (652).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 32, 815)));
Add_Action (Table.States (653), (22, 23, 24), (175, 1), 1, null, null);
Table.States (653).Kernel := To_Vector ((0 => (175, 174, 0, False)));
Table.States (653).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 175, 1)));
Add_Action (Table.States (654), 22, 816);
Add_Action (Table.States (654), 23, 651);
Add_Action (Table.States (654), 24, 817);
Add_Error (Table.States (654));
Add_Goto (Table.States (654), 174, 818);
Table.States (654).Kernel := To_Vector (((175, 175, 2, True), (222, 175, 4, False), (222, 175, 3, False)));
Table.States (654).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 817)));
Add_Action (Table.States (655), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (332, 0), 5,
with_clause_0'Access, null);
Table.States (655).Kernel := To_Vector ((0 => (332, 96, 0, False)));
Table.States (655).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 332, 5)));
Add_Action (Table.States (656), 74, 337);
Add_Action (Table.States (656), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (656));
Add_Goto (Table.States (656), 122, 819);
Table.States (656).Kernel := To_Vector ((0 => (248, 60, 1, False)));
Table.States (656).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (657), 13, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (657), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (657), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (657), 28, 183);
Add_Action (Table.States (657), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (657), 30, 8);
Add_Action (Table.States (657), 40, 12);
Add_Action (Table.States (657), 46, 14);
Add_Action (Table.States (657), 47, 15);
Add_Action (Table.States (657), 48, 16);
Add_Action (Table.States (657), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (657), 51, 19);
Add_Action (Table.States (657), 63, 25);
Add_Action (Table.States (657), 66, 26);
Add_Action (Table.States (657), 69, 27);
Add_Action (Table.States (657), 71, 28);
Add_Action (Table.States (657), 104, 185);
Add_Error (Table.States (657));
Add_Goto (Table.States (657), 112, 35);
Add_Goto (Table.States (657), 121, 37);
Add_Goto (Table.States (657), 127, 40);
Add_Goto (Table.States (657), 134, 45);
Add_Goto (Table.States (657), 135, 46);
Add_Goto (Table.States (657), 157, 391);
Add_Goto (Table.States (657), 158, 392);
Add_Goto (Table.States (657), 159, 820);
Add_Goto (Table.States (657), 179, 54);
Add_Goto (Table.States (657), 182, 55);
Add_Goto (Table.States (657), 186, 56);
Add_Goto (Table.States (657), 193, 58);
Add_Goto (Table.States (657), 206, 60);
Add_Goto (Table.States (657), 207, 61);
Add_Goto (Table.States (657), 209, 62);
Add_Goto (Table.States (657), 210, 63);
Add_Goto (Table.States (657), 213, 64);
Add_Goto (Table.States (657), 214, 65);
Add_Goto (Table.States (657), 215, 66);
Add_Goto (Table.States (657), 216, 67);
Add_Goto (Table.States (657), 219, 69);
Add_Goto (Table.States (657), 223, 71);
Add_Goto (Table.States (657), 243, 74);
Add_Goto (Table.States (657), 244, 75);
Add_Goto (Table.States (657), 245, 76);
Add_Goto (Table.States (657), 246, 77);
Add_Goto (Table.States (657), 247, 78);
Add_Goto (Table.States (657), 248, 79);
Add_Goto (Table.States (657), 249, 80);
Add_Goto (Table.States (657), 250, 81);
Add_Goto (Table.States (657), 251, 82);
Add_Goto (Table.States (657), 257, 394);
Add_Goto (Table.States (657), 259, 84);
Add_Goto (Table.States (657), 260, 85);
Add_Goto (Table.States (657), 262, 87);
Add_Goto (Table.States (657), 263, 88);
Add_Goto (Table.States (657), 264, 89);
Add_Goto (Table.States (657), 265, 90);
Add_Goto (Table.States (657), 271, 91);
Add_Goto (Table.States (657), 281, 94);
Add_Goto (Table.States (657), 289, 95);
Add_Goto (Table.States (657), 304, 102);
Add_Goto (Table.States (657), 305, 103);
Add_Goto (Table.States (657), 307, 105);
Add_Goto (Table.States (657), 308, 106);
Add_Goto (Table.States (657), 309, 107);
Add_Goto (Table.States (657), 311, 108);
Add_Goto (Table.States (657), 313, 109);
Add_Goto (Table.States (657), 316, 111);
Add_Goto (Table.States (657), 317, 112);
Add_Goto (Table.States (657), 319, 113);
Add_Goto (Table.States (657), 325, 115);
Add_Goto (Table.States (657), 331, 116);
Table.States (657).Kernel := To_Vector (((247, 35, 3, False), (247, 35, 2, False)));
Table.States (657).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (658), 74, 337);
Add_Action (Table.States (658), 76, 235);
Add_Action (Table.States (658), 84, 237);
Add_Action (Table.States (658), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (658), 101, 239);
Add_Action (Table.States (658), 102, 240);
Add_Error (Table.States (658));
Add_Goto (Table.States (658), 115, 241);
Add_Goto (Table.States (658), 122, 821);
Add_Goto (Table.States (658), 322, 242);
Table.States (658).Kernel := To_Vector (((128, 239, 2, True), (213, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (658).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (659), 96, 822);
Add_Error (Table.States (659));
Table.States (659).Kernel := To_Vector ((0 => (250, 122, 1, False)));
Table.States (659).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 822)));
Add_Action (Table.States (660), 24, 823);
Add_Action (Table.States (660), 49, 824);
Add_Error (Table.States (660));
Table.States (660).Kernel := To_Vector (((251, 159, 2, False), (251, 159, 1, False)));
Table.States (660).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 823)));
Add_Action (Table.States (661), 96, 825);
Add_Error (Table.States (661));
Table.States (661).Kernel := To_Vector ((0 => (257, 77, 1, False)));
Table.States (661).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 825)));
Add_Action (Table.States (662), 96, 826);
Add_Error (Table.States (662));
Table.States (662).Kernel := To_Vector ((0 => (257, 77, 1, False)));
Table.States (662).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 826)));
Add_Action (Table.States (663), 74, 337);
Add_Action (Table.States (663), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (663));
Add_Goto (Table.States (663), 122, 827);
Table.States (663).Kernel := To_Vector ((0 => (265, 60, 1, False)));
Table.States (663).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (664), 24, Reduce, (269, 1), 0, null, null);
Add_Action (Table.States (664), 25, 828);
Add_Action (Table.States (664), 28, 183);
Add_Action (Table.States (664), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (664), 40, 12);
Add_Action (Table.States (664), 46, 14);
Add_Action (Table.States (664), 50, Reduce, (246, 2), 0, null, null);
Add_Error (Table.States (664));
Add_Goto (Table.States (664), 121, 829);
Add_Goto (Table.States (664), 127, 40);
Add_Goto (Table.States (664), 176, 830);
Add_Goto (Table.States (664), 182, 55);
Add_Goto (Table.States (664), 193, 831);
Add_Goto (Table.States (664), 207, 61);
Add_Goto (Table.States (664), 243, 832);
Add_Goto (Table.States (664), 246, 833);
Add_Goto (Table.States (664), 262, 87);
Add_Goto (Table.States (664), 267, 834);
Add_Goto (Table.States (664), 268, 835);
Add_Goto (Table.States (664), 269, 836);
Add_Goto (Table.States (664), 281, 94);
Add_Goto (Table.States (664), 307, 837);
Add_Goto (Table.States (664), 309, 838);
Table.States (664).Kernel := To_Vector ((0 => (264, 35, 2, False)));
Table.States (664).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 269, 0)));
end Subr_12;
procedure Subr_13
is begin
Add_Action (Table.States (665), 35, 839);
Add_Error (Table.States (665));
Table.States (665).Kernel := To_Vector (((271, 122, 6, False), (271, 122, 3, False)));
Table.States (665).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 839)));
Add_Action (Table.States (666), 104, 119);
Add_Action (Table.States (666), 105, 33);
Add_Action (Table.States (666), 106, 34);
Add_Error (Table.States (666));
Add_Goto (Table.States (666), 128, 41);
Add_Goto (Table.States (666), 227, 840);
Add_Goto (Table.States (666), 239, 841);
Add_Goto (Table.States (666), 272, 92);
Add_Goto (Table.States (666), 293, 97);
Table.States (666).Kernel := To_Vector ((0 => (304, 39, 4, False)));
Table.States (666).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (667), 24, 842);
Add_Action (Table.States (667), 49, 843);
Add_Error (Table.States (667));
Table.States (667).Kernel := To_Vector (((266, 159, 2, False), (266, 159, 1, False)));
Table.States (667).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 842)));
Add_Action (Table.States (668), 96, 844);
Add_Error (Table.States (668));
Table.States (668).Kernel := To_Vector ((0 => (304, 266, 1, False)));
Table.States (668).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 844)));
Add_Action (Table.States (669), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (276, 0), 5, raise_statement_0'Access, null);
Table.States (669).Kernel := To_Vector ((0 => (276, 96, 0, False)));
Table.States (669).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 276, 5)));
Add_Action (Table.States (670), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (290, 0), 5, requeue_statement_0'Access, null);
Table.States (670).Kernel := To_Vector ((0 => (290, 96, 0, False)));
Table.States (670).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 290, 5)));
Add_Action (Table.States (671), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (671), 40, 742);
Add_Action (Table.States (671), 104, 119);
Add_Action (Table.States (671), 105, 33);
Add_Action (Table.States (671), 106, 34);
Add_Error (Table.States (671));
Add_Goto (Table.States (671), 114, 845);
Add_Goto (Table.States (671), 128, 41);
Add_Goto (Table.States (671), 239, 484);
Add_Goto (Table.States (671), 241, 721);
Add_Goto (Table.States (671), 272, 92);
Add_Goto (Table.States (671), 292, 846);
Add_Goto (Table.States (671), 293, 97);
Add_Goto (Table.States (671), 314, 847);
Table.States (671).Kernel := To_Vector (((194, 154, 2, False), (194, 154, 1, False)));
Table.States (671).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (672), 58, 848);
Add_Error (Table.States (672));
Table.States (672).Kernel := To_Vector ((0 => (196, 24, 2, False)));
Table.States (672).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 58, 848)));
Add_Action (Table.States (673), 14, 849);
Add_Error (Table.States (673));
Table.States (673).Kernel := To_Vector (((247, 47, 6, False), (247, 47, 5, False)));
Table.States (673).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 849)));
Add_Action (Table.States (674), 14, 850);
Add_Error (Table.States (674));
Table.States (674).Kernel := To_Vector ((0 => (264, 51, 5, False)));
Table.States (674).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 850)));
Add_Action (Table.States (675), 14, 851);
Add_Error (Table.States (675));
Table.States (675).Kernel := To_Vector ((0 => (316, 66, 6, False)));
Table.States (675).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 851)));
Add_Action (Table.States (676), 29, 7);
Add_Action (Table.States (676), 50, 18);
Add_Error (Table.States (676));
Add_Goto (Table.States (676), 207, 61);
Add_Goto (Table.States (676), 262, 87);
Add_Goto (Table.States (676), 312, 852);
Table.States (676).Kernel := To_Vector ((0 => (307, 246, 6, False)));
Table.States (676).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 50, 18)));
Add_Action (Table.States (677), (4, 5, 13, 15, 17, 18, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (315, 0), 5,
subunit_0'Access, null);
Table.States (677).Kernel := To_Vector ((0 => (315, 263, 0, False)));
Table.States (677).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 315, 5)));
Add_Action (Table.States (678), 96, 853);
Add_Error (Table.States (678));
Table.States (678).Kernel := To_Vector ((0 => (295, 67, 1, False)));
Table.States (678).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 853)));
Add_Action (Table.States (679), 4, 1);
Add_Action (Table.States (679), 5, 2);
Add_Action (Table.States (679), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (679), 15, 3);
Add_Action (Table.States (679), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (679), 18, 4);
Add_Action (Table.States (679), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (679), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (679), 27, 5);
Add_Action (Table.States (679), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (679), 31, 9);
Add_Action (Table.States (679), 32, 10);
Add_Action (Table.States (679), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (679), 41, 13);
Add_Action (Table.States (679), 43, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (679), 48, 16);
Add_Action (Table.States (679), 52, 20);
Add_Action (Table.States (679), 57, 21);
Add_Action (Table.States (679), 58, 22);
Add_Action (Table.States (679), 61, 24);
Add_Action (Table.States (679), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (679), 93, 31);
Add_Action (Table.States (679), 104, 360);
Add_Action (Table.States (679), 105, 33);
Add_Action (Table.States (679), 106, 34);
Add_Error (Table.States (679));
Add_Goto (Table.States (679), 113, 36);
Add_Goto (Table.States (679), 123, 38);
Add_Goto (Table.States (679), 126, 39);
Add_Goto (Table.States (679), 128, 41);
Add_Goto (Table.States (679), 131, 42);
Add_Goto (Table.States (679), 132, 43);
Add_Goto (Table.States (679), 133, 44);
Add_Goto (Table.States (679), 139, 47);
Add_Goto (Table.States (679), 151, 50);
Add_Goto (Table.States (679), 152, 51);
Add_Goto (Table.States (679), 161, 53);
Add_Goto (Table.States (679), 190, 57);
Add_Goto (Table.States (679), 196, 59);
Add_Goto (Table.States (679), 217, 68);
Add_Goto (Table.States (679), 222, 70);
Add_Goto (Table.States (679), 232, 72);
Add_Goto (Table.States (679), 239, 73);
Add_Goto (Table.States (679), 257, 83);
Add_Goto (Table.States (679), 261, 86);
Add_Goto (Table.States (679), 272, 92);
Add_Goto (Table.States (679), 276, 93);
Add_Goto (Table.States (679), 290, 96);
Add_Goto (Table.States (679), 293, 97);
Add_Goto (Table.States (679), 294, 98);
Add_Goto (Table.States (679), 298, 99);
Add_Goto (Table.States (679), 299, 361);
Add_Goto (Table.States (679), 300, 854);
Add_Goto (Table.States (679), 302, 100);
Add_Goto (Table.States (679), 303, 101);
Add_Goto (Table.States (679), 306, 363);
Add_Goto (Table.States (679), 323, 114);
Table.States (679).Kernel := To_Vector ((0 => (295, 113, 0, False)));
Table.States (679).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (680), (22, 24, 43), (295, 2), 4, select_alternative_2'Access, null);
Table.States (680).Kernel := To_Vector ((0 => (295, 160, 0, False)));
Table.States (680).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 295, 4)));
Add_Action (Table.States (681), 61, 855);
Add_Error (Table.States (681));
Table.States (681).Kernel := To_Vector ((0 => (152, 24, 2, False)));
Table.States (681).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 61, 855)));
Add_Action (Table.States (682), 61, 856);
Add_Error (Table.States (682));
Table.States (682).Kernel := To_Vector ((0 => (323, 24, 2, False)));
Table.States (682).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 61, 856)));
Add_Action (Table.States (683), (22, 24, 43), (160, 0), 2, null, null);
Table.States (683).Kernel := To_Vector ((0 => (160, 300, 0, False)));
Table.States (683).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 160, 2)));
Add_Action (Table.States (684), 61, 857);
Add_Error (Table.States (684));
Table.States (684).Kernel := To_Vector ((0 => (294, 24, 2, False)));
Table.States (684).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 61, 857)));
Add_Action (Table.States (685), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (294, 1), 5, selective_accept_1'Access, null);
Table.States (685).Kernel := To_Vector ((0 => (294, 96, 0, False)));
Table.States (685).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 294, 5)));
Add_Action (Table.States (686), 24, 858);
Add_Error (Table.States (686));
Table.States (686).Kernel := To_Vector ((0 => (126, 300, 3, False)));
Table.States (686).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 858)));
Add_Action (Table.States (687), 96, 859);
Add_Error (Table.States (687));
Table.States (687).Kernel := To_Vector ((0 => (313, 122, 1, False)));
Table.States (687).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 859)));
Add_Action (Table.States (688), 74, 337);
Add_Action (Table.States (688), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (688));
Add_Goto (Table.States (688), 122, 860);
Table.States (688).Kernel := To_Vector ((0 => (317, 60, 1, False)));
Table.States (688).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (689), 13, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (689), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (689), 28, 183);
Add_Action (Table.States (689), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (689), 30, 8);
Add_Action (Table.States (689), 40, 12);
Add_Action (Table.States (689), 46, 14);
Add_Action (Table.States (689), 47, 15);
Add_Action (Table.States (689), 48, 16);
Add_Action (Table.States (689), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (689), 51, 19);
Add_Action (Table.States (689), 63, 25);
Add_Action (Table.States (689), 66, 26);
Add_Action (Table.States (689), 69, 27);
Add_Action (Table.States (689), 71, 28);
Add_Action (Table.States (689), 104, 185);
Add_Error (Table.States (689));
Add_Goto (Table.States (689), 112, 35);
Add_Goto (Table.States (689), 121, 37);
Add_Goto (Table.States (689), 127, 40);
Add_Goto (Table.States (689), 134, 45);
Add_Goto (Table.States (689), 135, 46);
Add_Goto (Table.States (689), 157, 391);
Add_Goto (Table.States (689), 158, 392);
Add_Goto (Table.States (689), 159, 861);
Add_Goto (Table.States (689), 179, 54);
Add_Goto (Table.States (689), 182, 55);
Add_Goto (Table.States (689), 186, 56);
Add_Goto (Table.States (689), 193, 58);
Add_Goto (Table.States (689), 206, 60);
Add_Goto (Table.States (689), 207, 61);
Add_Goto (Table.States (689), 209, 62);
Add_Goto (Table.States (689), 210, 63);
Add_Goto (Table.States (689), 213, 64);
Add_Goto (Table.States (689), 214, 65);
Add_Goto (Table.States (689), 215, 66);
Add_Goto (Table.States (689), 216, 67);
Add_Goto (Table.States (689), 219, 69);
Add_Goto (Table.States (689), 223, 71);
Add_Goto (Table.States (689), 243, 74);
Add_Goto (Table.States (689), 244, 75);
Add_Goto (Table.States (689), 245, 76);
Add_Goto (Table.States (689), 246, 77);
Add_Goto (Table.States (689), 247, 78);
Add_Goto (Table.States (689), 248, 79);
Add_Goto (Table.States (689), 249, 80);
Add_Goto (Table.States (689), 250, 81);
Add_Goto (Table.States (689), 251, 82);
Add_Goto (Table.States (689), 257, 394);
Add_Goto (Table.States (689), 259, 84);
Add_Goto (Table.States (689), 260, 85);
Add_Goto (Table.States (689), 262, 87);
Add_Goto (Table.States (689), 263, 88);
Add_Goto (Table.States (689), 264, 89);
Add_Goto (Table.States (689), 265, 90);
Add_Goto (Table.States (689), 271, 91);
Add_Goto (Table.States (689), 281, 94);
Add_Goto (Table.States (689), 289, 95);
Add_Goto (Table.States (689), 304, 102);
Add_Goto (Table.States (689), 305, 103);
Add_Goto (Table.States (689), 307, 105);
Add_Goto (Table.States (689), 308, 106);
Add_Goto (Table.States (689), 309, 107);
Add_Goto (Table.States (689), 311, 108);
Add_Goto (Table.States (689), 313, 109);
Add_Goto (Table.States (689), 316, 111);
Add_Goto (Table.States (689), 317, 112);
Add_Goto (Table.States (689), 319, 113);
Add_Goto (Table.States (689), 325, 115);
Add_Goto (Table.States (689), 331, 116);
Table.States (689).Kernel := To_Vector ((0 => (316, 35, 3, False)));
Table.States (689).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (690), 35, 862);
Add_Action (Table.States (690), 96, 863);
Add_Error (Table.States (690));
Table.States (690).Kernel := To_Vector (((319, 122, 6, False), (319, 122, 3, False), (319, 122, 1,
False)));
Table.States (690).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 863)));
Add_Action (Table.States (691), 104, 119);
Add_Action (Table.States (691), 105, 33);
Add_Action (Table.States (691), 106, 34);
Add_Error (Table.States (691));
Add_Goto (Table.States (691), 128, 41);
Add_Goto (Table.States (691), 227, 864);
Add_Goto (Table.States (691), 239, 841);
Add_Goto (Table.States (691), 272, 92);
Add_Goto (Table.States (691), 293, 97);
Table.States (691).Kernel := To_Vector ((0 => (305, 39, 4, False)));
Table.States (691).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (692), 24, Reduce, (318, 1), 1, task_definition_1'Access, null);
Add_Action (Table.States (692), 49, 865);
Add_Error (Table.States (692));
Table.States (692).Kernel := To_Vector (((318, 159, 1, False), (318, 159, 0, False)));
Table.States (692).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 318, 1)));
Add_Action (Table.States (693), 24, 866);
Add_Error (Table.States (693));
Table.States (693).Kernel := To_Vector ((0 => (305, 318, 2, False)));
Table.States (693).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 866)));
Add_Action (Table.States (694), (35, 74, 96), (169, 0), 3, null, null);
Table.States (694).Kernel := To_Vector ((0 => (169, 77, 0, False)));
Table.States (694).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 169, 3)));
Add_Action (Table.States (695), (35, 74, 96), (169, 1), 3, discriminant_part_opt_1'Access, null);
Table.States (695).Kernel := To_Vector ((0 => (169, 77, 0, False)));
Table.States (695).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 169, 3)));
Add_Action (Table.States (696), 77, Reduce, (170, 4), 0, null, null);
Add_Action (Table.States (696), 96, Reduce, (170, 4), 0, null, null);
Add_Action (Table.States (696), 104, 164);
Add_Error (Table.States (696));
Add_Goto (Table.States (696), 170, 867);
Add_Goto (Table.States (696), 219, 547);
Table.States (696).Kernel := To_Vector ((0 => (171, 96, 0, True)));
Table.States (696).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 170, 0)));
Table.States (696).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (697), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (697), 40, 868);
Add_Action (Table.States (697), 104, 869);
Add_Action (Table.States (697), 105, 33);
Add_Action (Table.States (697), 106, 34);
Add_Error (Table.States (697));
Add_Goto (Table.States (697), 114, 870);
Add_Goto (Table.States (697), 128, 41);
Add_Goto (Table.States (697), 239, 871);
Add_Goto (Table.States (697), 241, 721);
Add_Goto (Table.States (697), 242, 872);
Add_Goto (Table.States (697), 272, 92);
Add_Goto (Table.States (697), 293, 873);
Table.States (697).Kernel := To_Vector (((170, 81, 2, False), (170, 81, 3, False), (170, 81, 1, False),
(170, 81, 2, False)));
Table.States (697).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 869)));
Add_Action (Table.States (698), 36, 874);
Add_Action (Table.States (698), 39, Reduce, (109, 2), 1, null, null);
Add_Conflict (Table.States (698), 39, (110, 2), 1, null, null);
Add_Action (Table.States (698), 64, 875);
Add_Action (Table.States (698), 65, 876);
Add_Error (Table.States (698));
Table.States (698).Kernel := To_Vector (((109, 6, 1, False), (109, 6, 1, False), (109, 6, 0, False), (110,
6, 1, False), (110, 6, 0, False), (111, 6, 2, False), (111, 6, 1, False)));
Table.States (698).Minimal_Complete_Actions := To_Vector (((Reduce, 109, 1), (Reduce, 110, 1)));
Add_Action (Table.States (699), 76, 877);
Add_Error (Table.States (699));
Table.States (699).Kernel := To_Vector (((120, 11, 7, False), (120, 11, 7, False)));
Table.States (699).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 76, 877)));
Add_Action (Table.States (700), 3, 121);
Add_Action (Table.States (700), 20, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (700), 39, 122);
Add_Action (Table.States (700), 40, 123);
Add_Action (Table.States (700), 41, 124);
Add_Action (Table.States (700), 52, 125);
Add_Action (Table.States (700), 53, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (700), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (700), 76, 126);
Add_Action (Table.States (700), 94, 127);
Add_Action (Table.States (700), 95, 128);
Add_Action (Table.States (700), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (700), 103, 129);
Add_Action (Table.States (700), 104, 119);
Add_Action (Table.States (700), 105, 33);
Add_Action (Table.States (700), 106, 34);
Add_Error (Table.States (700));
Add_Goto (Table.States (700), 117, 130);
Add_Goto (Table.States (700), 128, 41);
Add_Goto (Table.States (700), 191, 131);
Add_Goto (Table.States (700), 192, 878);
Add_Goto (Table.States (700), 197, 133);
Add_Goto (Table.States (700), 239, 134);
Add_Goto (Table.States (700), 258, 135);
Add_Goto (Table.States (700), 272, 92);
Add_Goto (Table.States (700), 275, 136);
Add_Goto (Table.States (700), 282, 137);
Add_Goto (Table.States (700), 283, 138);
Add_Goto (Table.States (700), 284, 139);
Add_Goto (Table.States (700), 285, 140);
Add_Goto (Table.States (700), 286, 141);
Add_Goto (Table.States (700), 287, 142);
Add_Goto (Table.States (700), 293, 97);
Add_Goto (Table.States (700), 301, 143);
Add_Goto (Table.States (700), 320, 144);
Add_Goto (Table.States (700), 321, 145);
Add_Goto (Table.States (700), 330, 146);
Table.States (700).Kernel := To_Vector (((326, 19, 1, False), (326, 19, 0, False)));
Table.States (700).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (701), 3, 121);
Add_Action (Table.States (701), 39, 122);
Add_Action (Table.States (701), 40, 123);
Add_Action (Table.States (701), 41, 124);
Add_Action (Table.States (701), 52, 125);
Add_Action (Table.States (701), 53, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (701), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (701), 76, 126);
Add_Action (Table.States (701), 94, 127);
Add_Action (Table.States (701), 95, 128);
Add_Action (Table.States (701), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (701), 103, 129);
Add_Action (Table.States (701), 104, 119);
Add_Action (Table.States (701), 105, 33);
Add_Action (Table.States (701), 106, 34);
Add_Error (Table.States (701));
Add_Goto (Table.States (701), 117, 130);
Add_Goto (Table.States (701), 128, 41);
Add_Goto (Table.States (701), 191, 131);
Add_Goto (Table.States (701), 192, 879);
Add_Goto (Table.States (701), 197, 133);
Add_Goto (Table.States (701), 239, 134);
Add_Goto (Table.States (701), 258, 135);
Add_Goto (Table.States (701), 272, 92);
Add_Goto (Table.States (701), 275, 136);
Add_Goto (Table.States (701), 282, 137);
Add_Goto (Table.States (701), 283, 138);
Add_Goto (Table.States (701), 284, 139);
Add_Goto (Table.States (701), 285, 140);
Add_Goto (Table.States (701), 286, 141);
Add_Goto (Table.States (701), 287, 142);
Add_Goto (Table.States (701), 293, 97);
Add_Goto (Table.States (701), 301, 143);
Add_Goto (Table.States (701), 320, 144);
Add_Goto (Table.States (701), 321, 145);
Add_Goto (Table.States (701), 330, 146);
Table.States (701).Kernel := To_Vector ((0 => (326, 20, 0, False)));
Table.States (701).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (702), (74, 96), (228, 8), 1, null, null);
Table.States (702).Kernel := To_Vector ((0 => (228, 34, 0, False)));
Table.States (702).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 1)));
Add_Action (Table.States (703), 34, 880);
Add_Action (Table.States (703), 39, Reduce, (109, 3), 1, null, null);
Add_Conflict (Table.States (703), 39, (110, 1), 1, null, null);
Add_Action (Table.States (703), 41, Reduce, (111, 4), 1, null, null);
Add_Action (Table.States (703), 49, Reduce, (111, 4), 1, null, null);
Add_Action (Table.States (703), 54, Reduce, (111, 4), 1, null, null);
Add_Error (Table.States (703));
Table.States (703).Kernel := To_Vector (((109, 36, 0, False), (110, 36, 0, False), (111, 36, 0, False),
(228, 36, 3, False), (228, 36, 1, False)));
Table.States (703).Minimal_Complete_Actions := To_Vector (((Reduce, 109, 1), (Reduce, 110, 1), (Reduce,
111, 1)));
Add_Action (Table.States (704), 3, 121);
Add_Action (Table.States (704), 39, 122);
Add_Action (Table.States (704), 40, 123);
Add_Action (Table.States (704), 41, 124);
Add_Action (Table.States (704), 52, 125);
Add_Action (Table.States (704), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (704), 76, 126);
Add_Action (Table.States (704), 94, 127);
Add_Action (Table.States (704), 95, 128);
Add_Action (Table.States (704), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (704), 103, 129);
Add_Action (Table.States (704), 104, 119);
Add_Action (Table.States (704), 105, 33);
Add_Action (Table.States (704), 106, 34);
Add_Error (Table.States (704));
Add_Goto (Table.States (704), 117, 130);
Add_Goto (Table.States (704), 128, 41);
Add_Goto (Table.States (704), 191, 131);
Add_Goto (Table.States (704), 192, 881);
Add_Goto (Table.States (704), 197, 133);
Add_Goto (Table.States (704), 239, 134);
Add_Goto (Table.States (704), 258, 135);
Add_Goto (Table.States (704), 272, 92);
Add_Goto (Table.States (704), 275, 136);
Add_Goto (Table.States (704), 282, 137);
Add_Goto (Table.States (704), 283, 138);
Add_Goto (Table.States (704), 284, 139);
Add_Goto (Table.States (704), 285, 140);
Add_Goto (Table.States (704), 286, 141);
Add_Goto (Table.States (704), 287, 142);
Add_Goto (Table.States (704), 293, 97);
Add_Goto (Table.States (704), 301, 143);
Add_Goto (Table.States (704), 320, 144);
Add_Goto (Table.States (704), 321, 145);
Add_Goto (Table.States (704), 330, 146);
Table.States (704).Kernel := To_Vector ((0 => (326, 38, 0, False)));
Table.States (704).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (705), 54, 882);
Add_Error (Table.States (705));
Table.States (705).Kernel := To_Vector ((0 => (280, 41, 1, False)));
Table.States (705).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 54, 882)));
Add_Action (Table.States (706), 34, 883);
Add_Error (Table.States (706));
Table.States (706).Kernel := To_Vector (((228, 51, 3, False), (228, 51, 1, False)));
Table.States (706).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 883)));
Add_Action (Table.States (707), 3, 121);
Add_Action (Table.States (707), 39, 122);
Add_Action (Table.States (707), 40, 123);
Add_Action (Table.States (707), 41, 124);
Add_Action (Table.States (707), 76, 126);
Add_Action (Table.States (707), 94, 127);
Add_Action (Table.States (707), 95, 128);
Add_Action (Table.States (707), 103, 129);
Add_Action (Table.States (707), 104, 119);
Add_Action (Table.States (707), 105, 33);
Add_Action (Table.States (707), 106, 34);
Add_Error (Table.States (707));
Add_Goto (Table.States (707), 117, 130);
Add_Goto (Table.States (707), 128, 41);
Add_Goto (Table.States (707), 197, 133);
Add_Goto (Table.States (707), 239, 134);
Add_Goto (Table.States (707), 258, 135);
Add_Goto (Table.States (707), 272, 92);
Add_Goto (Table.States (707), 293, 97);
Add_Goto (Table.States (707), 301, 884);
Add_Goto (Table.States (707), 320, 144);
Add_Goto (Table.States (707), 321, 145);
Add_Goto (Table.States (707), 330, 146);
Table.States (707).Kernel := To_Vector ((0 => (326, 53, 3, False)));
Table.States (707).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (708), 15, 885);
Add_Action (Table.States (708), 24, Reduce, (150, 1), 0, null, null);
Add_Action (Table.States (708), 28, 183);
Add_Action (Table.States (708), 41, 886);
Add_Action (Table.States (708), 104, 164);
Add_Error (Table.States (708));
Add_Goto (Table.States (708), 121, 887);
Add_Goto (Table.States (708), 127, 40);
Add_Goto (Table.States (708), 146, 888);
Add_Goto (Table.States (708), 148, 889);
Add_Goto (Table.States (708), 149, 890);
Add_Goto (Table.States (708), 150, 891);
Add_Goto (Table.States (708), 182, 55);
Add_Goto (Table.States (708), 219, 892);
Add_Goto (Table.States (708), 281, 94);
Add_Goto (Table.States (708), 327, 893);
Table.States (708).Kernel := To_Vector ((0 => (280, 54, 2, False)));
Table.States (708).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 150, 0)));
Add_Action (Table.States (709), 34, 894);
Add_Action (Table.States (709), 39, Reduce, (109, 4), 1, null, null);
Add_Error (Table.States (709));
Table.States (709).Kernel := To_Vector (((109, 64, 0, False), (228, 64, 3, False), (228, 64, 1, False)));
Table.States (709).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 109, 1)));
Add_Action (Table.States (710), 36, 895);
Add_Action (Table.States (710), 41, Reduce, (111, 3), 1, null, null);
Add_Action (Table.States (710), 49, Reduce, (111, 3), 1, null, null);
Add_Action (Table.States (710), 54, Reduce, (111, 3), 1, null, null);
Add_Action (Table.States (710), 96, 896);
Add_Error (Table.States (710));
Table.States (710).Kernel := To_Vector (((111, 65, 1, False), (111, 65, 0, False), (223, 65, 1, False)));
Table.States (710).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 111, 1)));
Add_Action (Table.States (711), 34, 897);
Add_Error (Table.States (711));
Table.States (711).Kernel := To_Vector (((228, 66, 3, False), (228, 66, 1, False)));
Table.States (711).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 897)));
Add_Action (Table.States (712), 104, 898);
Add_Action (Table.States (712), 106, 899);
Add_Error (Table.States (712));
Add_Goto (Table.States (712), 180, 900);
Add_Goto (Table.States (712), 181, 901);
Table.States (712).Kernel := To_Vector ((0 => (183, 76, 2, False)));
Table.States (712).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 898)));
Add_Action (Table.States (713), 39, 902);
Add_Error (Table.States (713));
Table.States (713).Kernel := To_Vector ((0 => (259, 109, 5, False)));
Table.States (713).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 39, 902)));
Add_Action (Table.States (714), 39, 903);
Add_Error (Table.States (714));
Table.States (714).Kernel := To_Vector (((162, 110, 5, False), (162, 110, 2, False)));
Table.States (714).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 39, 903)));
Add_Action (Table.States (715), 41, 705);
Add_Action (Table.States (715), 49, 904);
Add_Action (Table.States (715), 54, 708);
Add_Error (Table.States (715));
Add_Goto (Table.States (715), 280, 905);
Table.States (715).Kernel := To_Vector (((260, 111, 2, False), (326, 111, 2, False)));
Table.States (715).Minimal_Complete_Actions := To_Vector (((Shift, 49, 904), (Shift, 41, 705)));
Add_Action (Table.States (716), (74, 96), (326, 8), 1, null, null);
Table.States (716).Kernel := To_Vector ((0 => (326, 114, 0, False)));
Table.States (716).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 1)));
Add_Action (Table.States (717), (74, 96), (326, 6), 1, null, null);
Table.States (717).Kernel := To_Vector ((0 => (326, 120, 0, False)));
Table.States (717).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 1)));
Add_Action (Table.States (718), (74, 96), (326, 9), 1, null, null);
Table.States (718).Kernel := To_Vector ((0 => (326, 162, 0, False)));
Table.States (718).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 1)));
Add_Action (Table.States (719), (74, 96), (326, 0), 1, null, null);
Table.States (719).Kernel := To_Vector ((0 => (326, 183, 0, False)));
Table.States (719).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 1)));
Add_Action (Table.States (720), (74, 96), (326, 10), 1, null, null);
Table.States (720).Kernel := To_Vector ((0 => (326, 228, 0, False)));
Table.States (720).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 1)));
Add_Action (Table.States (721), 7, 556);
Add_Error (Table.States (721));
Table.States (721).Kernel := To_Vector (((114, 241, 2, False), (114, 241, 3, True), (114, 241, 2, False)));
Table.States (721).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 7, 556)));
Add_Action (Table.States (722), 74, 337);
Add_Action (Table.States (722), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (722));
Add_Goto (Table.States (722), 122, 906);
Table.States (722).Kernel := To_Vector ((0 => (206, 326, 1, False)));
Table.States (722).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (723), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (331, 0), 5,
use_clause_0'Access, null);
Table.States (723).Kernel := To_Vector ((0 => (331, 96, 0, False)));
Table.States (723).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 331, 5)));
Add_Action (Table.States (724), 74, 337);
Add_Action (Table.States (724), 76, 235);
Add_Action (Table.States (724), 84, 237);
Add_Action (Table.States (724), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (724), 101, 239);
Add_Action (Table.States (724), 102, 240);
Add_Error (Table.States (724));
Add_Goto (Table.States (724), 115, 241);
Add_Goto (Table.States (724), 122, 907);
Add_Goto (Table.States (724), 322, 242);
Table.States (724).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(245, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (724).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (725), 74, 337);
Add_Action (Table.States (725), 76, 235);
Add_Action (Table.States (725), 84, 237);
Add_Action (Table.States (725), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (725), 101, 239);
Add_Action (Table.States (725), 102, 240);
Add_Error (Table.States (725));
Add_Goto (Table.States (725), 115, 241);
Add_Goto (Table.States (725), 122, 908);
Add_Goto (Table.States (725), 322, 242);
Table.States (725).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(245, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (725).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (726), (104, 105, 106), (208, 0), 1, null, null);
Table.States (726).Kernel := To_Vector ((0 => (208, 9, 0, False)));
Table.States (726).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 208, 1)));
Add_Action (Table.States (727), (104, 105, 106), (208, 1), 1, null, null);
Table.States (727).Kernel := To_Vector ((0 => (208, 16, 0, False)));
Table.States (727).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 208, 1)));
Add_Action (Table.States (728), (29, 50), (270, 0), 1, null, null);
Table.States (728).Kernel := To_Vector ((0 => (270, 51, 0, False)));
Table.States (728).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 270, 1)));
Add_Action (Table.States (729), 104, 119);
Add_Action (Table.States (729), 105, 33);
Add_Action (Table.States (729), 106, 34);
Add_Error (Table.States (729));
Add_Goto (Table.States (729), 128, 41);
Add_Goto (Table.States (729), 239, 909);
Add_Goto (Table.States (729), 272, 92);
Add_Goto (Table.States (729), 293, 97);
Table.States (729).Kernel := To_Vector ((0 => (114, 208, 1, False)));
Table.States (729).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (730), 29, 910);
Add_Action (Table.States (730), 50, 911);
Add_Error (Table.States (730));
Table.States (730).Kernel := To_Vector (((114, 270, 1, False), (114, 270, 2, True)));
Table.States (730).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 50, 911)));
Table.States (730).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (731), 104, 119);
Add_Action (Table.States (731), 105, 33);
Add_Action (Table.States (731), 106, 34);
Add_Error (Table.States (731));
Add_Goto (Table.States (731), 128, 41);
Add_Goto (Table.States (731), 239, 912);
Add_Goto (Table.States (731), 272, 92);
Add_Goto (Table.States (731), 293, 97);
Table.States (731).Kernel := To_Vector ((0 => (245, 56, 2, False)));
Table.States (731).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (732), 96, 913);
Add_Error (Table.States (732));
Table.States (732).Kernel := To_Vector ((0 => (133, 220, 1, False)));
Table.States (732).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 913)));
Add_Action (Table.States (733), 44, 914);
Add_Action (Table.States (733), 104, 915);
Add_Action (Table.States (733), 105, 33);
Add_Action (Table.States (733), 106, 34);
Add_Error (Table.States (733));
Add_Goto (Table.States (733), 128, 41);
Add_Goto (Table.States (733), 184, 916);
Add_Goto (Table.States (733), 185, 917);
Add_Goto (Table.States (733), 239, 918);
Add_Goto (Table.States (733), 272, 92);
Add_Goto (Table.States (733), 293, 97);
Table.States (733).Kernel := To_Vector (((187, 72, 4, False), (187, 72, 2, False)));
Table.States (733).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 915)));
Add_Action (Table.States (734), (24, 72), (188, 1), 1, null, null);
Table.States (734).Kernel := To_Vector ((0 => (188, 187, 0, False)));
Table.States (734).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 188, 1)));
Add_Action (Table.States (735), 24, Reduce, (189, 0), 1, null, null);
Add_Action (Table.States (735), 72, 733);
Add_Error (Table.States (735));
Add_Goto (Table.States (735), 187, 919);
Table.States (735).Kernel := To_Vector (((188, 188, 3, True), (189, 188, 0, False)));
Table.States (735).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 189, 1)));
Add_Action (Table.States (736), (1 => 24), (218, 0), 3, handled_sequence_of_statements_0'Access, null);
Table.States (736).Kernel := To_Vector ((0 => (218, 189, 0, False)));
Table.States (736).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 3)));
Add_Action (Table.States (737), (24, 72), (188, 2), 1, null, null);
Table.States (737).Kernel := To_Vector ((0 => (188, 257, 0, False)));
Table.States (737).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 188, 1)));
Add_Action (Table.States (738), 24, 920);
Add_Error (Table.States (738));
Table.States (738).Kernel := To_Vector ((0 => (133, 218, 2, False)));
Table.States (738).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 920)));
Add_Action (Table.States (739), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (739), 104, 149);
Add_Error (Table.States (739));
Add_Goto (Table.States (739), 220, 921);
Table.States (739).Kernel := To_Vector ((0 => (232, 37, 1, False)));
Table.States (739).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (740), 37, 922);
Add_Error (Table.States (740));
Table.States (740).Kernel := To_Vector ((0 => (232, 24, 2, False)));
Table.States (740).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 922)));
Add_Action (Table.States (741), 96, 923);
Add_Error (Table.States (741));
Table.States (741).Kernel := To_Vector ((0 => (157, 192, 1, False)));
Table.States (741).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 923)));
Add_Action (Table.States (742), 41, 924);
Add_Error (Table.States (742));
Table.States (742).Kernel := To_Vector (((241, 40, 1, False), (314, 40, 6, False), (314, 40, 2, False)));
Table.States (742).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 41, 924)));
Add_Action (Table.States (743), 74, 337);
Add_Action (Table.States (743), 82, 925);
Add_Action (Table.States (743), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (743));
Add_Goto (Table.States (743), 122, 926);
Table.States (743).Kernel := To_Vector (((244, 114, 2, False), (244, 114, 1, False)));
Table.States (743).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (744), 74, 337);
Add_Action (Table.States (744), 82, 927);
Add_Action (Table.States (744), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (744));
Add_Goto (Table.States (744), 122, 928);
Table.States (744).Kernel := To_Vector (((244, 120, 2, False), (244, 120, 1, False)));
Table.States (744).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (745), 74, 337);
Add_Action (Table.States (745), 82, 929);
Add_Action (Table.States (745), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (745));
Add_Goto (Table.States (745), 122, 930);
Table.States (745).Kernel := To_Vector (((244, 314, 2, False), (244, 314, 1, False)));
Table.States (745).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
end Subr_13;
procedure Subr_14
is begin
Add_Action (Table.States (746), (77, 83), (278, 0), 3, null, null);
Table.States (746).Kernel := To_Vector ((0 => (278, 277, 0, True)));
Table.States (746).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 278, 3)));
Table.States (746).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (747), 77, 931);
Add_Error (Table.States (747));
Table.States (747).Kernel := To_Vector ((0 => (179, 167, 2, False)));
Table.States (747).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 931)));
Add_Action (Table.States (748), 96, 932);
Add_Error (Table.States (748));
Table.States (748).Kernel := To_Vector ((0 => (179, 122, 1, False)));
Table.States (748).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 932)));
Add_Action (Table.States (749), 104, 119);
Add_Action (Table.States (749), 105, 33);
Add_Action (Table.States (749), 106, 34);
Add_Error (Table.States (749));
Add_Goto (Table.States (749), 128, 41);
Add_Goto (Table.States (749), 239, 933);
Add_Goto (Table.States (749), 272, 92);
Add_Goto (Table.States (749), 293, 97);
Table.States (749).Kernel := To_Vector ((0 => (213, 39, 2, False)));
Table.States (749).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (750), 104, 119);
Add_Action (Table.States (750), 105, 33);
Add_Action (Table.States (750), 106, 34);
Add_Error (Table.States (750));
Add_Goto (Table.States (750), 128, 41);
Add_Goto (Table.States (750), 239, 934);
Add_Goto (Table.States (750), 272, 92);
Add_Goto (Table.States (750), 293, 97);
Table.States (750).Kernel := To_Vector ((0 => (213, 39, 2, False)));
Table.States (750).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (751), 77, 935);
Add_Action (Table.States (751), 83, 443);
Add_Error (Table.States (751));
Table.States (751).Kernel := To_Vector (((125, 125, 1, True), (256, 125, 1, False)));
Table.States (751).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 935)));
Add_Action (Table.States (752), 77, 936);
Add_Error (Table.States (752));
Table.States (752).Kernel := To_Vector ((0 => (256, 153, 1, False)));
Table.States (752).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 936)));
Add_Action (Table.States (753), 77, 937);
Add_Error (Table.States (753));
Table.States (753).Kernel := To_Vector ((0 => (256, 192, 1, False)));
Table.States (753).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 937)));
Add_Action (Table.States (754), 96, 938);
Add_Error (Table.States (754));
Table.States (754).Kernel := To_Vector ((0 => (193, 122, 1, False)));
Table.States (754).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 938)));
Add_Action (Table.States (755), 96, 939);
Add_Error (Table.States (755));
Table.States (755).Kernel := To_Vector ((0 => (243, 122, 1, False)));
Table.States (755).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 939)));
Add_Action (Table.States (756), 96, 940);
Add_Error (Table.States (756));
Table.States (756).Kernel := To_Vector ((0 => (112, 122, 1, False)));
Table.States (756).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 940)));
Add_Action (Table.States (757), 96, 941);
Add_Error (Table.States (757));
Table.States (757).Kernel := To_Vector ((0 => (308, 122, 1, False)));
Table.States (757).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 941)));
Add_Action (Table.States (758), 96, 942);
Add_Error (Table.States (758));
Table.States (758).Kernel := To_Vector ((0 => (311, 122, 1, False)));
Table.States (758).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 942)));
Add_Action (Table.States (759), 13, 943);
Add_Error (Table.States (759));
Table.States (759).Kernel := To_Vector ((0 => (307, 159, 3, False)));
Table.States (759).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 943)));
Add_Action (Table.States (760), 24, 944);
Add_Error (Table.States (760));
Table.States (760).Kernel := To_Vector ((0 => (113, 218, 2, False)));
Table.States (760).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 944)));
Add_Action (Table.States (761), 3, 121);
Add_Action (Table.States (761), 39, 122);
Add_Action (Table.States (761), 40, 261);
Add_Action (Table.States (761), 41, 124);
Add_Action (Table.States (761), 44, 263);
Add_Action (Table.States (761), 52, 125);
Add_Action (Table.States (761), 76, 126);
Add_Action (Table.States (761), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (761), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (761), 94, 127);
Add_Action (Table.States (761), 95, 128);
Add_Action (Table.States (761), 103, 129);
Add_Action (Table.States (761), 104, 119);
Add_Action (Table.States (761), 105, 33);
Add_Action (Table.States (761), 106, 34);
Add_Error (Table.States (761));
Add_Goto (Table.States (761), 117, 130);
Add_Goto (Table.States (761), 128, 41);
Add_Goto (Table.States (761), 165, 269);
Add_Goto (Table.States (761), 166, 945);
Add_Goto (Table.States (761), 191, 599);
Add_Goto (Table.States (761), 197, 133);
Add_Goto (Table.States (761), 239, 274);
Add_Goto (Table.States (761), 258, 135);
Add_Goto (Table.States (761), 272, 92);
Add_Goto (Table.States (761), 275, 136);
Add_Goto (Table.States (761), 277, 276);
Add_Goto (Table.States (761), 282, 137);
Add_Goto (Table.States (761), 283, 138);
Add_Goto (Table.States (761), 284, 139);
Add_Goto (Table.States (761), 285, 140);
Add_Goto (Table.States (761), 286, 141);
Add_Goto (Table.States (761), 287, 142);
Add_Goto (Table.States (761), 293, 97);
Add_Goto (Table.States (761), 301, 277);
Add_Goto (Table.States (761), 320, 144);
Add_Goto (Table.States (761), 321, 145);
Add_Goto (Table.States (761), 330, 146);
Table.States (761).Kernel := To_Vector ((0 => (137, 72, 1, False)));
Table.States (761).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 166, 0)));
Add_Action (Table.States (762), (77, 83), (138, 1), 1, null, null);
Table.States (762).Kernel := To_Vector ((0 => (138, 137, 0, False)));
Table.States (762).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 138, 1)));
Add_Action (Table.States (763), 77, Reduce, (136, 0), 4, case_expression_0'Access, null);
Add_Action (Table.States (763), 83, 946);
Add_Error (Table.States (763));
Table.States (763).Kernel := To_Vector (((136, 138, 0, False), (138, 138, 3, True)));
Table.States (763).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 136, 4)));
Add_Action (Table.States (764), 3, 121);
Add_Action (Table.States (764), 39, 122);
Add_Action (Table.States (764), 40, 123);
Add_Action (Table.States (764), 41, 124);
Add_Action (Table.States (764), 52, 125);
Add_Action (Table.States (764), 76, 126);
Add_Action (Table.States (764), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (764), 94, 127);
Add_Action (Table.States (764), 95, 128);
Add_Action (Table.States (764), 103, 129);
Add_Action (Table.States (764), 104, 119);
Add_Action (Table.States (764), 105, 33);
Add_Action (Table.States (764), 106, 34);
Add_Error (Table.States (764));
Add_Goto (Table.States (764), 117, 130);
Add_Goto (Table.States (764), 128, 41);
Add_Goto (Table.States (764), 191, 131);
Add_Goto (Table.States (764), 192, 947);
Add_Goto (Table.States (764), 197, 133);
Add_Goto (Table.States (764), 239, 134);
Add_Goto (Table.States (764), 258, 135);
Add_Goto (Table.States (764), 272, 92);
Add_Goto (Table.States (764), 275, 136);
Add_Goto (Table.States (764), 282, 137);
Add_Goto (Table.States (764), 283, 138);
Add_Goto (Table.States (764), 284, 139);
Add_Goto (Table.States (764), 285, 140);
Add_Goto (Table.States (764), 286, 141);
Add_Goto (Table.States (764), 287, 142);
Add_Goto (Table.States (764), 293, 97);
Add_Goto (Table.States (764), 301, 143);
Add_Goto (Table.States (764), 320, 144);
Add_Goto (Table.States (764), 321, 145);
Add_Goto (Table.States (764), 330, 146);
Table.States (764).Kernel := To_Vector ((0 => (273, 87, 0, False)));
Table.States (764).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (765), 22, 948);
Add_Action (Table.States (765), 23, 949);
Add_Action (Table.States (765), 77, Reduce, (221, 3), 4, if_expression_3'Access, null);
Add_Error (Table.States (765));
Add_Goto (Table.States (765), 172, 950);
Add_Goto (Table.States (765), 173, 951);
Table.States (765).Kernel := To_Vector (((221, 192, 3, False), (221, 192, 1, False), (221, 192, 2, False),
(221, 192, 0, False)));
Table.States (765).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 221, 4)));
Add_Action (Table.States (766), 77, 952);
Add_Error (Table.States (766));
Table.States (766).Kernel := To_Vector ((0 => (117, 54, 1, False)));
Table.States (766).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 952)));
Add_Action (Table.States (767), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (117, 1), 5, aggregate_1'Access,
null);
Table.States (767).Kernel := To_Vector ((0 => (117, 77, 0, False)));
Table.States (767).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 117, 5)));
Add_Action (Table.States (768), 3, 121);
Add_Action (Table.States (768), 39, 122);
Add_Action (Table.States (768), 40, 123);
Add_Action (Table.States (768), 41, 124);
Add_Action (Table.States (768), 52, 125);
Add_Action (Table.States (768), 76, 126);
Add_Action (Table.States (768), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (768), 94, 127);
Add_Action (Table.States (768), 95, 128);
Add_Action (Table.States (768), 103, 129);
Add_Action (Table.States (768), 104, 119);
Add_Action (Table.States (768), 105, 33);
Add_Action (Table.States (768), 106, 34);
Add_Error (Table.States (768));
Add_Goto (Table.States (768), 117, 130);
Add_Goto (Table.States (768), 128, 41);
Add_Goto (Table.States (768), 191, 131);
Add_Goto (Table.States (768), 192, 953);
Add_Goto (Table.States (768), 197, 133);
Add_Goto (Table.States (768), 239, 134);
Add_Goto (Table.States (768), 258, 135);
Add_Goto (Table.States (768), 272, 92);
Add_Goto (Table.States (768), 275, 136);
Add_Goto (Table.States (768), 282, 137);
Add_Goto (Table.States (768), 283, 138);
Add_Goto (Table.States (768), 284, 139);
Add_Goto (Table.States (768), 285, 140);
Add_Goto (Table.States (768), 286, 141);
Add_Goto (Table.States (768), 287, 142);
Add_Goto (Table.States (768), 293, 97);
Add_Goto (Table.States (768), 301, 143);
Add_Goto (Table.States (768), 320, 144);
Add_Goto (Table.States (768), 321, 145);
Add_Goto (Table.States (768), 330, 146);
Table.States (768).Kernel := To_Vector ((0 => (277, 76, 1, False)));
Table.States (768).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (769), 4, 1);
Add_Action (Table.States (769), 5, 2);
Add_Action (Table.States (769), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (769), 15, 3);
Add_Action (Table.States (769), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (769), 18, 4);
Add_Action (Table.States (769), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (769), 27, 5);
Add_Action (Table.States (769), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (769), 31, 9);
Add_Action (Table.States (769), 32, 10);
Add_Action (Table.States (769), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (769), 41, 13);
Add_Action (Table.States (769), 48, 16);
Add_Action (Table.States (769), 52, 20);
Add_Action (Table.States (769), 57, 21);
Add_Action (Table.States (769), 58, 22);
Add_Action (Table.States (769), 61, 24);
Add_Action (Table.States (769), 72, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (769), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (769), 93, 31);
Add_Action (Table.States (769), 104, 360);
Add_Action (Table.States (769), 105, 33);
Add_Action (Table.States (769), 106, 34);
Add_Error (Table.States (769));
Add_Goto (Table.States (769), 113, 36);
Add_Goto (Table.States (769), 123, 38);
Add_Goto (Table.States (769), 126, 39);
Add_Goto (Table.States (769), 128, 41);
Add_Goto (Table.States (769), 131, 42);
Add_Goto (Table.States (769), 132, 43);
Add_Goto (Table.States (769), 133, 44);
Add_Goto (Table.States (769), 139, 47);
Add_Goto (Table.States (769), 151, 50);
Add_Goto (Table.States (769), 152, 51);
Add_Goto (Table.States (769), 161, 53);
Add_Goto (Table.States (769), 190, 57);
Add_Goto (Table.States (769), 196, 59);
Add_Goto (Table.States (769), 217, 68);
Add_Goto (Table.States (769), 222, 70);
Add_Goto (Table.States (769), 232, 72);
Add_Goto (Table.States (769), 239, 73);
Add_Goto (Table.States (769), 257, 83);
Add_Goto (Table.States (769), 261, 86);
Add_Goto (Table.States (769), 272, 92);
Add_Goto (Table.States (769), 276, 93);
Add_Goto (Table.States (769), 290, 96);
Add_Goto (Table.States (769), 293, 97);
Add_Goto (Table.States (769), 294, 98);
Add_Goto (Table.States (769), 298, 99);
Add_Goto (Table.States (769), 299, 361);
Add_Goto (Table.States (769), 300, 954);
Add_Goto (Table.States (769), 302, 100);
Add_Goto (Table.States (769), 303, 101);
Add_Goto (Table.States (769), 306, 363);
Add_Goto (Table.States (769), 323, 114);
Table.States (769).Kernel := To_Vector ((0 => (140, 87, 0, False)));
Table.States (769).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (770), 96, 955);
Add_Error (Table.States (770));
Table.States (770).Kernel := To_Vector ((0 => (139, 15, 1, False)));
Table.States (770).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 955)));
Add_Action (Table.States (771), (10, 20, 21, 22, 23, 35, 37, 43, 53, 68, 74, 75, 77, 79, 83, 87, 96), (233,
0), 3, null, null);
Table.States (771).Kernel := To_Vector ((0 => (233, 234, 0, True)));
Table.States (771).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 233, 3)));
Table.States (771).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (772), 10, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 21, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 37, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 42, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 53, 618);
Add_Action (Table.States (772), 74, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 76, 619);
Add_Action (Table.States (772), 77, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 82, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 83, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 84, 237);
Add_Action (Table.States (772), 87, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 96, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (772), 101, 239);
Add_Action (Table.States (772), 102, 240);
Add_Error (Table.States (772));
Add_Goto (Table.States (772), 115, 241);
Add_Goto (Table.States (772), 155, 956);
Add_Goto (Table.States (772), 224, 621);
Add_Goto (Table.States (772), 322, 242);
Table.States (772).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(314, 239, 4, False), (314, 239, 0, False)));
Table.States (772).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 314, 3)));
Add_Action (Table.States (773), (10, 21, 37, 42, 74, 77, 82, 83, 87, 96), (155, 0), 2, null, null);
Table.States (773).Kernel := To_Vector ((0 => (155, 277, 0, False)));
Table.States (773).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 155, 2)));
Add_Action (Table.States (774), 39, 122);
Add_Action (Table.States (774), 41, 957);
Add_Action (Table.States (774), 76, 126);
Add_Action (Table.States (774), 103, 129);
Add_Action (Table.States (774), 104, 119);
Add_Action (Table.States (774), 105, 33);
Add_Action (Table.States (774), 106, 34);
Add_Error (Table.States (774));
Add_Goto (Table.States (774), 117, 130);
Add_Goto (Table.States (774), 128, 41);
Add_Goto (Table.States (774), 239, 134);
Add_Goto (Table.States (774), 258, 256);
Add_Goto (Table.States (774), 272, 92);
Add_Goto (Table.States (774), 293, 97);
Table.States (774).Kernel := To_Vector (((165, 40, 2, False), (197, 40, 1, False), (314, 40, 6, False),
(314, 40, 2, False)));
Table.States (774).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (775), (77, 83), (168, 1), 1, null, null);
Table.States (775).Kernel := To_Vector ((0 => (168, 167, 0, False)));
Table.States (775).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 168, 1)));
Add_Action (Table.States (776), 77, 958);
Add_Action (Table.States (776), 83, 959);
Add_Error (Table.States (776));
Table.States (776).Kernel := To_Vector (((168, 168, 2, True), (224, 168, 1, False)));
Table.States (776).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 958)));
Add_Action (Table.States (777), 77, Reduce, (167, 1), 1, null, null);
Add_Conflict (Table.States (777), 77, (278, 1), 1, null, null);
Add_Action (Table.States (777), 79, Reduce, (165, 2), 1, null, null);
Add_Action (Table.States (777), 83, Reduce, (167, 1), 1, null, null);
Add_Conflict (Table.States (777), 83, (278, 1), 1, null, null);
Add_Action (Table.States (777), 87, Reduce, (165, 2), 1, null, null);
Add_Error (Table.States (777));
Table.States (777).Kernel := To_Vector (((165, 277, 0, False), (167, 277, 0, False), (278, 277, 0,
False)));
Table.States (777).Minimal_Complete_Actions := To_Vector (((Reduce, 165, 1), (Reduce, 167, 1), (Reduce,
278, 1)));
Add_Action (Table.States (778), 104, 119);
Add_Action (Table.States (778), 105, 33);
Add_Action (Table.States (778), 106, 34);
Add_Error (Table.States (778));
Add_Goto (Table.States (778), 128, 41);
Add_Goto (Table.States (778), 239, 960);
Add_Goto (Table.States (778), 272, 92);
Add_Goto (Table.States (778), 293, 97);
Table.States (778).Kernel := To_Vector ((0 => (230, 59, 1, False)));
Table.States (778).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (779), 37, Reduce, (230, 1), 5, null, null);
Add_Action (Table.States (779), 76, 235);
Add_Action (Table.States (779), 84, 237);
Add_Action (Table.States (779), 87, Reduce, (230, 1), 5, null, null);
Add_Action (Table.States (779), 101, 239);
Add_Action (Table.States (779), 102, 240);
Add_Error (Table.States (779));
Add_Goto (Table.States (779), 115, 241);
Add_Goto (Table.States (779), 322, 242);
Table.States (779).Kernel := To_Vector (((128, 239, 2, True), (230, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (779).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 230, 5)));
Add_Action (Table.States (780), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 74, 93, 104, 105, 106, 107), (127, 0), 6,
at_clause_0'Access, null);
Table.States (780).Kernel := To_Vector ((0 => (127, 96, 0, False)));
Table.States (780).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 127, 6)));
Add_Action (Table.States (781), 3, 121);
Add_Action (Table.States (781), 39, 122);
Add_Action (Table.States (781), 40, 123);
Add_Action (Table.States (781), 41, 124);
Add_Action (Table.States (781), 52, 125);
Add_Action (Table.States (781), 76, 126);
Add_Action (Table.States (781), 94, 127);
Add_Action (Table.States (781), 95, 128);
Add_Action (Table.States (781), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (781), 103, 129);
Add_Action (Table.States (781), 104, 119);
Add_Action (Table.States (781), 105, 33);
Add_Action (Table.States (781), 106, 34);
Add_Error (Table.States (781));
Add_Goto (Table.States (781), 117, 130);
Add_Goto (Table.States (781), 128, 41);
Add_Goto (Table.States (781), 191, 131);
Add_Goto (Table.States (781), 192, 961);
Add_Goto (Table.States (781), 197, 133);
Add_Goto (Table.States (781), 239, 134);
Add_Goto (Table.States (781), 258, 135);
Add_Goto (Table.States (781), 272, 92);
Add_Goto (Table.States (781), 275, 136);
Add_Goto (Table.States (781), 282, 137);
Add_Goto (Table.States (781), 283, 138);
Add_Goto (Table.States (781), 284, 139);
Add_Goto (Table.States (781), 285, 140);
Add_Goto (Table.States (781), 286, 141);
Add_Goto (Table.States (781), 287, 142);
Add_Goto (Table.States (781), 293, 97);
Add_Goto (Table.States (781), 301, 143);
Add_Goto (Table.States (781), 320, 144);
Add_Goto (Table.States (781), 321, 145);
Add_Goto (Table.States (781), 330, 146);
Table.States (781).Kernel := To_Vector ((0 => (235, 38, 1, False)));
Table.States (781).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (782), 12, 962);
Add_Error (Table.States (782));
Table.States (782).Kernel := To_Vector ((0 => (144, 104, 7, False)));
Table.States (782).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 12, 962)));
Add_Action (Table.States (783), (24, 104), (145, 1), 1, null, null);
Table.States (783).Kernel := To_Vector ((0 => (145, 144, 0, False)));
Table.States (783).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 145, 1)));
Add_Action (Table.States (784), 24, 963);
Add_Action (Table.States (784), 104, 782);
Add_Error (Table.States (784));
Add_Goto (Table.States (784), 144, 964);
Table.States (784).Kernel := To_Vector (((145, 145, 8, True), (281, 145, 3, False)));
Table.States (784).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 963)));
Add_Action (Table.States (785), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (785), 33, 504);
Add_Action (Table.States (785), 40, 386);
Add_Conflict (Table.States (785), 40, (236, 3), 0, null, null);
Add_Action (Table.States (785), 45, 505);
Add_Action (Table.States (785), 104, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (785), 105, Reduce, (236, 3), 0, null, null);
Add_Action (Table.States (785), 106, Reduce, (236, 3), 0, null, null);
Add_Error (Table.States (785));
Add_Goto (Table.States (785), 114, 965);
Add_Goto (Table.States (785), 236, 966);
Add_Goto (Table.States (785), 241, 721);
Table.States (785).Kernel := To_Vector (((254, 118, 2, False), (254, 118, 1, False), (254, 118, 3, False),
(254, 118, 2, False)));
Table.States (785).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 236, 0)));
Add_Action (Table.States (786), (77, 96), (255, 0), 3, parameter_specification_list_0'Access, null);
Table.States (786).Kernel := To_Vector ((0 => (255, 254, 0, True)));
Table.States (786).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 255, 3)));
Table.States (786).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (787), 96, 967);
Add_Error (Table.States (787));
Table.States (787).Kernel := To_Vector ((0 => (215, 122, 1, False)));
Table.States (787).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 967)));
Add_Action (Table.States (788), 96, 968);
Add_Error (Table.States (788));
Table.States (788).Kernel := To_Vector ((0 => (215, 122, 1, False)));
Table.States (788).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 968)));
Add_Action (Table.States (789), 96, 969);
Add_Error (Table.States (789));
Table.States (789).Kernel := To_Vector ((0 => (215, 122, 1, False)));
Table.States (789).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 969)));
Add_Action (Table.States (790), 36, 970);
Add_Action (Table.States (790), 39, Reduce, (109, 2), 1, null, null);
Add_Action (Table.States (790), 64, 875);
Add_Action (Table.States (790), 65, 876);
Add_Error (Table.States (790));
Table.States (790).Kernel := To_Vector (((109, 6, 1, False), (109, 6, 1, False), (109, 6, 0, False), (111,
6, 2, False), (111, 6, 1, False)));
Table.States (790).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 109, 1)));
Add_Action (Table.States (791), 80, 971);
Add_Error (Table.States (791));
Table.States (791).Kernel := To_Vector (((202, 19, 3, False), (202, 19, 1, False)));
Table.States (791).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 971)));
Add_Action (Table.States (792), 80, 972);
Add_Error (Table.States (792));
Table.States (792).Kernel := To_Vector ((0 => (202, 20, 1, False)));
Table.States (792).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 972)));
Add_Action (Table.States (793), 34, 880);
Add_Action (Table.States (793), 39, Reduce, (109, 3), 1, null, null);
Add_Action (Table.States (793), 49, Reduce, (111, 4), 1, null, null);
Add_Error (Table.States (793));
Table.States (793).Kernel := To_Vector (((109, 36, 0, False), (111, 36, 0, False), (228, 36, 3, False),
(228, 36, 1, False)));
Table.States (793).Minimal_Complete_Actions := To_Vector (((Reduce, 109, 1), (Reduce, 111, 1)));
Add_Action (Table.States (794), 80, 973);
Add_Error (Table.States (794));
Table.States (794).Kernel := To_Vector ((0 => (202, 38, 1, False)));
Table.States (794).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 973)));
Add_Action (Table.States (795), 80, 974);
Add_Error (Table.States (795));
Table.States (795).Kernel := To_Vector ((0 => (202, 53, 1, False)));
Table.States (795).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 974)));
Add_Action (Table.States (796), 36, 895);
Add_Action (Table.States (796), 49, Reduce, (111, 3), 1, null, null);
Add_Action (Table.States (796), 74, 337);
Add_Action (Table.States (796), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (796));
Add_Goto (Table.States (796), 122, 975);
Table.States (796).Kernel := To_Vector (((111, 65, 1, False), (111, 65, 0, False), (201, 65, 1, False)));
Table.States (796).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 111, 1)));
Add_Action (Table.States (797), 80, 976);
Add_Error (Table.States (797));
Table.States (797).Kernel := To_Vector ((0 => (202, 76, 2, False)));
Table.States (797).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 976)));
Add_Action (Table.States (798), 39, 977);
Add_Error (Table.States (798));
Table.States (798).Kernel := To_Vector (((203, 109, 4, False), (203, 109, 2, False)));
Table.States (798).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 39, 977)));
Add_Action (Table.States (799), 49, 978);
Add_Error (Table.States (799));
Table.States (799).Kernel := To_Vector ((0 => (202, 111, 1, False)));
Table.States (799).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 49, 978)));
Add_Action (Table.States (800), (74, 96), (202, 9), 1, null, null);
Table.States (800).Kernel := To_Vector ((0 => (202, 114, 0, False)));
Table.States (800).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 1)));
Add_Action (Table.States (801), (74, 96), (202, 8), 1, null, null);
Table.States (801).Kernel := To_Vector ((0 => (202, 120, 0, False)));
Table.States (801).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 1)));
Add_Action (Table.States (802), 74, 337);
Add_Action (Table.States (802), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (802));
Add_Goto (Table.States (802), 122, 979);
Table.States (802).Kernel := To_Vector ((0 => (201, 202, 1, False)));
Table.States (802).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (803), (74, 96), (202, 1), 1, null, null);
Table.States (803).Kernel := To_Vector ((0 => (202, 203, 0, False)));
Table.States (803).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 1)));
Add_Action (Table.States (804), (74, 96), (202, 10), 1, null, null);
Table.States (804).Kernel := To_Vector ((0 => (202, 228, 0, False)));
Table.States (804).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 1)));
Add_Action (Table.States (805), (29, 47, 48, 50, 69, 71, 74, 104), (201, 2), 5,
formal_type_declaration_2'Access, null);
Table.States (805).Kernel := To_Vector ((0 => (201, 96, 0, False)));
Table.States (805).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 201, 5)));
Add_Action (Table.States (806), 104, 119);
Add_Action (Table.States (806), 105, 33);
Add_Action (Table.States (806), 106, 34);
Add_Error (Table.States (806));
Add_Goto (Table.States (806), 128, 41);
Add_Goto (Table.States (806), 239, 980);
Add_Goto (Table.States (806), 272, 92);
Add_Goto (Table.States (806), 293, 97);
Table.States (806).Kernel := To_Vector ((0 => (204, 39, 2, False)));
Table.States (806).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (807), 96, 981);
Add_Error (Table.States (807));
Table.States (807).Kernel := To_Vector ((0 => (200, 122, 1, False)));
Table.States (807).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 981)));
Add_Action (Table.States (808), 74, 337);
Add_Action (Table.States (808), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (808));
Add_Goto (Table.States (808), 122, 982);
Table.States (808).Kernel := To_Vector ((0 => (200, 310, 1, False)));
Table.States (808).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (809), 96, 983);
Add_Error (Table.States (809));
Table.States (809).Kernel := To_Vector ((0 => (200, 122, 1, False)));
Table.States (809).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 983)));
Add_Action (Table.States (810), 3, 121);
Add_Action (Table.States (810), 39, 122);
Add_Action (Table.States (810), 40, 123);
Add_Action (Table.States (810), 41, 124);
Add_Action (Table.States (810), 52, 125);
Add_Action (Table.States (810), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (810), 76, 126);
Add_Action (Table.States (810), 94, 127);
Add_Action (Table.States (810), 95, 128);
Add_Action (Table.States (810), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (810), 103, 129);
Add_Action (Table.States (810), 104, 119);
Add_Action (Table.States (810), 105, 33);
Add_Action (Table.States (810), 106, 34);
Add_Error (Table.States (810));
Add_Goto (Table.States (810), 117, 130);
Add_Goto (Table.States (810), 128, 41);
Add_Goto (Table.States (810), 191, 131);
Add_Goto (Table.States (810), 192, 984);
Add_Goto (Table.States (810), 197, 133);
Add_Goto (Table.States (810), 239, 134);
Add_Goto (Table.States (810), 258, 135);
Add_Goto (Table.States (810), 272, 92);
Add_Goto (Table.States (810), 275, 136);
Add_Goto (Table.States (810), 282, 137);
Add_Goto (Table.States (810), 283, 138);
Add_Goto (Table.States (810), 284, 139);
Add_Goto (Table.States (810), 285, 140);
Add_Goto (Table.States (810), 286, 141);
Add_Goto (Table.States (810), 287, 142);
Add_Goto (Table.States (810), 293, 97);
Add_Goto (Table.States (810), 301, 143);
Add_Goto (Table.States (810), 320, 144);
Add_Goto (Table.States (810), 321, 145);
Add_Goto (Table.States (810), 330, 146);
Table.States (810).Kernel := To_Vector ((0 => (198, 82, 1, False)));
Table.States (810).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (811), 96, 985);
Add_Error (Table.States (811));
Table.States (811).Kernel := To_Vector ((0 => (198, 122, 1, False)));
Table.States (811).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 985)));
Add_Action (Table.States (812), 74, 337);
Add_Action (Table.States (812), 76, 235);
Add_Action (Table.States (812), 82, 986);
Add_Action (Table.States (812), 84, 237);
Add_Action (Table.States (812), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (812), 101, 239);
Add_Action (Table.States (812), 102, 240);
Add_Error (Table.States (812));
Add_Goto (Table.States (812), 115, 241);
Add_Goto (Table.States (812), 122, 987);
Add_Goto (Table.States (812), 322, 242);
Table.States (812).Kernel := To_Vector (((128, 239, 2, True), (198, 239, 2, False), (198, 239, 1, False),
(239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (812).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (813), 24, 988);
Add_Error (Table.States (813));
Table.States (813).Kernel := To_Vector ((0 => (222, 300, 3, False)));
Table.States (813).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 988)));
Add_Action (Table.States (814), 68, 989);
Add_Error (Table.States (814));
Table.States (814).Kernel := To_Vector ((0 => (174, 192, 1, False)));
Table.States (814).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 68, 989)));
Add_Action (Table.States (815), 96, 990);
Add_Error (Table.States (815));
Table.States (815).Kernel := To_Vector ((0 => (222, 32, 1, False)));
Table.States (815).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 990)));
Add_Action (Table.States (816), 4, 1);
Add_Action (Table.States (816), 5, 2);
Add_Action (Table.States (816), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (816), 15, 3);
Add_Action (Table.States (816), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (816), 18, 4);
Add_Action (Table.States (816), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (816), 27, 5);
Add_Action (Table.States (816), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (816), 31, 9);
Add_Action (Table.States (816), 32, 10);
Add_Action (Table.States (816), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (816), 41, 13);
Add_Action (Table.States (816), 48, 16);
Add_Action (Table.States (816), 52, 20);
Add_Action (Table.States (816), 57, 21);
Add_Action (Table.States (816), 58, 22);
Add_Action (Table.States (816), 61, 24);
Add_Action (Table.States (816), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (816), 93, 31);
Add_Action (Table.States (816), 104, 360);
Add_Action (Table.States (816), 105, 33);
Add_Action (Table.States (816), 106, 34);
Add_Error (Table.States (816));
Add_Goto (Table.States (816), 113, 36);
Add_Goto (Table.States (816), 123, 38);
Add_Goto (Table.States (816), 126, 39);
Add_Goto (Table.States (816), 128, 41);
Add_Goto (Table.States (816), 131, 42);
Add_Goto (Table.States (816), 132, 43);
Add_Goto (Table.States (816), 133, 44);
Add_Goto (Table.States (816), 139, 47);
Add_Goto (Table.States (816), 151, 50);
Add_Goto (Table.States (816), 152, 51);
Add_Goto (Table.States (816), 161, 53);
Add_Goto (Table.States (816), 190, 57);
Add_Goto (Table.States (816), 196, 59);
Add_Goto (Table.States (816), 217, 68);
Add_Goto (Table.States (816), 222, 70);
Add_Goto (Table.States (816), 232, 72);
Add_Goto (Table.States (816), 239, 73);
Add_Goto (Table.States (816), 257, 83);
Add_Goto (Table.States (816), 261, 86);
Add_Goto (Table.States (816), 272, 92);
Add_Goto (Table.States (816), 276, 93);
Add_Goto (Table.States (816), 290, 96);
Add_Goto (Table.States (816), 293, 97);
Add_Goto (Table.States (816), 294, 98);
Add_Goto (Table.States (816), 298, 99);
Add_Goto (Table.States (816), 299, 361);
Add_Goto (Table.States (816), 300, 991);
Add_Goto (Table.States (816), 302, 100);
Add_Goto (Table.States (816), 303, 101);
Add_Goto (Table.States (816), 306, 363);
Add_Goto (Table.States (816), 323, 114);
Table.States (816).Kernel := To_Vector ((0 => (222, 22, 3, False)));
Table.States (816).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (817), 32, 992);
Add_Error (Table.States (817));
Table.States (817).Kernel := To_Vector ((0 => (222, 24, 2, False)));
Table.States (817).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 32, 992)));
Add_Action (Table.States (818), (22, 23, 24), (175, 0), 2, null, null);
Table.States (818).Kernel := To_Vector ((0 => (175, 174, 0, True)));
Table.States (818).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 175, 2)));
Table.States (818).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (819), 96, 993);
Add_Error (Table.States (819));
Table.States (819).Kernel := To_Vector ((0 => (248, 122, 1, False)));
Table.States (819).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 993)));
Add_Action (Table.States (820), 13, 994);
Add_Action (Table.States (820), 24, 995);
Add_Error (Table.States (820));
Table.States (820).Kernel := To_Vector (((247, 159, 3, False), (247, 159, 2, False)));
Table.States (820).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 995)));
end Subr_14;
procedure Subr_15
is begin
Add_Action (Table.States (821), 96, 996);
Add_Error (Table.States (821));
Table.States (821).Kernel := To_Vector ((0 => (213, 122, 1, False)));
Table.States (821).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 996)));
Add_Action (Table.States (822), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (250, 0), 6,
package_renaming_declaration_0'Access, null);
Table.States (822).Kernel := To_Vector ((0 => (250, 96, 0, False)));
Table.States (822).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 250, 6)));
Add_Action (Table.States (823), 96, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (823), 104, 119);
Add_Action (Table.States (823), 105, 33);
Add_Action (Table.States (823), 106, 34);
Add_Error (Table.States (823));
Add_Goto (Table.States (823), 128, 41);
Add_Goto (Table.States (823), 239, 630);
Add_Goto (Table.States (823), 240, 997);
Add_Goto (Table.States (823), 272, 92);
Add_Goto (Table.States (823), 293, 97);
Table.States (823).Kernel := To_Vector ((0 => (251, 24, 0, False)));
Table.States (823).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 240, 0)));
Add_Action (Table.States (824), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (824), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (824), 28, 183);
Add_Action (Table.States (824), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (824), 30, 8);
Add_Action (Table.States (824), 40, 12);
Add_Action (Table.States (824), 46, 14);
Add_Action (Table.States (824), 47, 15);
Add_Action (Table.States (824), 48, 16);
Add_Action (Table.States (824), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (824), 51, 19);
Add_Action (Table.States (824), 63, 25);
Add_Action (Table.States (824), 66, 26);
Add_Action (Table.States (824), 69, 27);
Add_Action (Table.States (824), 71, 28);
Add_Action (Table.States (824), 104, 185);
Add_Error (Table.States (824));
Add_Goto (Table.States (824), 112, 35);
Add_Goto (Table.States (824), 121, 37);
Add_Goto (Table.States (824), 127, 40);
Add_Goto (Table.States (824), 134, 45);
Add_Goto (Table.States (824), 135, 46);
Add_Goto (Table.States (824), 157, 391);
Add_Goto (Table.States (824), 158, 392);
Add_Goto (Table.States (824), 159, 998);
Add_Goto (Table.States (824), 179, 54);
Add_Goto (Table.States (824), 182, 55);
Add_Goto (Table.States (824), 186, 56);
Add_Goto (Table.States (824), 193, 58);
Add_Goto (Table.States (824), 206, 60);
Add_Goto (Table.States (824), 207, 61);
Add_Goto (Table.States (824), 209, 62);
Add_Goto (Table.States (824), 210, 63);
Add_Goto (Table.States (824), 213, 64);
Add_Goto (Table.States (824), 214, 65);
Add_Goto (Table.States (824), 215, 66);
Add_Goto (Table.States (824), 216, 67);
Add_Goto (Table.States (824), 219, 69);
Add_Goto (Table.States (824), 223, 71);
Add_Goto (Table.States (824), 243, 74);
Add_Goto (Table.States (824), 244, 75);
Add_Goto (Table.States (824), 245, 76);
Add_Goto (Table.States (824), 246, 77);
Add_Goto (Table.States (824), 247, 78);
Add_Goto (Table.States (824), 248, 79);
Add_Goto (Table.States (824), 249, 80);
Add_Goto (Table.States (824), 250, 81);
Add_Goto (Table.States (824), 251, 82);
Add_Goto (Table.States (824), 257, 394);
Add_Goto (Table.States (824), 259, 84);
Add_Goto (Table.States (824), 260, 85);
Add_Goto (Table.States (824), 262, 87);
Add_Goto (Table.States (824), 263, 88);
Add_Goto (Table.States (824), 264, 89);
Add_Goto (Table.States (824), 265, 90);
Add_Goto (Table.States (824), 271, 91);
Add_Goto (Table.States (824), 281, 94);
Add_Goto (Table.States (824), 289, 95);
Add_Goto (Table.States (824), 304, 102);
Add_Goto (Table.States (824), 305, 103);
Add_Goto (Table.States (824), 307, 105);
Add_Goto (Table.States (824), 308, 106);
Add_Goto (Table.States (824), 309, 107);
Add_Goto (Table.States (824), 311, 108);
Add_Goto (Table.States (824), 313, 109);
Add_Goto (Table.States (824), 316, 111);
Add_Goto (Table.States (824), 317, 112);
Add_Goto (Table.States (824), 319, 113);
Add_Goto (Table.States (824), 325, 115);
Add_Goto (Table.States (824), 331, 116);
Table.States (824).Kernel := To_Vector ((0 => (251, 49, 1, False)));
Table.States (824).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (825), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (257, 0), 6, pragma_g_0'Access, null);
Table.States (825).Kernel := To_Vector ((0 => (257, 96, 0, False)));
Table.States (825).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 257, 6)));
Add_Action (Table.States (826), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (257, 1), 6, pragma_g_1'Access, null);
Table.States (826).Kernel := To_Vector ((0 => (257, 96, 0, False)));
Table.States (826).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 257, 6)));
Add_Action (Table.States (827), 96, 999);
Add_Error (Table.States (827));
Table.States (827).Kernel := To_Vector ((0 => (265, 122, 1, False)));
Table.States (827).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 999)));
Add_Action (Table.States (828), 104, 1000);
Add_Error (Table.States (828));
Table.States (828).Kernel := To_Vector ((0 => (176, 25, 6, False)));
Table.States (828).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 1000)));
Add_Action (Table.States (829), (24, 25, 28, 29, 40, 46, 50), (267, 5), 1, null, null);
Table.States (829).Kernel := To_Vector ((0 => (267, 121, 0, False)));
Table.States (829).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 267, 1)));
Add_Action (Table.States (830), (24, 25, 28, 29, 40, 46, 50), (267, 2), 1, null, null);
Table.States (830).Kernel := To_Vector ((0 => (267, 176, 0, False)));
Table.States (830).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 267, 1)));
Add_Action (Table.States (831), (24, 25, 28, 29, 40, 46, 50), (267, 3), 1, null, null);
Table.States (831).Kernel := To_Vector ((0 => (267, 193, 0, False)));
Table.States (831).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 267, 1)));
Add_Action (Table.States (832), (24, 25, 28, 29, 40, 46, 50), (267, 4), 1, null, null);
Table.States (832).Kernel := To_Vector ((0 => (267, 243, 0, False)));
Table.States (832).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 267, 1)));
Add_Action (Table.States (833), 29, 7);
Add_Action (Table.States (833), 50, 18);
Add_Error (Table.States (833));
Add_Goto (Table.States (833), 207, 246);
Add_Goto (Table.States (833), 262, 247);
Add_Goto (Table.States (833), 312, 1001);
Table.States (833).Kernel := To_Vector (((193, 246, 7, False), (243, 246, 5, False), (307, 246, 6, False),
(309, 246, 3, False)));
Table.States (833).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 50, 18)));
Add_Action (Table.States (834), (24, 25, 28, 29, 40, 46, 50), (268, 1), 1, null, null);
Table.States (834).Kernel := To_Vector ((0 => (268, 267, 0, False)));
Table.States (834).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 268, 1)));
Add_Action (Table.States (835), 24, Reduce, (269, 0), 1, null, null);
Add_Action (Table.States (835), 25, 828);
Add_Action (Table.States (835), 28, 183);
Add_Action (Table.States (835), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (835), 40, 12);
Add_Action (Table.States (835), 46, 14);
Add_Action (Table.States (835), 50, Reduce, (246, 2), 0, null, null);
Add_Error (Table.States (835));
Add_Goto (Table.States (835), 121, 829);
Add_Goto (Table.States (835), 127, 40);
Add_Goto (Table.States (835), 176, 830);
Add_Goto (Table.States (835), 182, 55);
Add_Goto (Table.States (835), 193, 831);
Add_Goto (Table.States (835), 207, 61);
Add_Goto (Table.States (835), 243, 832);
Add_Goto (Table.States (835), 246, 833);
Add_Goto (Table.States (835), 262, 87);
Add_Goto (Table.States (835), 267, 1002);
Add_Goto (Table.States (835), 281, 94);
Add_Goto (Table.States (835), 307, 837);
Add_Goto (Table.States (835), 309, 838);
Table.States (835).Kernel := To_Vector (((268, 268, 3, True), (269, 268, 0, False)));
Table.States (835).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 269, 1)));
Add_Action (Table.States (836), 24, 1003);
Add_Error (Table.States (836));
Table.States (836).Kernel := To_Vector ((0 => (264, 269, 2, False)));
Table.States (836).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1003)));
Add_Action (Table.States (837), (24, 25, 28, 29, 40, 46, 50), (267, 1), 1, null, null);
Table.States (837).Kernel := To_Vector ((0 => (267, 307, 0, False)));
Table.States (837).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 267, 1)));
Add_Action (Table.States (838), (24, 25, 28, 29, 40, 46, 50), (267, 0), 1, null, null);
Table.States (838).Kernel := To_Vector ((0 => (267, 309, 0, False)));
Table.States (838).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 267, 1)));
Add_Action (Table.States (839), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (839), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (839), 28, 183);
Add_Action (Table.States (839), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (839), 30, 8);
Add_Action (Table.States (839), 39, 1004);
Add_Action (Table.States (839), 40, 12);
Add_Action (Table.States (839), 46, 14);
Add_Action (Table.States (839), 47, 15);
Add_Action (Table.States (839), 48, 16);
Add_Action (Table.States (839), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (839), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (839), 51, 19);
Add_Action (Table.States (839), 63, 25);
Add_Action (Table.States (839), 66, 26);
Add_Action (Table.States (839), 69, 27);
Add_Action (Table.States (839), 71, 28);
Add_Action (Table.States (839), 104, 185);
Add_Error (Table.States (839));
Add_Goto (Table.States (839), 112, 35);
Add_Goto (Table.States (839), 121, 37);
Add_Goto (Table.States (839), 127, 40);
Add_Goto (Table.States (839), 134, 45);
Add_Goto (Table.States (839), 135, 46);
Add_Goto (Table.States (839), 157, 391);
Add_Goto (Table.States (839), 158, 392);
Add_Goto (Table.States (839), 159, 667);
Add_Goto (Table.States (839), 179, 54);
Add_Goto (Table.States (839), 182, 55);
Add_Goto (Table.States (839), 186, 56);
Add_Goto (Table.States (839), 193, 58);
Add_Goto (Table.States (839), 206, 60);
Add_Goto (Table.States (839), 207, 61);
Add_Goto (Table.States (839), 209, 62);
Add_Goto (Table.States (839), 210, 63);
Add_Goto (Table.States (839), 213, 64);
Add_Goto (Table.States (839), 214, 65);
Add_Goto (Table.States (839), 215, 66);
Add_Goto (Table.States (839), 216, 67);
Add_Goto (Table.States (839), 219, 69);
Add_Goto (Table.States (839), 223, 71);
Add_Goto (Table.States (839), 243, 74);
Add_Goto (Table.States (839), 244, 75);
Add_Goto (Table.States (839), 245, 76);
Add_Goto (Table.States (839), 246, 77);
Add_Goto (Table.States (839), 247, 78);
Add_Goto (Table.States (839), 248, 79);
Add_Goto (Table.States (839), 249, 80);
Add_Goto (Table.States (839), 250, 81);
Add_Goto (Table.States (839), 251, 82);
Add_Goto (Table.States (839), 257, 394);
Add_Goto (Table.States (839), 259, 84);
Add_Goto (Table.States (839), 260, 85);
Add_Goto (Table.States (839), 262, 87);
Add_Goto (Table.States (839), 263, 88);
Add_Goto (Table.States (839), 264, 89);
Add_Goto (Table.States (839), 265, 90);
Add_Goto (Table.States (839), 266, 1005);
Add_Goto (Table.States (839), 271, 91);
Add_Goto (Table.States (839), 281, 94);
Add_Goto (Table.States (839), 289, 95);
Add_Goto (Table.States (839), 304, 102);
Add_Goto (Table.States (839), 305, 103);
Add_Goto (Table.States (839), 307, 105);
Add_Goto (Table.States (839), 308, 106);
Add_Goto (Table.States (839), 309, 107);
Add_Goto (Table.States (839), 311, 108);
Add_Goto (Table.States (839), 313, 109);
Add_Goto (Table.States (839), 316, 111);
Add_Goto (Table.States (839), 317, 112);
Add_Goto (Table.States (839), 319, 113);
Add_Goto (Table.States (839), 325, 115);
Add_Goto (Table.States (839), 331, 116);
Table.States (839).Kernel := To_Vector (((271, 35, 5, False), (271, 35, 2, False)));
Table.States (839).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (840), 10, 1006);
Add_Action (Table.States (840), 74, 1007);
Add_Error (Table.States (840));
Table.States (840).Kernel := To_Vector (((227, 227, 2, True), (304, 227, 3, False)));
Table.States (840).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 1007)));
Add_Action (Table.States (841), 10, Reduce, (227, 1), 1, interface_list_1'Access, null);
Add_Action (Table.States (841), 74, Reduce, (227, 1), 1, interface_list_1'Access, null);
Add_Action (Table.States (841), 76, 235);
Add_Action (Table.States (841), 84, 237);
Add_Action (Table.States (841), 96, Reduce, (227, 1), 1, interface_list_1'Access, null);
Add_Action (Table.States (841), 101, 239);
Add_Action (Table.States (841), 102, 240);
Add_Error (Table.States (841));
Add_Goto (Table.States (841), 115, 241);
Add_Goto (Table.States (841), 322, 242);
Table.States (841).Kernel := To_Vector (((128, 239, 2, True), (227, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (841).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 227, 1)));
Add_Action (Table.States (842), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (842), 104, 149);
Add_Error (Table.States (842));
Add_Goto (Table.States (842), 220, 1008);
Table.States (842).Kernel := To_Vector ((0 => (266, 24, 0, False)));
Table.States (842).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (843), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (843), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (843), 28, 183);
Add_Action (Table.States (843), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (843), 30, 8);
Add_Action (Table.States (843), 40, 12);
Add_Action (Table.States (843), 46, 14);
Add_Action (Table.States (843), 47, 15);
Add_Action (Table.States (843), 48, 16);
Add_Action (Table.States (843), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (843), 51, 19);
Add_Action (Table.States (843), 63, 25);
Add_Action (Table.States (843), 66, 26);
Add_Action (Table.States (843), 69, 27);
Add_Action (Table.States (843), 71, 28);
Add_Action (Table.States (843), 104, 185);
Add_Error (Table.States (843));
Add_Goto (Table.States (843), 112, 35);
Add_Goto (Table.States (843), 121, 37);
Add_Goto (Table.States (843), 127, 40);
Add_Goto (Table.States (843), 134, 45);
Add_Goto (Table.States (843), 135, 46);
Add_Goto (Table.States (843), 157, 391);
Add_Goto (Table.States (843), 158, 392);
Add_Goto (Table.States (843), 159, 1009);
Add_Goto (Table.States (843), 179, 54);
Add_Goto (Table.States (843), 182, 55);
Add_Goto (Table.States (843), 186, 56);
Add_Goto (Table.States (843), 193, 58);
Add_Goto (Table.States (843), 206, 60);
Add_Goto (Table.States (843), 207, 61);
Add_Goto (Table.States (843), 209, 62);
Add_Goto (Table.States (843), 210, 63);
Add_Goto (Table.States (843), 213, 64);
Add_Goto (Table.States (843), 214, 65);
Add_Goto (Table.States (843), 215, 66);
Add_Goto (Table.States (843), 216, 67);
Add_Goto (Table.States (843), 219, 69);
Add_Goto (Table.States (843), 223, 71);
Add_Goto (Table.States (843), 243, 74);
Add_Goto (Table.States (843), 244, 75);
Add_Goto (Table.States (843), 245, 76);
Add_Goto (Table.States (843), 246, 77);
Add_Goto (Table.States (843), 247, 78);
Add_Goto (Table.States (843), 248, 79);
Add_Goto (Table.States (843), 249, 80);
Add_Goto (Table.States (843), 250, 81);
Add_Goto (Table.States (843), 251, 82);
Add_Goto (Table.States (843), 257, 394);
Add_Goto (Table.States (843), 259, 84);
Add_Goto (Table.States (843), 260, 85);
Add_Goto (Table.States (843), 262, 87);
Add_Goto (Table.States (843), 263, 88);
Add_Goto (Table.States (843), 264, 89);
Add_Goto (Table.States (843), 265, 90);
Add_Goto (Table.States (843), 271, 91);
Add_Goto (Table.States (843), 281, 94);
Add_Goto (Table.States (843), 289, 95);
Add_Goto (Table.States (843), 304, 102);
Add_Goto (Table.States (843), 305, 103);
Add_Goto (Table.States (843), 307, 105);
Add_Goto (Table.States (843), 308, 106);
Add_Goto (Table.States (843), 309, 107);
Add_Goto (Table.States (843), 311, 108);
Add_Goto (Table.States (843), 313, 109);
Add_Goto (Table.States (843), 316, 111);
Add_Goto (Table.States (843), 317, 112);
Add_Goto (Table.States (843), 319, 113);
Add_Goto (Table.States (843), 325, 115);
Add_Goto (Table.States (843), 331, 116);
Table.States (843).Kernel := To_Vector ((0 => (266, 49, 1, False)));
Table.States (843).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (844), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (304, 1), 6,
single_protected_declaration_1'Access, single_protected_declaration_1_check'Access);
Table.States (844).Kernel := To_Vector ((0 => (304, 96, 0, False)));
Table.States (844).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 304, 6)));
Add_Action (Table.States (845), (21, 82, 96), (292, 1), 1, null, null);
Table.States (845).Kernel := To_Vector ((0 => (292, 114, 0, False)));
Table.States (845).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 292, 1)));
Add_Action (Table.States (846), 21, Reduce, (194, 1), 5, extended_return_object_declaration_1'Access,
null);
Add_Action (Table.States (846), 82, 1010);
Add_Action (Table.States (846), 96, Reduce, (194, 1), 5, extended_return_object_declaration_1'Access,
null);
Add_Error (Table.States (846));
Table.States (846).Kernel := To_Vector (((194, 292, 1, False), (194, 292, 0, False)));
Table.States (846).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 194, 5)));
Add_Action (Table.States (847), (21, 82, 96), (292, 0), 1, null, null);
Table.States (847).Kernel := To_Vector ((0 => (292, 314, 0, False)));
Table.States (847).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 292, 1)));
Add_Action (Table.States (848), 96, 1011);
Add_Error (Table.States (848));
Table.States (848).Kernel := To_Vector ((0 => (196, 58, 1, False)));
Table.States (848).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1011)));
Add_Action (Table.States (849), 104, 119);
Add_Action (Table.States (849), 105, 33);
Add_Action (Table.States (849), 106, 34);
Add_Error (Table.States (849));
Add_Goto (Table.States (849), 128, 41);
Add_Goto (Table.States (849), 239, 1012);
Add_Goto (Table.States (849), 272, 92);
Add_Goto (Table.States (849), 293, 97);
Table.States (849).Kernel := To_Vector (((247, 14, 5, False), (247, 14, 4, False)));
Table.States (849).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (850), 104, 1013);
Add_Error (Table.States (850));
Table.States (850).Kernel := To_Vector ((0 => (264, 14, 4, False)));
Table.States (850).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 1013)));
Add_Action (Table.States (851), 104, 1014);
Add_Error (Table.States (851));
Table.States (851).Kernel := To_Vector ((0 => (316, 14, 5, False)));
Table.States (851).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 1014)));
Add_Action (Table.States (852), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (852), 74, 337);
Add_Error (Table.States (852));
Add_Goto (Table.States (852), 122, 1015);
Table.States (852).Kernel := To_Vector ((0 => (307, 312, 4, False)));
Table.States (852).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (853), (22, 24, 43), (295, 1), 5, select_alternative_1'Access, null);
Table.States (853).Kernel := To_Vector ((0 => (295, 96, 0, False)));
Table.States (853).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 295, 5)));
Add_Action (Table.States (854), (22, 24, 43), (295, 0), 5, select_alternative_0'Access, null);
Table.States (854).Kernel := To_Vector ((0 => (295, 300, 0, False)));
Table.States (854).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 295, 5)));
Add_Action (Table.States (855), 96, 1016);
Add_Error (Table.States (855));
Table.States (855).Kernel := To_Vector ((0 => (152, 61, 1, False)));
Table.States (855).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1016)));
Add_Action (Table.States (856), 96, 1017);
Add_Error (Table.States (856));
Table.States (856).Kernel := To_Vector ((0 => (323, 61, 1, False)));
Table.States (856).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1017)));
Add_Action (Table.States (857), 96, 1018);
Add_Error (Table.States (857));
Table.States (857).Kernel := To_Vector ((0 => (294, 61, 1, False)));
Table.States (857).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1018)));
Add_Action (Table.States (858), 61, 1019);
Add_Error (Table.States (858));
Table.States (858).Kernel := To_Vector ((0 => (126, 24, 2, False)));
Table.States (858).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 61, 1019)));
Add_Action (Table.States (859), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (313, 0), 6,
subtype_declaration_0'Access, null);
Table.States (859).Kernel := To_Vector ((0 => (313, 96, 0, False)));
Table.States (859).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 313, 6)));
Add_Action (Table.States (860), 96, 1020);
Add_Error (Table.States (860));
Table.States (860).Kernel := To_Vector ((0 => (317, 122, 1, False)));
Table.States (860).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1020)));
Add_Action (Table.States (861), 13, 1021);
Add_Error (Table.States (861));
Table.States (861).Kernel := To_Vector ((0 => (316, 159, 3, False)));
Table.States (861).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 1021)));
Add_Action (Table.States (862), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (862), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (862), 28, 183);
Add_Action (Table.States (862), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (862), 30, 8);
Add_Action (Table.States (862), 39, 1022);
Add_Action (Table.States (862), 40, 12);
Add_Action (Table.States (862), 46, 14);
Add_Action (Table.States (862), 47, 15);
Add_Action (Table.States (862), 48, 16);
Add_Action (Table.States (862), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (862), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (862), 51, 19);
Add_Action (Table.States (862), 63, 25);
Add_Action (Table.States (862), 66, 26);
Add_Action (Table.States (862), 69, 27);
Add_Action (Table.States (862), 71, 28);
Add_Action (Table.States (862), 104, 185);
Add_Error (Table.States (862));
Add_Goto (Table.States (862), 112, 35);
Add_Goto (Table.States (862), 121, 37);
Add_Goto (Table.States (862), 127, 40);
Add_Goto (Table.States (862), 134, 45);
Add_Goto (Table.States (862), 135, 46);
Add_Goto (Table.States (862), 157, 391);
Add_Goto (Table.States (862), 158, 392);
Add_Goto (Table.States (862), 159, 692);
Add_Goto (Table.States (862), 179, 54);
Add_Goto (Table.States (862), 182, 55);
Add_Goto (Table.States (862), 186, 56);
Add_Goto (Table.States (862), 193, 58);
Add_Goto (Table.States (862), 206, 60);
Add_Goto (Table.States (862), 207, 61);
Add_Goto (Table.States (862), 209, 62);
Add_Goto (Table.States (862), 210, 63);
Add_Goto (Table.States (862), 213, 64);
Add_Goto (Table.States (862), 214, 65);
Add_Goto (Table.States (862), 215, 66);
Add_Goto (Table.States (862), 216, 67);
Add_Goto (Table.States (862), 219, 69);
Add_Goto (Table.States (862), 223, 71);
Add_Goto (Table.States (862), 243, 74);
Add_Goto (Table.States (862), 244, 75);
Add_Goto (Table.States (862), 245, 76);
Add_Goto (Table.States (862), 246, 77);
Add_Goto (Table.States (862), 247, 78);
Add_Goto (Table.States (862), 248, 79);
Add_Goto (Table.States (862), 249, 80);
Add_Goto (Table.States (862), 250, 81);
Add_Goto (Table.States (862), 251, 82);
Add_Goto (Table.States (862), 257, 394);
Add_Goto (Table.States (862), 259, 84);
Add_Goto (Table.States (862), 260, 85);
Add_Goto (Table.States (862), 262, 87);
Add_Goto (Table.States (862), 263, 88);
Add_Goto (Table.States (862), 264, 89);
Add_Goto (Table.States (862), 265, 90);
Add_Goto (Table.States (862), 271, 91);
Add_Goto (Table.States (862), 281, 94);
Add_Goto (Table.States (862), 289, 95);
Add_Goto (Table.States (862), 304, 102);
Add_Goto (Table.States (862), 305, 103);
Add_Goto (Table.States (862), 307, 105);
Add_Goto (Table.States (862), 308, 106);
Add_Goto (Table.States (862), 309, 107);
Add_Goto (Table.States (862), 311, 108);
Add_Goto (Table.States (862), 313, 109);
Add_Goto (Table.States (862), 316, 111);
Add_Goto (Table.States (862), 317, 112);
Add_Goto (Table.States (862), 318, 1023);
Add_Goto (Table.States (862), 319, 113);
Add_Goto (Table.States (862), 325, 115);
Add_Goto (Table.States (862), 331, 116);
Table.States (862).Kernel := To_Vector (((319, 35, 5, False), (319, 35, 2, False)));
Table.States (862).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 318, 0)));
Add_Action (Table.States (863), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (319, 2), 6,
task_type_declaration_2'Access, null);
Table.States (863).Kernel := To_Vector ((0 => (319, 96, 0, False)));
Table.States (863).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 319, 6)));
Add_Action (Table.States (864), 10, 1006);
Add_Action (Table.States (864), 74, 1024);
Add_Error (Table.States (864));
Table.States (864).Kernel := To_Vector (((227, 227, 2, True), (305, 227, 3, False)));
Table.States (864).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 1024)));
Add_Action (Table.States (865), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (865), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (865), 28, 183);
Add_Action (Table.States (865), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (865), 30, 8);
Add_Action (Table.States (865), 40, 12);
Add_Action (Table.States (865), 46, 14);
Add_Action (Table.States (865), 47, 15);
Add_Action (Table.States (865), 48, 16);
Add_Action (Table.States (865), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (865), 51, 19);
Add_Action (Table.States (865), 63, 25);
Add_Action (Table.States (865), 66, 26);
Add_Action (Table.States (865), 69, 27);
Add_Action (Table.States (865), 71, 28);
Add_Action (Table.States (865), 104, 185);
Add_Error (Table.States (865));
Add_Goto (Table.States (865), 112, 35);
Add_Goto (Table.States (865), 121, 37);
Add_Goto (Table.States (865), 127, 40);
Add_Goto (Table.States (865), 134, 45);
Add_Goto (Table.States (865), 135, 46);
Add_Goto (Table.States (865), 157, 391);
Add_Goto (Table.States (865), 158, 392);
Add_Goto (Table.States (865), 159, 1025);
Add_Goto (Table.States (865), 179, 54);
Add_Goto (Table.States (865), 182, 55);
Add_Goto (Table.States (865), 186, 56);
Add_Goto (Table.States (865), 193, 58);
Add_Goto (Table.States (865), 206, 60);
Add_Goto (Table.States (865), 207, 61);
Add_Goto (Table.States (865), 209, 62);
Add_Goto (Table.States (865), 210, 63);
Add_Goto (Table.States (865), 213, 64);
Add_Goto (Table.States (865), 214, 65);
Add_Goto (Table.States (865), 215, 66);
Add_Goto (Table.States (865), 216, 67);
Add_Goto (Table.States (865), 219, 69);
Add_Goto (Table.States (865), 223, 71);
Add_Goto (Table.States (865), 243, 74);
Add_Goto (Table.States (865), 244, 75);
Add_Goto (Table.States (865), 245, 76);
Add_Goto (Table.States (865), 246, 77);
Add_Goto (Table.States (865), 247, 78);
Add_Goto (Table.States (865), 248, 79);
Add_Goto (Table.States (865), 249, 80);
Add_Goto (Table.States (865), 250, 81);
Add_Goto (Table.States (865), 251, 82);
Add_Goto (Table.States (865), 257, 394);
Add_Goto (Table.States (865), 259, 84);
Add_Goto (Table.States (865), 260, 85);
Add_Goto (Table.States (865), 262, 87);
Add_Goto (Table.States (865), 263, 88);
Add_Goto (Table.States (865), 264, 89);
Add_Goto (Table.States (865), 265, 90);
Add_Goto (Table.States (865), 271, 91);
Add_Goto (Table.States (865), 281, 94);
Add_Goto (Table.States (865), 289, 95);
Add_Goto (Table.States (865), 304, 102);
Add_Goto (Table.States (865), 305, 103);
Add_Goto (Table.States (865), 307, 105);
Add_Goto (Table.States (865), 308, 106);
Add_Goto (Table.States (865), 309, 107);
Add_Goto (Table.States (865), 311, 108);
Add_Goto (Table.States (865), 313, 109);
Add_Goto (Table.States (865), 316, 111);
Add_Goto (Table.States (865), 317, 112);
Add_Goto (Table.States (865), 319, 113);
Add_Goto (Table.States (865), 325, 115);
Add_Goto (Table.States (865), 331, 116);
Table.States (865).Kernel := To_Vector ((0 => (318, 49, 0, False)));
Table.States (865).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (866), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (866), 104, 149);
Add_Error (Table.States (866));
Add_Goto (Table.States (866), 220, 1026);
Table.States (866).Kernel := To_Vector ((0 => (305, 24, 1, False)));
Table.States (866).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (867), (77, 96), (171, 0), 3, null, null);
Table.States (867).Kernel := To_Vector ((0 => (171, 170, 0, True)));
Table.States (867).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 171, 3)));
Table.States (867).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (868), 41, 1027);
Add_Error (Table.States (868));
Table.States (868).Kernel := To_Vector (((241, 40, 1, False), (242, 40, 2, False), (242, 40, 4, False)));
Table.States (868).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 41, 1027)));
Add_Action (Table.States (869), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (869), 77, Reduce, (242, 0), 1, null_exclusion_opt_name_type_0'Access, null);
Add_Action (Table.States (869), 82, Reduce, (242, 0), 1, null_exclusion_opt_name_type_0'Access, null);
Add_Action (Table.States (869), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (869), 96, Reduce, (242, 0), 1, null_exclusion_opt_name_type_0'Access, null);
Add_Action (Table.States (869), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (869), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (869));
Table.States (869).Kernel := To_Vector (((239, 104, 0, False), (242, 104, 0, False)));
Table.States (869).Minimal_Complete_Actions := To_Vector (((Reduce, 239, 1), (Reduce, 242, 1)));
Add_Action (Table.States (870), 77, Reduce, (170, 3), 3, null, null);
Add_Action (Table.States (870), 82, 1028);
Add_Action (Table.States (870), 96, Reduce, (170, 3), 3, null, null);
Add_Error (Table.States (870));
Table.States (870).Kernel := To_Vector (((170, 114, 1, False), (170, 114, 0, False)));
Table.States (870).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 170, 3)));
Add_Action (Table.States (871), 76, 235);
Add_Action (Table.States (871), 84, 237);
Add_Action (Table.States (871), 101, 239);
Add_Action (Table.States (871), 102, 240);
Add_Error (Table.States (871));
Add_Goto (Table.States (871), 115, 241);
Add_Goto (Table.States (871), 322, 242);
Table.States (871).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True)));
Table.States (871).Minimal_Complete_Actions := To_Vector (((Shift, 101, 239), (Shift, 76, 235), (Shift, 84,
237)));
Table.States (871).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (872), 77, Reduce, (170, 2), 3, null, null);
Add_Action (Table.States (872), 82, 1029);
Add_Action (Table.States (872), 96, Reduce, (170, 2), 3, null, null);
Add_Error (Table.States (872));
Table.States (872).Kernel := To_Vector (((170, 242, 1, False), (170, 242, 0, False)));
Table.States (872).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 170, 3)));
Add_Action (Table.States (873), 76, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Action (Table.States (873), 77, Reduce, (242, 1), 1, null_exclusion_opt_name_type_1'Access, null);
Add_Action (Table.States (873), 82, Reduce, (242, 1), 1, null_exclusion_opt_name_type_1'Access, null);
Add_Action (Table.States (873), 84, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Action (Table.States (873), 96, Reduce, (242, 1), 1, null_exclusion_opt_name_type_1'Access, null);
Add_Action (Table.States (873), 101, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Action (Table.States (873), 102, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Error (Table.States (873));
Table.States (873).Kernel := To_Vector (((239, 293, 0, True), (242, 293, 0, False)));
Table.States (873).Minimal_Complete_Actions := To_Vector (((Reduce, 239, 1), (Reduce, 242, 1)));
Table.States (873).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (874), 39, Reduce, (109, 0), 2, null, null);
Add_Conflict (Table.States (874), 39, (110, 0), 2, null, null);
Add_Error (Table.States (874));
Table.States (874).Kernel := To_Vector (((109, 36, 0, False), (110, 36, 0, False)));
Table.States (874).Minimal_Complete_Actions := To_Vector (((Reduce, 109, 2), (Reduce, 110, 2)));
Add_Action (Table.States (875), (1 => 39), (109, 1), 2, null, null);
Table.States (875).Kernel := To_Vector ((0 => (109, 64, 0, False)));
Table.States (875).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 109, 2)));
Add_Action (Table.States (876), 36, 1030);
Add_Action (Table.States (876), 41, Reduce, (111, 1), 2, null, null);
Add_Action (Table.States (876), 49, Reduce, (111, 1), 2, null, null);
Add_Action (Table.States (876), 54, Reduce, (111, 1), 2, null, null);
Add_Error (Table.States (876));
Table.States (876).Kernel := To_Vector (((111, 65, 1, False), (111, 65, 0, False)));
Table.States (876).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 111, 2)));
Add_Action (Table.States (877), 3, 121);
Add_Action (Table.States (877), 39, 122);
Add_Action (Table.States (877), 40, 474);
Add_Action (Table.States (877), 41, 124);
Add_Action (Table.States (877), 76, 126);
Add_Action (Table.States (877), 94, 127);
Add_Action (Table.States (877), 95, 128);
Add_Action (Table.States (877), 103, 129);
Add_Action (Table.States (877), 104, 119);
Add_Action (Table.States (877), 105, 33);
Add_Action (Table.States (877), 106, 34);
Add_Error (Table.States (877));
Add_Goto (Table.States (877), 117, 130);
Add_Goto (Table.States (877), 128, 41);
Add_Goto (Table.States (877), 167, 775);
Add_Goto (Table.States (877), 168, 1031);
Add_Goto (Table.States (877), 197, 133);
Add_Goto (Table.States (877), 225, 1032);
Add_Goto (Table.States (877), 226, 1033);
Add_Goto (Table.States (877), 239, 1034);
Add_Goto (Table.States (877), 258, 135);
Add_Goto (Table.States (877), 272, 92);
Add_Goto (Table.States (877), 277, 478);
Add_Goto (Table.States (877), 293, 97);
Add_Goto (Table.States (877), 301, 479);
Add_Goto (Table.States (877), 314, 480);
Add_Goto (Table.States (877), 320, 144);
Add_Goto (Table.States (877), 321, 145);
Add_Goto (Table.States (877), 330, 146);
Table.States (877).Kernel := To_Vector (((120, 76, 6, False), (120, 76, 6, False)));
Table.States (877).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (878), 20, 1035);
Add_Action (Table.States (878), 53, 1036);
Add_Action (Table.States (878), 74, Reduce, (279, 1), 0, null, null);
Add_Action (Table.States (878), 96, Reduce, (279, 1), 0, null, null);
Add_Error (Table.States (878));
Add_Goto (Table.States (878), 279, 1037);
Table.States (878).Kernel := To_Vector (((326, 192, 1, False), (326, 192, 0, False)));
Table.States (878).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 279, 0)));
Add_Action (Table.States (879), 53, 1036);
Add_Action (Table.States (879), 74, Reduce, (279, 1), 0, null, null);
Add_Action (Table.States (879), 96, Reduce, (279, 1), 0, null, null);
Add_Error (Table.States (879));
Add_Goto (Table.States (879), 279, 1038);
Table.States (879).Kernel := To_Vector ((0 => (326, 192, 0, False)));
Table.States (879).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 279, 0)));
Add_Action (Table.States (880), 10, 1039);
Add_Action (Table.States (880), 74, Reduce, (228, 4), 2, null, null);
Add_Action (Table.States (880), 96, Reduce, (228, 4), 2, null, null);
Add_Error (Table.States (880));
Table.States (880).Kernel := To_Vector (((228, 34, 2, False), (228, 34, 0, False)));
Table.States (880).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 2)));
Add_Action (Table.States (881), (74, 96), (326, 2), 2, null, null);
Table.States (881).Kernel := To_Vector ((0 => (326, 192, 0, False)));
Table.States (881).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 2)));
Add_Action (Table.States (882), (74, 96), (280, 1), 2, null, null);
Table.States (882).Kernel := To_Vector ((0 => (280, 54, 0, False)));
Table.States (882).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 280, 2)));
Add_Action (Table.States (883), 10, 1040);
Add_Action (Table.States (883), 74, Reduce, (228, 6), 2, null, null);
Add_Action (Table.States (883), 96, Reduce, (228, 6), 2, null, null);
Add_Error (Table.States (883));
Table.States (883).Kernel := To_Vector (((228, 34, 2, False), (228, 34, 0, False)));
Table.States (883).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 2)));
Add_Action (Table.States (884), 85, 1041);
Add_Error (Table.States (884));
Table.States (884).Kernel := To_Vector ((0 => (326, 301, 2, False)));
Table.States (884).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 85, 1041)));
Add_Action (Table.States (885), 35, Reduce, (164, 1), 0, null, null);
Add_Action (Table.States (885), 104, 1042);
Add_Action (Table.States (885), 105, 1043);
Add_Error (Table.States (885));
Add_Goto (Table.States (885), 163, 1044);
Add_Goto (Table.States (885), 164, 1045);
Table.States (885).Kernel := To_Vector ((0 => (327, 15, 6, False)));
Table.States (885).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 164, 0)));
Add_Action (Table.States (886), 96, 1046);
Add_Error (Table.States (886));
Table.States (886).Kernel := To_Vector ((0 => (149, 41, 1, False)));
Table.States (886).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1046)));
Add_Action (Table.States (887), (15, 24, 28, 72, 104), (148, 1), 1, null, null);
Table.States (887).Kernel := To_Vector ((0 => (148, 121, 0, False)));
Table.States (887).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 148, 1)));
Add_Action (Table.States (888), (15, 24, 28, 72, 104), (148, 0), 1, null, null);
Table.States (888).Kernel := To_Vector ((0 => (148, 146, 0, False)));
Table.States (888).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 148, 1)));
end Subr_15;
procedure Subr_16
is begin
Add_Action (Table.States (889), (15, 24, 28, 72, 104), (149, 2), 1, null, null);
Table.States (889).Kernel := To_Vector ((0 => (149, 148, 0, False)));
Table.States (889).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 149, 1)));
Add_Action (Table.States (890), 15, 885);
Add_Action (Table.States (890), 24, Reduce, (150, 0), 1, null, null);
Add_Action (Table.States (890), 28, 183);
Add_Action (Table.States (890), 72, Reduce, (150, 0), 1, null, null);
Add_Action (Table.States (890), 104, 164);
Add_Error (Table.States (890));
Add_Goto (Table.States (890), 121, 887);
Add_Goto (Table.States (890), 127, 40);
Add_Goto (Table.States (890), 146, 888);
Add_Goto (Table.States (890), 148, 1047);
Add_Goto (Table.States (890), 182, 55);
Add_Goto (Table.States (890), 219, 892);
Add_Goto (Table.States (890), 281, 94);
Add_Goto (Table.States (890), 327, 1048);
Table.States (890).Kernel := To_Vector (((149, 149, 4, True), (149, 149, 7, True), (150, 149, 0, False)));
Table.States (890).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 150, 1)));
Add_Action (Table.States (891), 24, 1049);
Add_Error (Table.States (891));
Table.States (891).Kernel := To_Vector ((0 => (280, 150, 2, False)));
Table.States (891).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1049)));
Add_Action (Table.States (892), 81, 1050);
Add_Action (Table.States (892), 83, 234);
Add_Error (Table.States (892));
Table.States (892).Kernel := To_Vector (((146, 219, 4, False), (146, 219, 3, False), (219, 219, 2, True)));
Table.States (892).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 81, 1050)));
Add_Action (Table.States (893), (15, 24, 28, 72, 104), (149, 3), 1, null, null);
Table.States (893).Kernel := To_Vector ((0 => (149, 327, 0, False)));
Table.States (893).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 149, 1)));
Add_Action (Table.States (894), 10, 1051);
Add_Action (Table.States (894), 74, Reduce, (228, 7), 2, null, null);
Add_Action (Table.States (894), 96, Reduce, (228, 7), 2, null, null);
Add_Error (Table.States (894));
Table.States (894).Kernel := To_Vector (((228, 34, 2, False), (228, 34, 0, False)));
Table.States (894).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 2)));
Add_Action (Table.States (895), (41, 49, 54), (111, 2), 2, null, null);
Table.States (895).Kernel := To_Vector ((0 => (111, 36, 0, False)));
Table.States (895).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 111, 2)));
Add_Action (Table.States (896), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (223, 0), 6,
incomplete_type_declaration_0'Access, null);
Table.States (896).Kernel := To_Vector ((0 => (223, 96, 0, False)));
Table.States (896).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 223, 6)));
Add_Action (Table.States (897), 10, 1052);
Add_Action (Table.States (897), 74, Reduce, (228, 5), 2, null, null);
Add_Action (Table.States (897), 96, Reduce, (228, 5), 2, null, null);
Add_Error (Table.States (897));
Table.States (897).Kernel := To_Vector (((228, 34, 2, False), (228, 34, 0, False)));
Table.States (897).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 2)));
Add_Action (Table.States (898), (77, 83), (180, 0), 1, null, null);
Table.States (898).Kernel := To_Vector ((0 => (180, 104, 0, False)));
Table.States (898).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 180, 1)));
Add_Action (Table.States (899), (77, 83), (180, 1), 1, null, null);
Table.States (899).Kernel := To_Vector ((0 => (180, 106, 0, False)));
Table.States (899).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 180, 1)));
Add_Action (Table.States (900), (77, 83), (181, 1), 1, null, null);
Table.States (900).Kernel := To_Vector ((0 => (181, 180, 0, False)));
Table.States (900).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 181, 1)));
Add_Action (Table.States (901), 77, 1053);
Add_Action (Table.States (901), 83, 1054);
Add_Error (Table.States (901));
Table.States (901).Kernel := To_Vector (((181, 181, 2, True), (183, 181, 1, False)));
Table.States (901).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 1053)));
Add_Action (Table.States (902), 40, 483);
Add_Action (Table.States (902), 104, 119);
Add_Action (Table.States (902), 105, 33);
Add_Action (Table.States (902), 106, 34);
Add_Error (Table.States (902));
Add_Goto (Table.States (902), 128, 41);
Add_Goto (Table.States (902), 239, 484);
Add_Goto (Table.States (902), 272, 92);
Add_Goto (Table.States (902), 293, 97);
Add_Goto (Table.States (902), 314, 1055);
Table.States (902).Kernel := To_Vector ((0 => (259, 39, 4, False)));
Table.States (902).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (903), 104, 119);
Add_Action (Table.States (903), 105, 33);
Add_Action (Table.States (903), 106, 34);
Add_Error (Table.States (903));
Add_Goto (Table.States (903), 128, 41);
Add_Goto (Table.States (903), 239, 1056);
Add_Goto (Table.States (903), 272, 92);
Add_Goto (Table.States (903), 293, 97);
Table.States (903).Kernel := To_Vector (((162, 39, 4, False), (162, 39, 1, False)));
Table.States (903).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (904), 74, 337);
Add_Action (Table.States (904), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (904));
Add_Goto (Table.States (904), 122, 1057);
Table.States (904).Kernel := To_Vector ((0 => (260, 49, 1, False)));
Table.States (904).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (905), (74, 96), (326, 7), 2, null, null);
Table.States (905).Kernel := To_Vector ((0 => (326, 280, 0, False)));
Table.States (905).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 2)));
Add_Action (Table.States (906), 96, 1058);
Add_Error (Table.States (906));
Table.States (906).Kernel := To_Vector ((0 => (206, 122, 1, False)));
Table.States (906).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1058)));
Add_Action (Table.States (907), 96, 1059);
Add_Error (Table.States (907));
Table.States (907).Kernel := To_Vector ((0 => (245, 122, 1, False)));
Table.States (907).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1059)));
Add_Action (Table.States (908), 96, 1060);
Add_Error (Table.States (908));
Table.States (908).Kernel := To_Vector ((0 => (245, 122, 1, False)));
Table.States (908).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1060)));
Add_Action (Table.States (909), 21, Reduce, (114, 2), 4, access_definition_2'Access, null);
Add_Action (Table.States (909), 35, Reduce, (114, 2), 4, access_definition_2'Access, null);
Add_Action (Table.States (909), 56, Reduce, (114, 2), 4, access_definition_2'Access, null);
Add_Action (Table.States (909), 74, Reduce, (114, 2), 4, access_definition_2'Access, null);
Add_Action (Table.States (909), 76, 235);
Add_Action (Table.States (909), 77, Reduce, (114, 2), 4, access_definition_2'Access, null);
Add_Action (Table.States (909), 82, Reduce, (114, 2), 4, access_definition_2'Access, null);
Add_Action (Table.States (909), 84, 237);
Add_Action (Table.States (909), 96, Reduce, (114, 2), 4, access_definition_2'Access, null);
Add_Action (Table.States (909), 101, 239);
Add_Action (Table.States (909), 102, 240);
Add_Error (Table.States (909));
Add_Goto (Table.States (909), 115, 241);
Add_Goto (Table.States (909), 322, 242);
Table.States (909).Kernel := To_Vector (((114, 239, 0, False), (128, 239, 2, True), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (909).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 114, 4)));
Add_Action (Table.States (910), 58, 317);
Add_Action (Table.States (910), 76, 431);
Add_Error (Table.States (910));
Add_Goto (Table.States (910), 199, 319);
Add_Goto (Table.States (910), 252, 1061);
Add_Goto (Table.States (910), 291, 321);
Table.States (910).Kernel := To_Vector ((0 => (114, 29, 1, True)));
Table.States (910).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 58, 317)));
Table.States (910).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (911), 21, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (911), 35, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (911), 56, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (911), 74, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (911), 76, 431);
Add_Action (Table.States (911), 77, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (911), 82, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (911), 96, Reduce, (253, 1), 0, null, null);
Add_Error (Table.States (911));
Add_Goto (Table.States (911), 199, 344);
Add_Goto (Table.States (911), 253, 1062);
Table.States (911).Kernel := To_Vector ((0 => (114, 50, 0, False)));
Table.States (911).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 0)));
Add_Action (Table.States (912), 74, 337);
Add_Action (Table.States (912), 76, 235);
Add_Action (Table.States (912), 84, 237);
Add_Action (Table.States (912), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (912), 101, 239);
Add_Action (Table.States (912), 102, 240);
Add_Error (Table.States (912));
Add_Goto (Table.States (912), 115, 241);
Add_Goto (Table.States (912), 122, 1063);
Add_Goto (Table.States (912), 322, 242);
Table.States (912).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(245, 239, 1, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (912).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (913), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (133, 1), 6, block_statement_1'Access, block_statement_1_check'Access);
Table.States (913).Kernel := To_Vector ((0 => (133, 96, 0, False)));
Table.States (913).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 133, 6)));
Add_Action (Table.States (914), (79, 87), (184, 1), 1, null, null);
Table.States (914).Kernel := To_Vector ((0 => (184, 44, 0, False)));
Table.States (914).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 184, 1)));
Add_Action (Table.States (915), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (915), 79, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (915), 81, 1064);
Add_Action (Table.States (915), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (915), 87, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (915), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (915), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (915));
Table.States (915).Kernel := To_Vector (((187, 104, 3, False), (239, 104, 0, False)));
Table.States (915).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 239, 1)));
Add_Action (Table.States (916), (79, 87), (185, 1), 1, null, null);
Table.States (916).Kernel := To_Vector ((0 => (185, 184, 0, False)));
Table.States (916).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 185, 1)));
Add_Action (Table.States (917), 79, 1065);
Add_Action (Table.States (917), 87, 1066);
Add_Error (Table.States (917));
Table.States (917).Kernel := To_Vector (((185, 185, 2, True), (187, 185, 1, False)));
Table.States (917).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 1066)));
Add_Action (Table.States (918), 76, 235);
Add_Action (Table.States (918), 79, Reduce, (184, 0), 1, null, null);
Add_Action (Table.States (918), 84, 237);
Add_Action (Table.States (918), 87, Reduce, (184, 0), 1, null, null);
Add_Action (Table.States (918), 101, 239);
Add_Action (Table.States (918), 102, 240);
Add_Error (Table.States (918));
Add_Goto (Table.States (918), 115, 241);
Add_Goto (Table.States (918), 322, 242);
Table.States (918).Kernel := To_Vector (((128, 239, 2, True), (184, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (918).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 184, 1)));
Add_Action (Table.States (919), (24, 72), (188, 0), 2, null, null);
Table.States (919).Kernel := To_Vector ((0 => (188, 187, 0, True)));
Table.States (919).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 188, 2)));
Table.States (919).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (920), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (920), 104, 149);
Add_Error (Table.States (920));
Add_Goto (Table.States (920), 220, 1067);
Table.States (920).Kernel := To_Vector ((0 => (133, 24, 1, False)));
Table.States (920).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (921), 96, 1068);
Add_Error (Table.States (921));
Table.States (921).Kernel := To_Vector ((0 => (232, 220, 1, False)));
Table.States (921).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1068)));
Add_Action (Table.States (922), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (922), 104, 149);
Add_Error (Table.States (922));
Add_Goto (Table.States (922), 220, 1069);
Table.States (922).Kernel := To_Vector ((0 => (232, 37, 1, False)));
Table.States (922).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (923), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (157, 9), 6,
declaration_9'Access, null);
Table.States (923).Kernel := To_Vector ((0 => (157, 96, 0, False)));
Table.States (923).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 157, 6)));
Add_Action (Table.States (924), 7, Reduce, (241, 0), 2, null, null);
Add_Action (Table.States (924), 104, 119);
Add_Action (Table.States (924), 105, 33);
Add_Action (Table.States (924), 106, 34);
Add_Error (Table.States (924));
Add_Goto (Table.States (924), 128, 41);
Add_Goto (Table.States (924), 239, 772);
Add_Goto (Table.States (924), 272, 92);
Add_Goto (Table.States (924), 293, 97);
Table.States (924).Kernel := To_Vector (((241, 41, 0, False), (314, 41, 5, False), (314, 41, 1, False)));
Table.States (924).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 241, 2)));
Add_Action (Table.States (925), 3, 121);
Add_Action (Table.States (925), 39, 122);
Add_Action (Table.States (925), 40, 123);
Add_Action (Table.States (925), 41, 124);
Add_Action (Table.States (925), 52, 125);
Add_Action (Table.States (925), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (925), 76, 126);
Add_Action (Table.States (925), 94, 127);
Add_Action (Table.States (925), 95, 128);
Add_Action (Table.States (925), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (925), 103, 129);
Add_Action (Table.States (925), 104, 119);
Add_Action (Table.States (925), 105, 33);
Add_Action (Table.States (925), 106, 34);
Add_Error (Table.States (925));
Add_Goto (Table.States (925), 117, 130);
Add_Goto (Table.States (925), 128, 41);
Add_Goto (Table.States (925), 191, 131);
Add_Goto (Table.States (925), 192, 1070);
Add_Goto (Table.States (925), 197, 133);
Add_Goto (Table.States (925), 239, 134);
Add_Goto (Table.States (925), 258, 135);
Add_Goto (Table.States (925), 272, 92);
Add_Goto (Table.States (925), 275, 136);
Add_Goto (Table.States (925), 282, 137);
Add_Goto (Table.States (925), 283, 138);
Add_Goto (Table.States (925), 284, 139);
Add_Goto (Table.States (925), 285, 140);
Add_Goto (Table.States (925), 286, 141);
Add_Goto (Table.States (925), 287, 142);
Add_Goto (Table.States (925), 293, 97);
Add_Goto (Table.States (925), 301, 143);
Add_Goto (Table.States (925), 320, 144);
Add_Goto (Table.States (925), 321, 145);
Add_Goto (Table.States (925), 330, 146);
Table.States (925).Kernel := To_Vector ((0 => (244, 82, 1, False)));
Table.States (925).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (926), 96, 1071);
Add_Error (Table.States (926));
Table.States (926).Kernel := To_Vector ((0 => (244, 122, 1, False)));
Table.States (926).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1071)));
Add_Action (Table.States (927), 3, 121);
Add_Action (Table.States (927), 39, 122);
Add_Action (Table.States (927), 40, 123);
Add_Action (Table.States (927), 41, 124);
Add_Action (Table.States (927), 52, 125);
Add_Action (Table.States (927), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (927), 76, 126);
Add_Action (Table.States (927), 94, 127);
Add_Action (Table.States (927), 95, 128);
Add_Action (Table.States (927), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (927), 103, 129);
Add_Action (Table.States (927), 104, 119);
Add_Action (Table.States (927), 105, 33);
Add_Action (Table.States (927), 106, 34);
Add_Error (Table.States (927));
Add_Goto (Table.States (927), 117, 130);
Add_Goto (Table.States (927), 128, 41);
Add_Goto (Table.States (927), 191, 131);
Add_Goto (Table.States (927), 192, 1072);
Add_Goto (Table.States (927), 197, 133);
Add_Goto (Table.States (927), 239, 134);
Add_Goto (Table.States (927), 258, 135);
Add_Goto (Table.States (927), 272, 92);
Add_Goto (Table.States (927), 275, 136);
Add_Goto (Table.States (927), 282, 137);
Add_Goto (Table.States (927), 283, 138);
Add_Goto (Table.States (927), 284, 139);
Add_Goto (Table.States (927), 285, 140);
Add_Goto (Table.States (927), 286, 141);
Add_Goto (Table.States (927), 287, 142);
Add_Goto (Table.States (927), 293, 97);
Add_Goto (Table.States (927), 301, 143);
Add_Goto (Table.States (927), 320, 144);
Add_Goto (Table.States (927), 321, 145);
Add_Goto (Table.States (927), 330, 146);
Table.States (927).Kernel := To_Vector ((0 => (244, 82, 1, False)));
Table.States (927).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (928), 96, 1073);
Add_Error (Table.States (928));
Table.States (928).Kernel := To_Vector ((0 => (244, 122, 1, False)));
Table.States (928).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1073)));
Add_Action (Table.States (929), 3, 121);
Add_Action (Table.States (929), 39, 122);
Add_Action (Table.States (929), 40, 123);
Add_Action (Table.States (929), 41, 124);
Add_Action (Table.States (929), 52, 125);
Add_Action (Table.States (929), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (929), 76, 126);
Add_Action (Table.States (929), 94, 127);
Add_Action (Table.States (929), 95, 128);
Add_Action (Table.States (929), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (929), 103, 129);
Add_Action (Table.States (929), 104, 119);
Add_Action (Table.States (929), 105, 33);
Add_Action (Table.States (929), 106, 34);
Add_Error (Table.States (929));
Add_Goto (Table.States (929), 117, 130);
Add_Goto (Table.States (929), 128, 41);
Add_Goto (Table.States (929), 191, 131);
Add_Goto (Table.States (929), 192, 1074);
Add_Goto (Table.States (929), 197, 133);
Add_Goto (Table.States (929), 239, 134);
Add_Goto (Table.States (929), 258, 135);
Add_Goto (Table.States (929), 272, 92);
Add_Goto (Table.States (929), 275, 136);
Add_Goto (Table.States (929), 282, 137);
Add_Goto (Table.States (929), 283, 138);
Add_Goto (Table.States (929), 284, 139);
Add_Goto (Table.States (929), 285, 140);
Add_Goto (Table.States (929), 286, 141);
Add_Goto (Table.States (929), 287, 142);
Add_Goto (Table.States (929), 293, 97);
Add_Goto (Table.States (929), 301, 143);
Add_Goto (Table.States (929), 320, 144);
Add_Goto (Table.States (929), 321, 145);
Add_Goto (Table.States (929), 330, 146);
Table.States (929).Kernel := To_Vector ((0 => (244, 82, 1, False)));
Table.States (929).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (930), 96, 1075);
Add_Error (Table.States (930));
Table.States (930).Kernel := To_Vector ((0 => (244, 122, 1, False)));
Table.States (930).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1075)));
Add_Action (Table.States (931), 74, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (931), 76, 431);
Add_Action (Table.States (931), 96, Reduce, (253, 1), 0, null, null);
Add_Error (Table.States (931));
Add_Goto (Table.States (931), 199, 344);
Add_Goto (Table.States (931), 253, 1076);
Table.States (931).Kernel := To_Vector ((0 => (179, 77, 1, False)));
Table.States (931).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 0)));
Add_Action (Table.States (932), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (179, 1), 6,
entry_declaration_1'Access, null);
Table.States (932).Kernel := To_Vector ((0 => (179, 96, 0, False)));
Table.States (932).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 179, 6)));
Add_Action (Table.States (933), 74, 337);
Add_Action (Table.States (933), 76, 235);
Add_Action (Table.States (933), 84, 237);
Add_Action (Table.States (933), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (933), 101, 239);
Add_Action (Table.States (933), 102, 240);
Add_Error (Table.States (933));
Add_Goto (Table.States (933), 115, 241);
Add_Goto (Table.States (933), 122, 1077);
Add_Goto (Table.States (933), 322, 242);
Table.States (933).Kernel := To_Vector (((128, 239, 2, True), (213, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (933).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (934), 74, 337);
Add_Action (Table.States (934), 76, 235);
Add_Action (Table.States (934), 84, 237);
Add_Action (Table.States (934), 96, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (934), 101, 239);
Add_Action (Table.States (934), 102, 240);
Add_Error (Table.States (934));
Add_Goto (Table.States (934), 115, 241);
Add_Goto (Table.States (934), 122, 1078);
Add_Goto (Table.States (934), 322, 242);
Table.States (934).Kernel := To_Vector (((128, 239, 2, True), (213, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (934).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (935), (74, 96), (256, 1), 3, paren_expression_1'Access, null);
Table.States (935).Kernel := To_Vector ((0 => (256, 77, 0, False)));
Table.States (935).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 256, 3)));
Add_Action (Table.States (936), (74, 96), (256, 2), 3, paren_expression_2'Access, null);
Table.States (936).Kernel := To_Vector ((0 => (256, 77, 0, False)));
Table.States (936).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 256, 3)));
Add_Action (Table.States (937), (74, 96), (256, 0), 3, paren_expression_0'Access, null);
Table.States (937).Kernel := To_Vector ((0 => (256, 77, 0, False)));
Table.States (937).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 256, 3)));
Add_Action (Table.States (938), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (193, 0), 6,
expression_function_declaration_0'Access, null);
Table.States (938).Kernel := To_Vector ((0 => (193, 96, 0, False)));
Table.States (938).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 193, 6)));
Add_Action (Table.States (939), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (243, 0), 6,
null_procedure_declaration_0'Access, null);
Table.States (939).Kernel := To_Vector ((0 => (243, 96, 0, False)));
Table.States (939).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 243, 6)));
Add_Action (Table.States (940), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (112, 0), 6,
abstract_subprogram_declaration_0'Access, null);
Table.States (940).Kernel := To_Vector ((0 => (112, 96, 0, False)));
Table.States (940).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 112, 6)));
Add_Action (Table.States (941), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (308, 0), 6,
subprogram_body_stub_0'Access, null);
Table.States (941).Kernel := To_Vector ((0 => (308, 96, 0, False)));
Table.States (941).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 308, 6)));
Add_Action (Table.States (942), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (311, 0), 6,
subprogram_renaming_declaration_0'Access, null);
Table.States (942).Kernel := To_Vector ((0 => (311, 96, 0, False)));
Table.States (942).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 311, 6)));
Add_Action (Table.States (943), 4, 1);
Add_Action (Table.States (943), 5, 2);
Add_Action (Table.States (943), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (943), 15, 3);
Add_Action (Table.States (943), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (943), 18, 4);
Add_Action (Table.States (943), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (943), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (943), 27, 5);
Add_Action (Table.States (943), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (943), 31, 9);
Add_Action (Table.States (943), 32, 10);
Add_Action (Table.States (943), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (943), 41, 13);
Add_Action (Table.States (943), 48, 16);
Add_Action (Table.States (943), 52, 20);
Add_Action (Table.States (943), 57, 21);
Add_Action (Table.States (943), 58, 22);
Add_Action (Table.States (943), 61, 24);
Add_Action (Table.States (943), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (943), 93, 31);
Add_Action (Table.States (943), 104, 360);
Add_Action (Table.States (943), 105, 33);
Add_Action (Table.States (943), 106, 34);
Add_Error (Table.States (943));
Add_Goto (Table.States (943), 113, 36);
Add_Goto (Table.States (943), 123, 38);
Add_Goto (Table.States (943), 126, 39);
Add_Goto (Table.States (943), 128, 41);
Add_Goto (Table.States (943), 131, 42);
Add_Goto (Table.States (943), 132, 43);
Add_Goto (Table.States (943), 133, 44);
Add_Goto (Table.States (943), 139, 47);
Add_Goto (Table.States (943), 151, 50);
Add_Goto (Table.States (943), 152, 51);
Add_Goto (Table.States (943), 161, 53);
Add_Goto (Table.States (943), 190, 57);
Add_Goto (Table.States (943), 196, 59);
Add_Goto (Table.States (943), 217, 68);
Add_Goto (Table.States (943), 218, 1079);
Add_Goto (Table.States (943), 222, 70);
Add_Goto (Table.States (943), 232, 72);
Add_Goto (Table.States (943), 239, 73);
Add_Goto (Table.States (943), 257, 83);
Add_Goto (Table.States (943), 261, 86);
Add_Goto (Table.States (943), 272, 92);
Add_Goto (Table.States (943), 276, 93);
Add_Goto (Table.States (943), 290, 96);
Add_Goto (Table.States (943), 293, 97);
Add_Goto (Table.States (943), 294, 98);
Add_Goto (Table.States (943), 298, 99);
Add_Goto (Table.States (943), 299, 361);
Add_Goto (Table.States (943), 300, 390);
Add_Goto (Table.States (943), 302, 100);
Add_Goto (Table.States (943), 303, 101);
Add_Goto (Table.States (943), 306, 363);
Add_Goto (Table.States (943), 323, 114);
Table.States (943).Kernel := To_Vector ((0 => (307, 13, 2, False)));
Table.States (943).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (944), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (944), 104, 149);
Add_Error (Table.States (944));
Add_Goto (Table.States (944), 220, 1080);
Table.States (944).Kernel := To_Vector ((0 => (113, 24, 1, False)));
Table.States (944).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (945), 79, 445);
Add_Action (Table.States (945), 87, 1081);
Add_Error (Table.States (945));
Table.States (945).Kernel := To_Vector (((137, 166, 1, False), (166, 166, 2, True)));
Table.States (945).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 1081)));
Add_Action (Table.States (946), 72, 761);
Add_Error (Table.States (946));
Add_Goto (Table.States (946), 137, 1082);
Table.States (946).Kernel := To_Vector ((0 => (138, 83, 2, True)));
Table.States (946).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 72, 761)));
Table.States (946).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (947), (1 => 77), (273, 0), 5, quantified_expression_0'Access, null);
Table.States (947).Kernel := To_Vector ((0 => (273, 192, 0, False)));
Table.States (947).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 273, 5)));
Add_Action (Table.States (948), 3, 121);
Add_Action (Table.States (948), 39, 122);
Add_Action (Table.States (948), 40, 123);
Add_Action (Table.States (948), 41, 124);
Add_Action (Table.States (948), 52, 125);
Add_Action (Table.States (948), 76, 126);
Add_Action (Table.States (948), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (948), 94, 127);
Add_Action (Table.States (948), 95, 128);
Add_Action (Table.States (948), 103, 129);
Add_Action (Table.States (948), 104, 119);
Add_Action (Table.States (948), 105, 33);
Add_Action (Table.States (948), 106, 34);
Add_Error (Table.States (948));
Add_Goto (Table.States (948), 117, 130);
Add_Goto (Table.States (948), 128, 41);
Add_Goto (Table.States (948), 191, 131);
Add_Goto (Table.States (948), 192, 1083);
Add_Goto (Table.States (948), 197, 133);
Add_Goto (Table.States (948), 239, 134);
Add_Goto (Table.States (948), 258, 135);
Add_Goto (Table.States (948), 272, 92);
Add_Goto (Table.States (948), 275, 136);
Add_Goto (Table.States (948), 282, 137);
Add_Goto (Table.States (948), 283, 138);
Add_Goto (Table.States (948), 284, 139);
Add_Goto (Table.States (948), 285, 140);
Add_Goto (Table.States (948), 286, 141);
Add_Goto (Table.States (948), 287, 142);
Add_Goto (Table.States (948), 293, 97);
Add_Goto (Table.States (948), 301, 143);
Add_Goto (Table.States (948), 320, 144);
Add_Goto (Table.States (948), 321, 145);
Add_Goto (Table.States (948), 330, 146);
Table.States (948).Kernel := To_Vector ((0 => (221, 22, 0, False)));
Table.States (948).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (949), 3, 121);
Add_Action (Table.States (949), 39, 122);
Add_Action (Table.States (949), 40, 123);
Add_Action (Table.States (949), 41, 124);
Add_Action (Table.States (949), 52, 125);
Add_Action (Table.States (949), 68, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (949), 76, 126);
Add_Action (Table.States (949), 94, 127);
Add_Action (Table.States (949), 95, 128);
Add_Action (Table.States (949), 103, 129);
Add_Action (Table.States (949), 104, 119);
Add_Action (Table.States (949), 105, 33);
Add_Action (Table.States (949), 106, 34);
Add_Error (Table.States (949));
Add_Goto (Table.States (949), 117, 130);
Add_Goto (Table.States (949), 128, 41);
Add_Goto (Table.States (949), 191, 131);
Add_Goto (Table.States (949), 192, 1084);
Add_Goto (Table.States (949), 197, 133);
Add_Goto (Table.States (949), 239, 134);
Add_Goto (Table.States (949), 258, 135);
Add_Goto (Table.States (949), 272, 92);
Add_Goto (Table.States (949), 275, 136);
Add_Goto (Table.States (949), 282, 137);
Add_Goto (Table.States (949), 283, 138);
Add_Goto (Table.States (949), 284, 139);
Add_Goto (Table.States (949), 285, 140);
Add_Goto (Table.States (949), 286, 141);
Add_Goto (Table.States (949), 287, 142);
Add_Goto (Table.States (949), 293, 97);
Add_Goto (Table.States (949), 301, 143);
Add_Goto (Table.States (949), 320, 144);
Add_Goto (Table.States (949), 321, 145);
Add_Goto (Table.States (949), 330, 146);
Table.States (949).Kernel := To_Vector ((0 => (172, 23, 1, False)));
Table.States (949).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (950), (22, 23, 77), (173, 1), 1, null, null);
Table.States (950).Kernel := To_Vector ((0 => (173, 172, 0, False)));
Table.States (950).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 173, 1)));
Add_Action (Table.States (951), 22, 1085);
Add_Action (Table.States (951), 23, 949);
Add_Action (Table.States (951), 77, Reduce, (221, 2), 5, if_expression_2'Access, null);
Add_Error (Table.States (951));
Add_Goto (Table.States (951), 172, 1086);
Table.States (951).Kernel := To_Vector (((173, 173, 2, True), (221, 173, 1, False), (221, 173, 0, False)));
Table.States (951).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 221, 5)));
Add_Action (Table.States (952), (4, 5, 10, 13, 15, 17, 18, 20, 21, 22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 106), (117, 0), 6, aggregate_0'Access,
null);
Table.States (952).Kernel := To_Vector ((0 => (117, 77, 0, False)));
Table.States (952).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 117, 6)));
Add_Action (Table.States (953), 77, 1087);
Add_Error (Table.States (953));
Table.States (953).Kernel := To_Vector ((0 => (277, 192, 1, False)));
Table.States (953).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 1087)));
Add_Action (Table.States (954), (24, 72), (140, 0), 4, case_statement_alternative_0'Access, null);
Table.States (954).Kernel := To_Vector ((0 => (140, 300, 0, False)));
Table.States (954).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 140, 4)));
Add_Action (Table.States (955), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (139, 0), 7, case_statement_0'Access, null);
Table.States (955).Kernel := To_Vector ((0 => (139, 96, 0, False)));
Table.States (955).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 139, 7)));
Add_Action (Table.States (956), (10, 21, 37, 42, 74, 77, 82, 83, 87, 96), (314, 0), 4,
subtype_indication_0'Access, null);
Table.States (956).Kernel := To_Vector ((0 => (314, 155, 0, False)));
Table.States (956).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 314, 4)));
Add_Action (Table.States (957), 10, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 33, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 38, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 40, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 43, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 55, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 75, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 77, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 78, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 79, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 83, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 85, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 86, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 87, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 88, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 89, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 91, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 92, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 94, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 95, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 97, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 98, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 99, Reduce, (258, 1), 1, null, null);
Add_Action (Table.States (957), 104, 119);
Add_Action (Table.States (957), 105, 33);
Add_Action (Table.States (957), 106, 34);
Add_Error (Table.States (957));
Add_Goto (Table.States (957), 128, 41);
Add_Goto (Table.States (957), 239, 1088);
Add_Goto (Table.States (957), 272, 92);
Add_Goto (Table.States (957), 293, 97);
Table.States (957).Kernel := To_Vector (((165, 41, 1, False), (258, 41, 0, False), (314, 41, 5, False),
(314, 41, 1, False)));
Table.States (957).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 258, 1)));
Add_Action (Table.States (958), (10, 21, 37, 42, 74, 77, 82, 83, 87, 96), (224, 0), 3,
index_constraint_0'Access, null);
Table.States (958).Kernel := To_Vector ((0 => (224, 77, 0, False)));
Table.States (958).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 224, 3)));
Add_Action (Table.States (959), 3, 121);
Add_Action (Table.States (959), 39, 122);
Add_Action (Table.States (959), 40, 474);
Add_Action (Table.States (959), 41, 124);
Add_Action (Table.States (959), 76, 126);
Add_Action (Table.States (959), 94, 127);
Add_Action (Table.States (959), 95, 128);
Add_Action (Table.States (959), 103, 129);
Add_Action (Table.States (959), 104, 119);
Add_Action (Table.States (959), 105, 33);
Add_Action (Table.States (959), 106, 34);
Add_Error (Table.States (959));
Add_Goto (Table.States (959), 117, 130);
Add_Goto (Table.States (959), 128, 41);
Add_Goto (Table.States (959), 167, 1089);
Add_Goto (Table.States (959), 197, 133);
Add_Goto (Table.States (959), 239, 477);
Add_Goto (Table.States (959), 258, 135);
Add_Goto (Table.States (959), 272, 92);
Add_Goto (Table.States (959), 277, 478);
Add_Goto (Table.States (959), 293, 97);
Add_Goto (Table.States (959), 301, 479);
Add_Goto (Table.States (959), 314, 480);
Add_Goto (Table.States (959), 320, 144);
Add_Goto (Table.States (959), 321, 145);
Add_Goto (Table.States (959), 330, 146);
Table.States (959).Kernel := To_Vector ((0 => (168, 83, 1, True)));
Table.States (959).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Table.States (959).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (960), 37, Reduce, (230, 0), 6, null, null);
Add_Action (Table.States (960), 76, 235);
Add_Action (Table.States (960), 84, 237);
Add_Action (Table.States (960), 87, Reduce, (230, 0), 6, null, null);
Add_Action (Table.States (960), 101, 239);
Add_Action (Table.States (960), 102, 240);
Add_Error (Table.States (960));
Add_Goto (Table.States (960), 115, 241);
Add_Goto (Table.States (960), 322, 242);
Table.States (960).Kernel := To_Vector (((128, 239, 2, True), (230, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (960).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 230, 6)));
end Subr_16;
procedure Subr_17
is begin
Add_Action (Table.States (961), 96, 1090);
Add_Error (Table.States (961));
Table.States (961).Kernel := To_Vector ((0 => (235, 192, 1, False)));
Table.States (961).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1090)));
Add_Action (Table.States (962), 3, 121);
Add_Action (Table.States (962), 39, 122);
Add_Action (Table.States (962), 40, 123);
Add_Action (Table.States (962), 41, 124);
Add_Action (Table.States (962), 76, 126);
Add_Action (Table.States (962), 94, 127);
Add_Action (Table.States (962), 95, 128);
Add_Action (Table.States (962), 103, 129);
Add_Action (Table.States (962), 104, 119);
Add_Action (Table.States (962), 105, 33);
Add_Action (Table.States (962), 106, 34);
Add_Error (Table.States (962));
Add_Goto (Table.States (962), 117, 130);
Add_Goto (Table.States (962), 128, 41);
Add_Goto (Table.States (962), 197, 133);
Add_Goto (Table.States (962), 239, 134);
Add_Goto (Table.States (962), 258, 135);
Add_Goto (Table.States (962), 272, 92);
Add_Goto (Table.States (962), 293, 97);
Add_Goto (Table.States (962), 301, 1091);
Add_Goto (Table.States (962), 320, 144);
Add_Goto (Table.States (962), 321, 145);
Add_Goto (Table.States (962), 330, 146);
Table.States (962).Kernel := To_Vector ((0 => (144, 12, 6, False)));
Table.States (962).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (963), 54, 1092);
Add_Error (Table.States (963));
Table.States (963).Kernel := To_Vector ((0 => (281, 24, 2, False)));
Table.States (963).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 54, 1092)));
Add_Action (Table.States (964), (24, 104), (145, 0), 2, null, null);
Table.States (964).Kernel := To_Vector ((0 => (145, 144, 0, True)));
Table.States (964).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 145, 2)));
Table.States (964).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (965), 77, Reduce, (254, 3), 4, parameter_specification_3'Access, null);
Add_Action (Table.States (965), 82, 1093);
Add_Action (Table.States (965), 96, Reduce, (254, 3), 4, parameter_specification_3'Access, null);
Add_Error (Table.States (965));
Table.States (965).Kernel := To_Vector (((254, 114, 1, False), (254, 114, 0, False)));
Table.States (965).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 254, 4)));
Add_Action (Table.States (966), 40, 386);
Add_Action (Table.States (966), 104, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (966), 105, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (966), 106, Reduce, (241, 1), 0, null, null);
Add_Error (Table.States (966));
Add_Goto (Table.States (966), 241, 1094);
Table.States (966).Kernel := To_Vector (((254, 236, 2, False), (254, 236, 1, False)));
Table.States (966).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 241, 0)));
Add_Action (Table.States (967), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (215, 2), 7,
generic_renaming_declaration_2'Access, null);
Table.States (967).Kernel := To_Vector ((0 => (215, 96, 0, False)));
Table.States (967).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 215, 7)));
Add_Action (Table.States (968), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (215, 0), 7,
generic_renaming_declaration_0'Access, null);
Table.States (968).Kernel := To_Vector ((0 => (215, 96, 0, False)));
Table.States (968).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 215, 7)));
Add_Action (Table.States (969), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (215, 1), 7,
generic_renaming_declaration_1'Access, null);
Table.States (969).Kernel := To_Vector ((0 => (215, 96, 0, False)));
Table.States (969).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 215, 7)));
Add_Action (Table.States (970), (1 => 39), (109, 0), 2, null, null);
Table.States (970).Kernel := To_Vector ((0 => (109, 36, 0, False)));
Table.States (970).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 109, 2)));
Add_Action (Table.States (971), 20, 1095);
Add_Action (Table.States (971), 74, Reduce, (202, 7), 2, null, null);
Add_Action (Table.States (971), 96, Reduce, (202, 7), 2, null, null);
Add_Error (Table.States (971));
Table.States (971).Kernel := To_Vector (((202, 80, 2, False), (202, 80, 0, False)));
Table.States (971).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 2)));
Add_Action (Table.States (972), (74, 96), (202, 5), 2, null, null);
Table.States (972).Kernel := To_Vector ((0 => (202, 80, 0, False)));
Table.States (972).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 2)));
Add_Action (Table.States (973), (74, 96), (202, 4), 2, null, null);
Table.States (973).Kernel := To_Vector ((0 => (202, 80, 0, False)));
Table.States (973).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 2)));
Add_Action (Table.States (974), (74, 96), (202, 3), 2, null, null);
Table.States (974).Kernel := To_Vector ((0 => (202, 80, 0, False)));
Table.States (974).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 2)));
Add_Action (Table.States (975), 96, 1096);
Add_Error (Table.States (975));
Table.States (975).Kernel := To_Vector ((0 => (201, 122, 1, False)));
Table.States (975).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1096)));
Add_Action (Table.States (976), 77, 1097);
Add_Error (Table.States (976));
Table.States (976).Kernel := To_Vector ((0 => (202, 80, 1, False)));
Table.States (976).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 1097)));
Add_Action (Table.States (977), 104, 119);
Add_Action (Table.States (977), 105, 33);
Add_Action (Table.States (977), 106, 34);
Add_Error (Table.States (977));
Add_Goto (Table.States (977), 128, 41);
Add_Goto (Table.States (977), 239, 1098);
Add_Goto (Table.States (977), 272, 92);
Add_Goto (Table.States (977), 293, 97);
Table.States (977).Kernel := To_Vector (((203, 39, 3, False), (203, 39, 1, False)));
Table.States (977).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (978), (74, 96), (202, 0), 2, null, null);
Table.States (978).Kernel := To_Vector ((0 => (202, 49, 0, False)));
Table.States (978).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 2)));
Add_Action (Table.States (979), 96, 1099);
Add_Error (Table.States (979));
Table.States (979).Kernel := To_Vector ((0 => (201, 122, 1, False)));
Table.States (979).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1099)));
Add_Action (Table.States (980), 74, Reduce, (205, 1), 0, null, null);
Add_Action (Table.States (980), 76, 1100);
Add_Action (Table.States (980), 84, 237);
Add_Action (Table.States (980), 96, Reduce, (205, 1), 0, null, null);
Add_Action (Table.States (980), 101, 239);
Add_Action (Table.States (980), 102, 240);
Add_Error (Table.States (980));
Add_Goto (Table.States (980), 115, 241);
Add_Goto (Table.States (980), 205, 1101);
Add_Goto (Table.States (980), 322, 242);
Table.States (980).Kernel := To_Vector (((128, 239, 2, True), (204, 239, 1, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (980).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 205, 0)));
Add_Action (Table.States (981), (29, 47, 48, 50, 69, 71, 74, 104), (200, 2), 6,
formal_subprogram_declaration_2'Access, null);
Table.States (981).Kernel := To_Vector ((0 => (200, 96, 0, False)));
Table.States (981).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 200, 6)));
Add_Action (Table.States (982), 96, 1102);
Add_Error (Table.States (982));
Table.States (982).Kernel := To_Vector ((0 => (200, 122, 1, False)));
Table.States (982).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1102)));
Add_Action (Table.States (983), (29, 47, 48, 50, 69, 71, 74, 104), (200, 1), 6,
formal_subprogram_declaration_1'Access, null);
Table.States (983).Kernel := To_Vector ((0 => (200, 96, 0, False)));
Table.States (983).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 200, 6)));
Add_Action (Table.States (984), 74, 337);
Add_Action (Table.States (984), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (984));
Add_Goto (Table.States (984), 122, 1103);
Table.States (984).Kernel := To_Vector ((0 => (198, 192, 1, False)));
Table.States (984).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (985), (29, 47, 48, 50, 69, 71, 74, 104), (198, 3), 6,
formal_object_declaration_3'Access, null);
Table.States (985).Kernel := To_Vector ((0 => (198, 96, 0, False)));
Table.States (985).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 198, 6)));
Add_Action (Table.States (986), 3, 121);
Add_Action (Table.States (986), 39, 122);
Add_Action (Table.States (986), 40, 123);
Add_Action (Table.States (986), 41, 124);
Add_Action (Table.States (986), 52, 125);
Add_Action (Table.States (986), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (986), 76, 126);
Add_Action (Table.States (986), 94, 127);
Add_Action (Table.States (986), 95, 128);
Add_Action (Table.States (986), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (986), 103, 129);
Add_Action (Table.States (986), 104, 119);
Add_Action (Table.States (986), 105, 33);
Add_Action (Table.States (986), 106, 34);
Add_Error (Table.States (986));
Add_Goto (Table.States (986), 117, 130);
Add_Goto (Table.States (986), 128, 41);
Add_Goto (Table.States (986), 191, 131);
Add_Goto (Table.States (986), 192, 1104);
Add_Goto (Table.States (986), 197, 133);
Add_Goto (Table.States (986), 239, 134);
Add_Goto (Table.States (986), 258, 135);
Add_Goto (Table.States (986), 272, 92);
Add_Goto (Table.States (986), 275, 136);
Add_Goto (Table.States (986), 282, 137);
Add_Goto (Table.States (986), 283, 138);
Add_Goto (Table.States (986), 284, 139);
Add_Goto (Table.States (986), 285, 140);
Add_Goto (Table.States (986), 286, 141);
Add_Goto (Table.States (986), 287, 142);
Add_Goto (Table.States (986), 293, 97);
Add_Goto (Table.States (986), 301, 143);
Add_Goto (Table.States (986), 320, 144);
Add_Goto (Table.States (986), 321, 145);
Add_Goto (Table.States (986), 330, 146);
Table.States (986).Kernel := To_Vector ((0 => (198, 82, 1, False)));
Table.States (986).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (987), 96, 1105);
Add_Error (Table.States (987));
Table.States (987).Kernel := To_Vector ((0 => (198, 122, 1, False)));
Table.States (987).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1105)));
Add_Action (Table.States (988), 32, 1106);
Add_Error (Table.States (988));
Table.States (988).Kernel := To_Vector ((0 => (222, 24, 2, False)));
Table.States (988).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 32, 1106)));
Add_Action (Table.States (989), 4, 1);
Add_Action (Table.States (989), 5, 2);
Add_Action (Table.States (989), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (989), 15, 3);
Add_Action (Table.States (989), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (989), 18, 4);
Add_Action (Table.States (989), 22, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (989), 23, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (989), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (989), 27, 5);
Add_Action (Table.States (989), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (989), 31, 9);
Add_Action (Table.States (989), 32, 10);
Add_Action (Table.States (989), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (989), 41, 13);
Add_Action (Table.States (989), 48, 16);
Add_Action (Table.States (989), 52, 20);
Add_Action (Table.States (989), 57, 21);
Add_Action (Table.States (989), 58, 22);
Add_Action (Table.States (989), 61, 24);
Add_Action (Table.States (989), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (989), 93, 31);
Add_Action (Table.States (989), 104, 360);
Add_Action (Table.States (989), 105, 33);
Add_Action (Table.States (989), 106, 34);
Add_Error (Table.States (989));
Add_Goto (Table.States (989), 113, 36);
Add_Goto (Table.States (989), 123, 38);
Add_Goto (Table.States (989), 126, 39);
Add_Goto (Table.States (989), 128, 41);
Add_Goto (Table.States (989), 131, 42);
Add_Goto (Table.States (989), 132, 43);
Add_Goto (Table.States (989), 133, 44);
Add_Goto (Table.States (989), 139, 47);
Add_Goto (Table.States (989), 151, 50);
Add_Goto (Table.States (989), 152, 51);
Add_Goto (Table.States (989), 161, 53);
Add_Goto (Table.States (989), 190, 57);
Add_Goto (Table.States (989), 196, 59);
Add_Goto (Table.States (989), 217, 68);
Add_Goto (Table.States (989), 222, 70);
Add_Goto (Table.States (989), 232, 72);
Add_Goto (Table.States (989), 239, 73);
Add_Goto (Table.States (989), 257, 83);
Add_Goto (Table.States (989), 261, 86);
Add_Goto (Table.States (989), 272, 92);
Add_Goto (Table.States (989), 276, 93);
Add_Goto (Table.States (989), 290, 96);
Add_Goto (Table.States (989), 293, 97);
Add_Goto (Table.States (989), 294, 98);
Add_Goto (Table.States (989), 298, 99);
Add_Goto (Table.States (989), 299, 361);
Add_Goto (Table.States (989), 300, 1107);
Add_Goto (Table.States (989), 302, 100);
Add_Goto (Table.States (989), 303, 101);
Add_Goto (Table.States (989), 306, 363);
Add_Goto (Table.States (989), 323, 114);
Table.States (989).Kernel := To_Vector ((0 => (174, 68, 0, False)));
Table.States (989).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (990), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (222, 3), 7, if_statement_3'Access, null);
Table.States (990).Kernel := To_Vector ((0 => (222, 96, 0, False)));
Table.States (990).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 222, 7)));
Add_Action (Table.States (991), 24, 1108);
Add_Error (Table.States (991));
Table.States (991).Kernel := To_Vector ((0 => (222, 300, 3, False)));
Table.States (991).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1108)));
Add_Action (Table.States (992), 96, 1109);
Add_Error (Table.States (992));
Table.States (992).Kernel := To_Vector ((0 => (222, 32, 1, False)));
Table.States (992).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1109)));
Add_Action (Table.States (993), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (248, 0), 7,
package_body_stub_0'Access, null);
Table.States (993).Kernel := To_Vector ((0 => (248, 96, 0, False)));
Table.States (993).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 248, 7)));
Add_Action (Table.States (994), 4, 1);
Add_Action (Table.States (994), 5, 2);
Add_Action (Table.States (994), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (994), 15, 3);
Add_Action (Table.States (994), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (994), 18, 4);
Add_Action (Table.States (994), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (994), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (994), 27, 5);
Add_Action (Table.States (994), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (994), 31, 9);
Add_Action (Table.States (994), 32, 10);
Add_Action (Table.States (994), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (994), 41, 13);
Add_Action (Table.States (994), 48, 16);
Add_Action (Table.States (994), 52, 20);
Add_Action (Table.States (994), 57, 21);
Add_Action (Table.States (994), 58, 22);
Add_Action (Table.States (994), 61, 24);
Add_Action (Table.States (994), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (994), 93, 31);
Add_Action (Table.States (994), 104, 360);
Add_Action (Table.States (994), 105, 33);
Add_Action (Table.States (994), 106, 34);
Add_Error (Table.States (994));
Add_Goto (Table.States (994), 113, 36);
Add_Goto (Table.States (994), 123, 38);
Add_Goto (Table.States (994), 126, 39);
Add_Goto (Table.States (994), 128, 41);
Add_Goto (Table.States (994), 131, 42);
Add_Goto (Table.States (994), 132, 43);
Add_Goto (Table.States (994), 133, 44);
Add_Goto (Table.States (994), 139, 47);
Add_Goto (Table.States (994), 151, 50);
Add_Goto (Table.States (994), 152, 51);
Add_Goto (Table.States (994), 161, 53);
Add_Goto (Table.States (994), 190, 57);
Add_Goto (Table.States (994), 196, 59);
Add_Goto (Table.States (994), 217, 68);
Add_Goto (Table.States (994), 218, 1110);
Add_Goto (Table.States (994), 222, 70);
Add_Goto (Table.States (994), 232, 72);
Add_Goto (Table.States (994), 239, 73);
Add_Goto (Table.States (994), 257, 83);
Add_Goto (Table.States (994), 261, 86);
Add_Goto (Table.States (994), 272, 92);
Add_Goto (Table.States (994), 276, 93);
Add_Goto (Table.States (994), 290, 96);
Add_Goto (Table.States (994), 293, 97);
Add_Goto (Table.States (994), 294, 98);
Add_Goto (Table.States (994), 298, 99);
Add_Goto (Table.States (994), 299, 361);
Add_Goto (Table.States (994), 300, 390);
Add_Goto (Table.States (994), 302, 100);
Add_Goto (Table.States (994), 303, 101);
Add_Goto (Table.States (994), 306, 363);
Add_Goto (Table.States (994), 323, 114);
Table.States (994).Kernel := To_Vector ((0 => (247, 13, 2, False)));
Table.States (994).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (995), 96, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (995), 104, 119);
Add_Action (Table.States (995), 105, 33);
Add_Action (Table.States (995), 106, 34);
Add_Error (Table.States (995));
Add_Goto (Table.States (995), 128, 41);
Add_Goto (Table.States (995), 239, 630);
Add_Goto (Table.States (995), 240, 1111);
Add_Goto (Table.States (995), 272, 92);
Add_Goto (Table.States (995), 293, 97);
Table.States (995).Kernel := To_Vector ((0 => (247, 24, 1, False)));
Table.States (995).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 240, 0)));
Add_Action (Table.States (996), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (213, 0), 7,
generic_instantiation_0'Access, null);
Table.States (996).Kernel := To_Vector ((0 => (213, 96, 0, False)));
Table.States (996).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 213, 7)));
Add_Action (Table.States (997), (1 => 96), (251, 1), 7, package_specification_1'Access,
package_specification_1_check'Access);
Table.States (997).Kernel := To_Vector ((0 => (251, 240, 0, False)));
Table.States (997).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 251, 7)));
Add_Action (Table.States (998), 24, 1112);
Add_Error (Table.States (998));
Table.States (998).Kernel := To_Vector ((0 => (251, 159, 1, False)));
Table.States (998).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1112)));
Add_Action (Table.States (999), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (265, 0), 7,
protected_body_stub_0'Access, null);
Table.States (999).Kernel := To_Vector ((0 => (265, 96, 0, False)));
Table.States (999).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 265, 7)));
Add_Action (Table.States (1000), 72, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (1000), 76, 1113);
Add_Error (Table.States (1000));
Add_Goto (Table.States (1000), 177, 1114);
Add_Goto (Table.States (1000), 199, 344);
Add_Goto (Table.States (1000), 253, 1115);
Table.States (1000).Kernel := To_Vector ((0 => (176, 104, 5, False)));
Table.States (1000).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 177, 0)));
Add_Action (Table.States (1001), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (1001), 74, 337);
Add_Action (Table.States (1001), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1001));
Add_Goto (Table.States (1001), 122, 430);
Table.States (1001).Kernel := To_Vector (((307, 312, 4, False), (309, 312, 1, False)));
Table.States (1001).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1002), (24, 25, 28, 29, 40, 46, 50), (268, 0), 2, null, null);
Table.States (1002).Kernel := To_Vector ((0 => (268, 267, 0, True)));
Table.States (1002).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 268, 2)));
Table.States (1002).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1003), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (1003), 104, 149);
Add_Error (Table.States (1003));
Add_Goto (Table.States (1003), 220, 1116);
Table.States (1003).Kernel := To_Vector ((0 => (264, 24, 1, False)));
Table.States (1003).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (1004), 104, 119);
Add_Action (Table.States (1004), 105, 33);
Add_Action (Table.States (1004), 106, 34);
Add_Error (Table.States (1004));
Add_Goto (Table.States (1004), 128, 41);
Add_Goto (Table.States (1004), 227, 1117);
Add_Goto (Table.States (1004), 239, 841);
Add_Goto (Table.States (1004), 272, 92);
Add_Goto (Table.States (1004), 293, 97);
Table.States (1004).Kernel := To_Vector ((0 => (271, 39, 4, False)));
Table.States (1004).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1005), 96, 1118);
Add_Error (Table.States (1005));
Table.States (1005).Kernel := To_Vector ((0 => (271, 266, 1, False)));
Table.States (1005).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1118)));
Add_Action (Table.States (1006), 104, 119);
Add_Action (Table.States (1006), 105, 33);
Add_Action (Table.States (1006), 106, 34);
Add_Error (Table.States (1006));
Add_Goto (Table.States (1006), 128, 41);
Add_Goto (Table.States (1006), 239, 1119);
Add_Goto (Table.States (1006), 272, 92);
Add_Goto (Table.States (1006), 293, 97);
Table.States (1006).Kernel := To_Vector ((0 => (227, 10, 1, True)));
Table.States (1006).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Table.States (1006).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1007), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1007), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1007), 28, 183);
Add_Action (Table.States (1007), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1007), 30, 8);
Add_Action (Table.States (1007), 40, 12);
Add_Action (Table.States (1007), 46, 14);
Add_Action (Table.States (1007), 47, 15);
Add_Action (Table.States (1007), 48, 16);
Add_Action (Table.States (1007), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1007), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1007), 51, 19);
Add_Action (Table.States (1007), 63, 25);
Add_Action (Table.States (1007), 66, 26);
Add_Action (Table.States (1007), 69, 27);
Add_Action (Table.States (1007), 71, 28);
Add_Action (Table.States (1007), 104, 185);
Add_Error (Table.States (1007));
Add_Goto (Table.States (1007), 112, 35);
Add_Goto (Table.States (1007), 121, 37);
Add_Goto (Table.States (1007), 127, 40);
Add_Goto (Table.States (1007), 134, 45);
Add_Goto (Table.States (1007), 135, 46);
Add_Goto (Table.States (1007), 157, 391);
Add_Goto (Table.States (1007), 158, 392);
Add_Goto (Table.States (1007), 159, 667);
Add_Goto (Table.States (1007), 179, 54);
Add_Goto (Table.States (1007), 182, 55);
Add_Goto (Table.States (1007), 186, 56);
Add_Goto (Table.States (1007), 193, 58);
Add_Goto (Table.States (1007), 206, 60);
Add_Goto (Table.States (1007), 207, 61);
Add_Goto (Table.States (1007), 209, 62);
Add_Goto (Table.States (1007), 210, 63);
Add_Goto (Table.States (1007), 213, 64);
Add_Goto (Table.States (1007), 214, 65);
Add_Goto (Table.States (1007), 215, 66);
Add_Goto (Table.States (1007), 216, 67);
Add_Goto (Table.States (1007), 219, 69);
Add_Goto (Table.States (1007), 223, 71);
Add_Goto (Table.States (1007), 243, 74);
Add_Goto (Table.States (1007), 244, 75);
Add_Goto (Table.States (1007), 245, 76);
Add_Goto (Table.States (1007), 246, 77);
Add_Goto (Table.States (1007), 247, 78);
Add_Goto (Table.States (1007), 248, 79);
Add_Goto (Table.States (1007), 249, 80);
Add_Goto (Table.States (1007), 250, 81);
Add_Goto (Table.States (1007), 251, 82);
Add_Goto (Table.States (1007), 257, 394);
Add_Goto (Table.States (1007), 259, 84);
Add_Goto (Table.States (1007), 260, 85);
Add_Goto (Table.States (1007), 262, 87);
Add_Goto (Table.States (1007), 263, 88);
Add_Goto (Table.States (1007), 264, 89);
Add_Goto (Table.States (1007), 265, 90);
Add_Goto (Table.States (1007), 266, 1120);
Add_Goto (Table.States (1007), 271, 91);
Add_Goto (Table.States (1007), 281, 94);
Add_Goto (Table.States (1007), 289, 95);
Add_Goto (Table.States (1007), 304, 102);
Add_Goto (Table.States (1007), 305, 103);
Add_Goto (Table.States (1007), 307, 105);
Add_Goto (Table.States (1007), 308, 106);
Add_Goto (Table.States (1007), 309, 107);
Add_Goto (Table.States (1007), 311, 108);
Add_Goto (Table.States (1007), 313, 109);
Add_Goto (Table.States (1007), 316, 111);
Add_Goto (Table.States (1007), 317, 112);
Add_Goto (Table.States (1007), 319, 113);
Add_Goto (Table.States (1007), 325, 115);
Add_Goto (Table.States (1007), 331, 116);
Table.States (1007).Kernel := To_Vector ((0 => (304, 74, 2, False)));
Table.States (1007).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (1008), (1 => 96), (266, 1), 3, protected_definition_1'Access,
protected_definition_1_check'Access);
Table.States (1008).Kernel := To_Vector ((0 => (266, 220, 0, False)));
Table.States (1008).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 266, 3)));
Add_Action (Table.States (1009), 24, 1121);
Add_Error (Table.States (1009));
Table.States (1009).Kernel := To_Vector ((0 => (266, 159, 1, False)));
Table.States (1009).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1121)));
Add_Action (Table.States (1010), 3, 121);
Add_Action (Table.States (1010), 21, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1010), 39, 122);
Add_Action (Table.States (1010), 40, 123);
Add_Action (Table.States (1010), 41, 124);
Add_Action (Table.States (1010), 52, 125);
Add_Action (Table.States (1010), 76, 126);
Add_Action (Table.States (1010), 94, 127);
Add_Action (Table.States (1010), 95, 128);
Add_Action (Table.States (1010), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1010), 103, 129);
Add_Action (Table.States (1010), 104, 119);
Add_Action (Table.States (1010), 105, 33);
Add_Action (Table.States (1010), 106, 34);
Add_Error (Table.States (1010));
Add_Goto (Table.States (1010), 117, 130);
Add_Goto (Table.States (1010), 128, 41);
Add_Goto (Table.States (1010), 191, 131);
Add_Goto (Table.States (1010), 192, 1122);
Add_Goto (Table.States (1010), 197, 133);
Add_Goto (Table.States (1010), 239, 134);
Add_Goto (Table.States (1010), 258, 135);
Add_Goto (Table.States (1010), 272, 92);
Add_Goto (Table.States (1010), 275, 136);
Add_Goto (Table.States (1010), 282, 137);
Add_Goto (Table.States (1010), 283, 138);
Add_Goto (Table.States (1010), 284, 139);
Add_Goto (Table.States (1010), 285, 140);
Add_Goto (Table.States (1010), 286, 141);
Add_Goto (Table.States (1010), 287, 142);
Add_Goto (Table.States (1010), 293, 97);
Add_Goto (Table.States (1010), 301, 143);
Add_Goto (Table.States (1010), 320, 144);
Add_Goto (Table.States (1010), 321, 145);
Add_Goto (Table.States (1010), 330, 146);
Table.States (1010).Kernel := To_Vector ((0 => (194, 82, 0, False)));
Table.States (1010).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1011), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (196, 0), 7, extended_return_statement_0'Access, null);
Table.States (1011).Kernel := To_Vector ((0 => (196, 96, 0, False)));
Table.States (1011).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 196, 7)));
Add_Action (Table.States (1012), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (1012), 74, 337);
Add_Action (Table.States (1012), 76, 235);
Add_Action (Table.States (1012), 84, 237);
Add_Action (Table.States (1012), 101, 239);
Add_Action (Table.States (1012), 102, 240);
Add_Error (Table.States (1012));
Add_Goto (Table.States (1012), 115, 241);
Add_Goto (Table.States (1012), 122, 511);
Add_Goto (Table.States (1012), 322, 242);
Table.States (1012).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(247, 239, 4, False), (247, 239, 3, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (1012).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1013), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (1013), 74, 337);
Add_Error (Table.States (1013));
Add_Goto (Table.States (1013), 122, 520);
Table.States (1013).Kernel := To_Vector ((0 => (264, 104, 3, False)));
Table.States (1013).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1014), 35, Reduce, (122, 1), 0, null, null);
Add_Action (Table.States (1014), 74, 337);
Add_Error (Table.States (1014));
Add_Goto (Table.States (1014), 122, 540);
Table.States (1014).Kernel := To_Vector ((0 => (316, 104, 4, False)));
Table.States (1014).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1015), 35, 585);
Add_Error (Table.States (1015));
Table.States (1015).Kernel := To_Vector ((0 => (307, 122, 4, False)));
Table.States (1015).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 585)));
Add_Action (Table.States (1016), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (152, 0), 7, conditional_entry_call_0'Access, null);
Table.States (1016).Kernel := To_Vector ((0 => (152, 96, 0, False)));
Table.States (1016).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 152, 7)));
Add_Action (Table.States (1017), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (323, 0), 7, timed_entry_call_0'Access, null);
Table.States (1017).Kernel := To_Vector ((0 => (323, 96, 0, False)));
Table.States (1017).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 323, 7)));
Add_Action (Table.States (1018), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (294, 0), 7, selective_accept_0'Access, null);
Table.States (1018).Kernel := To_Vector ((0 => (294, 96, 0, False)));
Table.States (1018).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 294, 7)));
Add_Action (Table.States (1019), 96, 1123);
Add_Error (Table.States (1019));
Table.States (1019).Kernel := To_Vector ((0 => (126, 61, 1, False)));
Table.States (1019).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1123)));
Add_Action (Table.States (1020), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (317, 0), 7,
task_body_stub_0'Access, null);
Table.States (1020).Kernel := To_Vector ((0 => (317, 96, 0, False)));
Table.States (1020).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 317, 7)));
Add_Action (Table.States (1021), 4, 1);
Add_Action (Table.States (1021), 5, 2);
Add_Action (Table.States (1021), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1021), 15, 3);
Add_Action (Table.States (1021), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1021), 18, 4);
Add_Action (Table.States (1021), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1021), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1021), 27, 5);
Add_Action (Table.States (1021), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1021), 31, 9);
Add_Action (Table.States (1021), 32, 10);
Add_Action (Table.States (1021), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1021), 41, 13);
Add_Action (Table.States (1021), 48, 16);
Add_Action (Table.States (1021), 52, 20);
Add_Action (Table.States (1021), 57, 21);
Add_Action (Table.States (1021), 58, 22);
Add_Action (Table.States (1021), 61, 24);
Add_Action (Table.States (1021), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1021), 93, 31);
Add_Action (Table.States (1021), 104, 360);
Add_Action (Table.States (1021), 105, 33);
Add_Action (Table.States (1021), 106, 34);
Add_Error (Table.States (1021));
Add_Goto (Table.States (1021), 113, 36);
Add_Goto (Table.States (1021), 123, 38);
Add_Goto (Table.States (1021), 126, 39);
Add_Goto (Table.States (1021), 128, 41);
Add_Goto (Table.States (1021), 131, 42);
Add_Goto (Table.States (1021), 132, 43);
Add_Goto (Table.States (1021), 133, 44);
Add_Goto (Table.States (1021), 139, 47);
Add_Goto (Table.States (1021), 151, 50);
Add_Goto (Table.States (1021), 152, 51);
Add_Goto (Table.States (1021), 161, 53);
Add_Goto (Table.States (1021), 190, 57);
Add_Goto (Table.States (1021), 196, 59);
Add_Goto (Table.States (1021), 217, 68);
Add_Goto (Table.States (1021), 218, 1124);
Add_Goto (Table.States (1021), 222, 70);
Add_Goto (Table.States (1021), 232, 72);
Add_Goto (Table.States (1021), 239, 73);
Add_Goto (Table.States (1021), 257, 83);
Add_Goto (Table.States (1021), 261, 86);
Add_Goto (Table.States (1021), 272, 92);
Add_Goto (Table.States (1021), 276, 93);
Add_Goto (Table.States (1021), 290, 96);
Add_Goto (Table.States (1021), 293, 97);
Add_Goto (Table.States (1021), 294, 98);
Add_Goto (Table.States (1021), 298, 99);
Add_Goto (Table.States (1021), 299, 361);
Add_Goto (Table.States (1021), 300, 390);
Add_Goto (Table.States (1021), 302, 100);
Add_Goto (Table.States (1021), 303, 101);
Add_Goto (Table.States (1021), 306, 363);
Add_Goto (Table.States (1021), 323, 114);
Table.States (1021).Kernel := To_Vector ((0 => (316, 13, 2, False)));
Table.States (1021).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (1022), 104, 119);
Add_Action (Table.States (1022), 105, 33);
Add_Action (Table.States (1022), 106, 34);
Add_Error (Table.States (1022));
Add_Goto (Table.States (1022), 128, 41);
Add_Goto (Table.States (1022), 227, 1125);
Add_Goto (Table.States (1022), 239, 841);
Add_Goto (Table.States (1022), 272, 92);
Add_Goto (Table.States (1022), 293, 97);
Table.States (1022).Kernel := To_Vector ((0 => (319, 39, 4, False)));
Table.States (1022).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1023), 24, 1126);
Add_Error (Table.States (1023));
Table.States (1023).Kernel := To_Vector ((0 => (319, 318, 2, False)));
Table.States (1023).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1126)));
Add_Action (Table.States (1024), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1024), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1024), 28, 183);
Add_Action (Table.States (1024), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1024), 30, 8);
Add_Action (Table.States (1024), 40, 12);
Add_Action (Table.States (1024), 46, 14);
Add_Action (Table.States (1024), 47, 15);
Add_Action (Table.States (1024), 48, 16);
Add_Action (Table.States (1024), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1024), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1024), 51, 19);
Add_Action (Table.States (1024), 63, 25);
Add_Action (Table.States (1024), 66, 26);
Add_Action (Table.States (1024), 69, 27);
Add_Action (Table.States (1024), 71, 28);
Add_Action (Table.States (1024), 104, 185);
Add_Error (Table.States (1024));
Add_Goto (Table.States (1024), 112, 35);
Add_Goto (Table.States (1024), 121, 37);
Add_Goto (Table.States (1024), 127, 40);
Add_Goto (Table.States (1024), 134, 45);
Add_Goto (Table.States (1024), 135, 46);
Add_Goto (Table.States (1024), 157, 391);
Add_Goto (Table.States (1024), 158, 392);
Add_Goto (Table.States (1024), 159, 692);
Add_Goto (Table.States (1024), 179, 54);
Add_Goto (Table.States (1024), 182, 55);
Add_Goto (Table.States (1024), 186, 56);
Add_Goto (Table.States (1024), 193, 58);
Add_Goto (Table.States (1024), 206, 60);
Add_Goto (Table.States (1024), 207, 61);
Add_Goto (Table.States (1024), 209, 62);
Add_Goto (Table.States (1024), 210, 63);
Add_Goto (Table.States (1024), 213, 64);
Add_Goto (Table.States (1024), 214, 65);
Add_Goto (Table.States (1024), 215, 66);
Add_Goto (Table.States (1024), 216, 67);
Add_Goto (Table.States (1024), 219, 69);
Add_Goto (Table.States (1024), 223, 71);
Add_Goto (Table.States (1024), 243, 74);
Add_Goto (Table.States (1024), 244, 75);
Add_Goto (Table.States (1024), 245, 76);
Add_Goto (Table.States (1024), 246, 77);
Add_Goto (Table.States (1024), 247, 78);
Add_Goto (Table.States (1024), 248, 79);
Add_Goto (Table.States (1024), 249, 80);
Add_Goto (Table.States (1024), 250, 81);
Add_Goto (Table.States (1024), 251, 82);
Add_Goto (Table.States (1024), 257, 394);
Add_Goto (Table.States (1024), 259, 84);
Add_Goto (Table.States (1024), 260, 85);
Add_Goto (Table.States (1024), 262, 87);
Add_Goto (Table.States (1024), 263, 88);
Add_Goto (Table.States (1024), 264, 89);
Add_Goto (Table.States (1024), 265, 90);
Add_Goto (Table.States (1024), 271, 91);
Add_Goto (Table.States (1024), 281, 94);
Add_Goto (Table.States (1024), 289, 95);
Add_Goto (Table.States (1024), 304, 102);
Add_Goto (Table.States (1024), 305, 103);
Add_Goto (Table.States (1024), 307, 105);
Add_Goto (Table.States (1024), 308, 106);
Add_Goto (Table.States (1024), 309, 107);
Add_Goto (Table.States (1024), 311, 108);
Add_Goto (Table.States (1024), 313, 109);
Add_Goto (Table.States (1024), 316, 111);
Add_Goto (Table.States (1024), 317, 112);
Add_Goto (Table.States (1024), 318, 1127);
Add_Goto (Table.States (1024), 319, 113);
Add_Goto (Table.States (1024), 325, 115);
Add_Goto (Table.States (1024), 331, 116);
Table.States (1024).Kernel := To_Vector ((0 => (305, 74, 2, False)));
Table.States (1024).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 318, 0)));
end Subr_17;
procedure Subr_18
is begin
Add_Action (Table.States (1025), (1 => 24), (318, 0), 3, task_definition_0'Access, null);
Table.States (1025).Kernel := To_Vector ((0 => (318, 159, 0, False)));
Table.States (1025).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 318, 3)));
Add_Action (Table.States (1026), 96, 1128);
Add_Error (Table.States (1026));
Table.States (1026).Kernel := To_Vector ((0 => (305, 220, 1, False)));
Table.States (1026).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1128)));
Add_Action (Table.States (1027), 7, Reduce, (241, 0), 2, null, null);
Add_Action (Table.States (1027), 104, 1129);
Add_Action (Table.States (1027), 105, 33);
Add_Action (Table.States (1027), 106, 34);
Add_Error (Table.States (1027));
Add_Goto (Table.States (1027), 128, 41);
Add_Goto (Table.States (1027), 239, 871);
Add_Goto (Table.States (1027), 272, 92);
Add_Goto (Table.States (1027), 293, 1130);
Table.States (1027).Kernel := To_Vector (((241, 41, 0, False), (242, 41, 1, False), (242, 41, 3, False)));
Table.States (1027).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 241, 2)));
Add_Action (Table.States (1028), 3, 121);
Add_Action (Table.States (1028), 39, 122);
Add_Action (Table.States (1028), 40, 123);
Add_Action (Table.States (1028), 41, 124);
Add_Action (Table.States (1028), 52, 125);
Add_Action (Table.States (1028), 76, 126);
Add_Action (Table.States (1028), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1028), 94, 127);
Add_Action (Table.States (1028), 95, 128);
Add_Action (Table.States (1028), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1028), 103, 129);
Add_Action (Table.States (1028), 104, 119);
Add_Action (Table.States (1028), 105, 33);
Add_Action (Table.States (1028), 106, 34);
Add_Error (Table.States (1028));
Add_Goto (Table.States (1028), 117, 130);
Add_Goto (Table.States (1028), 128, 41);
Add_Goto (Table.States (1028), 191, 131);
Add_Goto (Table.States (1028), 192, 1131);
Add_Goto (Table.States (1028), 197, 133);
Add_Goto (Table.States (1028), 239, 134);
Add_Goto (Table.States (1028), 258, 135);
Add_Goto (Table.States (1028), 272, 92);
Add_Goto (Table.States (1028), 275, 136);
Add_Goto (Table.States (1028), 282, 137);
Add_Goto (Table.States (1028), 283, 138);
Add_Goto (Table.States (1028), 284, 139);
Add_Goto (Table.States (1028), 285, 140);
Add_Goto (Table.States (1028), 286, 141);
Add_Goto (Table.States (1028), 287, 142);
Add_Goto (Table.States (1028), 293, 97);
Add_Goto (Table.States (1028), 301, 143);
Add_Goto (Table.States (1028), 320, 144);
Add_Goto (Table.States (1028), 321, 145);
Add_Goto (Table.States (1028), 330, 146);
Table.States (1028).Kernel := To_Vector ((0 => (170, 82, 0, False)));
Table.States (1028).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1029), 3, 121);
Add_Action (Table.States (1029), 39, 122);
Add_Action (Table.States (1029), 40, 123);
Add_Action (Table.States (1029), 41, 124);
Add_Action (Table.States (1029), 52, 125);
Add_Action (Table.States (1029), 76, 126);
Add_Action (Table.States (1029), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1029), 94, 127);
Add_Action (Table.States (1029), 95, 128);
Add_Action (Table.States (1029), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1029), 103, 129);
Add_Action (Table.States (1029), 104, 119);
Add_Action (Table.States (1029), 105, 33);
Add_Action (Table.States (1029), 106, 34);
Add_Error (Table.States (1029));
Add_Goto (Table.States (1029), 117, 130);
Add_Goto (Table.States (1029), 128, 41);
Add_Goto (Table.States (1029), 191, 131);
Add_Goto (Table.States (1029), 192, 1132);
Add_Goto (Table.States (1029), 197, 133);
Add_Goto (Table.States (1029), 239, 134);
Add_Goto (Table.States (1029), 258, 135);
Add_Goto (Table.States (1029), 272, 92);
Add_Goto (Table.States (1029), 275, 136);
Add_Goto (Table.States (1029), 282, 137);
Add_Goto (Table.States (1029), 283, 138);
Add_Goto (Table.States (1029), 284, 139);
Add_Goto (Table.States (1029), 285, 140);
Add_Goto (Table.States (1029), 286, 141);
Add_Goto (Table.States (1029), 287, 142);
Add_Goto (Table.States (1029), 293, 97);
Add_Goto (Table.States (1029), 301, 143);
Add_Goto (Table.States (1029), 320, 144);
Add_Goto (Table.States (1029), 321, 145);
Add_Goto (Table.States (1029), 330, 146);
Table.States (1029).Kernel := To_Vector ((0 => (170, 82, 0, False)));
Table.States (1029).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1030), (41, 49, 54), (111, 0), 3, null, null);
Table.States (1030).Kernel := To_Vector ((0 => (111, 36, 0, False)));
Table.States (1030).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 111, 3)));
Add_Action (Table.States (1031), 77, 1133);
Add_Action (Table.States (1031), 83, 959);
Add_Error (Table.States (1031));
Table.States (1031).Kernel := To_Vector (((120, 168, 3, False), (168, 168, 2, True)));
Table.States (1031).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 1133)));
Add_Action (Table.States (1032), (77, 83), (226, 1), 1, null, null);
Table.States (1032).Kernel := To_Vector ((0 => (226, 225, 0, False)));
Table.States (1032).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 226, 1)));
Add_Action (Table.States (1033), 77, 1134);
Add_Action (Table.States (1033), 83, 1135);
Add_Error (Table.States (1033));
Table.States (1033).Kernel := To_Vector (((120, 226, 3, False), (226, 226, 4, True)));
Table.States (1033).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 1134)));
Add_Action (Table.States (1034), 38, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 53, 1136);
Add_Action (Table.States (1034), 55, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 76, 619);
Add_Action (Table.States (1034), 77, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (1034), 78, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 83, Reduce, (314, 3), 1, subtype_indication_3'Access, null);
Add_Action (Table.States (1034), 84, 237);
Add_Action (Table.States (1034), 85, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 94, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 95, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 97, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 99, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 100, Reduce, (258, 3), 1, null, null);
Add_Action (Table.States (1034), 101, 239);
Add_Action (Table.States (1034), 102, 240);
Add_Error (Table.States (1034));
Add_Goto (Table.States (1034), 115, 241);
Add_Goto (Table.States (1034), 155, 620);
Add_Goto (Table.States (1034), 224, 621);
Add_Goto (Table.States (1034), 322, 448);
Table.States (1034).Kernel := To_Vector (((128, 239, 2, True), (225, 239, 2, False), (239, 239, 5, True),
(239, 239, 2, True), (258, 239, 0, False), (272, 239, 3, True), (277, 239, 4, False), (277, 239, 2, False),
(293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), (314, 239, 4, False),
(314, 239, 0, False)));
Table.States (1034).Minimal_Complete_Actions := To_Vector (((Reduce, 258, 1), (Reduce, 314, 1)));
Add_Action (Table.States (1035), 3, 121);
Add_Action (Table.States (1035), 39, 122);
Add_Action (Table.States (1035), 40, 123);
Add_Action (Table.States (1035), 41, 124);
Add_Action (Table.States (1035), 52, 125);
Add_Action (Table.States (1035), 53, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1035), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1035), 76, 126);
Add_Action (Table.States (1035), 94, 127);
Add_Action (Table.States (1035), 95, 128);
Add_Action (Table.States (1035), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1035), 103, 129);
Add_Action (Table.States (1035), 104, 119);
Add_Action (Table.States (1035), 105, 33);
Add_Action (Table.States (1035), 106, 34);
Add_Error (Table.States (1035));
Add_Goto (Table.States (1035), 117, 130);
Add_Goto (Table.States (1035), 128, 41);
Add_Goto (Table.States (1035), 191, 131);
Add_Goto (Table.States (1035), 192, 1137);
Add_Goto (Table.States (1035), 197, 133);
Add_Goto (Table.States (1035), 239, 134);
Add_Goto (Table.States (1035), 258, 135);
Add_Goto (Table.States (1035), 272, 92);
Add_Goto (Table.States (1035), 275, 136);
Add_Goto (Table.States (1035), 282, 137);
Add_Goto (Table.States (1035), 283, 138);
Add_Goto (Table.States (1035), 284, 139);
Add_Goto (Table.States (1035), 285, 140);
Add_Goto (Table.States (1035), 286, 141);
Add_Goto (Table.States (1035), 287, 142);
Add_Goto (Table.States (1035), 293, 97);
Add_Goto (Table.States (1035), 301, 143);
Add_Goto (Table.States (1035), 320, 144);
Add_Goto (Table.States (1035), 321, 145);
Add_Goto (Table.States (1035), 330, 146);
Table.States (1035).Kernel := To_Vector ((0 => (326, 20, 0, False)));
Table.States (1035).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1036), 3, 121);
Add_Action (Table.States (1036), 39, 122);
Add_Action (Table.States (1036), 40, 123);
Add_Action (Table.States (1036), 41, 124);
Add_Action (Table.States (1036), 76, 126);
Add_Action (Table.States (1036), 94, 127);
Add_Action (Table.States (1036), 95, 128);
Add_Action (Table.States (1036), 103, 129);
Add_Action (Table.States (1036), 104, 119);
Add_Action (Table.States (1036), 105, 33);
Add_Action (Table.States (1036), 106, 34);
Add_Error (Table.States (1036));
Add_Goto (Table.States (1036), 117, 130);
Add_Goto (Table.States (1036), 128, 41);
Add_Goto (Table.States (1036), 197, 133);
Add_Goto (Table.States (1036), 239, 134);
Add_Goto (Table.States (1036), 258, 135);
Add_Goto (Table.States (1036), 272, 92);
Add_Goto (Table.States (1036), 293, 97);
Add_Goto (Table.States (1036), 301, 1138);
Add_Goto (Table.States (1036), 320, 144);
Add_Goto (Table.States (1036), 321, 145);
Add_Goto (Table.States (1036), 330, 146);
Table.States (1036).Kernel := To_Vector ((0 => (279, 53, 3, False)));
Table.States (1036).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (1037), (74, 96), (326, 5), 3, null, null);
Table.States (1037).Kernel := To_Vector ((0 => (326, 279, 0, False)));
Table.States (1037).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 3)));
Add_Action (Table.States (1038), (74, 96), (326, 3), 3, null, null);
Table.States (1038).Kernel := To_Vector ((0 => (326, 279, 0, False)));
Table.States (1038).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 3)));
Add_Action (Table.States (1039), 104, 119);
Add_Action (Table.States (1039), 105, 33);
Add_Action (Table.States (1039), 106, 34);
Add_Error (Table.States (1039));
Add_Goto (Table.States (1039), 128, 41);
Add_Goto (Table.States (1039), 227, 1139);
Add_Goto (Table.States (1039), 239, 841);
Add_Goto (Table.States (1039), 272, 92);
Add_Goto (Table.States (1039), 293, 97);
Table.States (1039).Kernel := To_Vector ((0 => (228, 10, 1, False)));
Table.States (1039).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1040), 104, 119);
Add_Action (Table.States (1040), 105, 33);
Add_Action (Table.States (1040), 106, 34);
Add_Error (Table.States (1040));
Add_Goto (Table.States (1040), 128, 41);
Add_Goto (Table.States (1040), 227, 1140);
Add_Goto (Table.States (1040), 239, 841);
Add_Goto (Table.States (1040), 272, 92);
Add_Goto (Table.States (1040), 293, 97);
Table.States (1040).Kernel := To_Vector ((0 => (228, 10, 1, False)));
Table.States (1040).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1041), 3, 121);
Add_Action (Table.States (1041), 39, 122);
Add_Action (Table.States (1041), 40, 123);
Add_Action (Table.States (1041), 41, 124);
Add_Action (Table.States (1041), 76, 126);
Add_Action (Table.States (1041), 94, 127);
Add_Action (Table.States (1041), 95, 128);
Add_Action (Table.States (1041), 103, 129);
Add_Action (Table.States (1041), 104, 119);
Add_Action (Table.States (1041), 105, 33);
Add_Action (Table.States (1041), 106, 34);
Add_Error (Table.States (1041));
Add_Goto (Table.States (1041), 117, 130);
Add_Goto (Table.States (1041), 128, 41);
Add_Goto (Table.States (1041), 197, 133);
Add_Goto (Table.States (1041), 239, 134);
Add_Goto (Table.States (1041), 258, 135);
Add_Goto (Table.States (1041), 272, 92);
Add_Goto (Table.States (1041), 293, 97);
Add_Goto (Table.States (1041), 301, 1141);
Add_Goto (Table.States (1041), 320, 144);
Add_Goto (Table.States (1041), 321, 145);
Add_Goto (Table.States (1041), 330, 146);
Table.States (1041).Kernel := To_Vector ((0 => (326, 85, 1, False)));
Table.States (1041).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (1042), (1 => 35), (163, 0), 1, null, null);
Table.States (1042).Kernel := To_Vector ((0 => (163, 104, 0, False)));
Table.States (1042).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 163, 1)));
Add_Action (Table.States (1043), (1 => 35), (163, 1), 1, null, null);
Table.States (1043).Kernel := To_Vector ((0 => (163, 105, 0, False)));
Table.States (1043).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 163, 1)));
Add_Action (Table.States (1044), (1 => 35), (164, 0), 1, null, null);
Table.States (1044).Kernel := To_Vector ((0 => (164, 163, 0, False)));
Table.States (1044).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 164, 1)));
Add_Action (Table.States (1045), 35, 1142);
Add_Error (Table.States (1045));
Table.States (1045).Kernel := To_Vector ((0 => (327, 164, 6, False)));
Table.States (1045).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 1142)));
Add_Action (Table.States (1046), (15, 24, 28, 72, 104), (149, 4), 2, component_list_4'Access, null);
Table.States (1046).Kernel := To_Vector ((0 => (149, 96, 0, False)));
Table.States (1046).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 149, 2)));
Add_Action (Table.States (1047), (15, 24, 28, 72, 104), (149, 0), 2, null, null);
Table.States (1047).Kernel := To_Vector ((0 => (149, 148, 0, True)));
Table.States (1047).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 149, 2)));
Table.States (1047).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1048), (15, 24, 28, 72, 104), (149, 1), 2, null, null);
Table.States (1048).Kernel := To_Vector ((0 => (149, 327, 0, True)));
Table.States (1048).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 149, 2)));
Table.States (1048).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1049), 54, 1143);
Add_Error (Table.States (1049));
Table.States (1049).Kernel := To_Vector ((0 => (280, 24, 1, False)));
Table.States (1049).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 54, 1143)));
Add_Action (Table.States (1050), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (1050), 8, 1144);
Add_Action (Table.States (1050), 40, 742);
Add_Action (Table.States (1050), 104, 119);
Add_Action (Table.States (1050), 105, 33);
Add_Action (Table.States (1050), 106, 34);
Add_Error (Table.States (1050));
Add_Goto (Table.States (1050), 114, 1145);
Add_Goto (Table.States (1050), 128, 41);
Add_Goto (Table.States (1050), 147, 1146);
Add_Goto (Table.States (1050), 239, 484);
Add_Goto (Table.States (1050), 241, 721);
Add_Goto (Table.States (1050), 272, 92);
Add_Goto (Table.States (1050), 293, 97);
Add_Goto (Table.States (1050), 314, 1147);
Table.States (1050).Kernel := To_Vector (((146, 81, 3, False), (146, 81, 2, False)));
Table.States (1050).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1051), 104, 119);
Add_Action (Table.States (1051), 105, 33);
Add_Action (Table.States (1051), 106, 34);
Add_Error (Table.States (1051));
Add_Goto (Table.States (1051), 128, 41);
Add_Goto (Table.States (1051), 227, 1148);
Add_Goto (Table.States (1051), 239, 841);
Add_Goto (Table.States (1051), 272, 92);
Add_Goto (Table.States (1051), 293, 97);
Table.States (1051).Kernel := To_Vector ((0 => (228, 10, 1, False)));
Table.States (1051).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1052), 104, 119);
Add_Action (Table.States (1052), 105, 33);
Add_Action (Table.States (1052), 106, 34);
Add_Error (Table.States (1052));
Add_Goto (Table.States (1052), 128, 41);
Add_Goto (Table.States (1052), 227, 1149);
Add_Goto (Table.States (1052), 239, 841);
Add_Goto (Table.States (1052), 272, 92);
Add_Goto (Table.States (1052), 293, 97);
Table.States (1052).Kernel := To_Vector ((0 => (228, 10, 1, False)));
Table.States (1052).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1053), (74, 96), (183, 0), 3, enumeration_type_definition_0'Access, null);
Table.States (1053).Kernel := To_Vector ((0 => (183, 77, 0, False)));
Table.States (1053).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 183, 3)));
Add_Action (Table.States (1054), 104, 898);
Add_Action (Table.States (1054), 106, 899);
Add_Error (Table.States (1054));
Add_Goto (Table.States (1054), 180, 1150);
Table.States (1054).Kernel := To_Vector ((0 => (181, 83, 1, True)));
Table.States (1054).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 898)));
Table.States (1054).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1055), 10, 1151);
Add_Action (Table.States (1055), 74, Reduce, (119, 1), 0, null, null);
Add_Error (Table.States (1055));
Add_Goto (Table.States (1055), 119, 1152);
Table.States (1055).Kernel := To_Vector ((0 => (259, 314, 3, False)));
Table.States (1055).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 119, 0)));
Add_Action (Table.States (1056), 10, 1151);
Add_Action (Table.States (1056), 53, 618);
Add_Action (Table.States (1056), 74, Reduce, (119, 1), 0, null, null);
Add_Conflict (Table.States (1056), 74, (156, 1), 0, null, null);
Add_Action (Table.States (1056), 76, 619);
Add_Action (Table.States (1056), 84, 237);
Add_Action (Table.States (1056), 96, Reduce, (156, 1), 0, null, null);
Add_Action (Table.States (1056), 101, 239);
Add_Action (Table.States (1056), 102, 240);
Add_Error (Table.States (1056));
Add_Goto (Table.States (1056), 115, 241);
Add_Goto (Table.States (1056), 119, 1153);
Add_Goto (Table.States (1056), 155, 1154);
Add_Goto (Table.States (1056), 156, 1155);
Add_Goto (Table.States (1056), 224, 621);
Add_Goto (Table.States (1056), 322, 242);
Table.States (1056).Kernel := To_Vector (((128, 239, 2, True), (162, 239, 3, False), (162, 239, 0, False),
(239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (1056).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 156, 0)));
Add_Action (Table.States (1057), 96, 1156);
Add_Error (Table.States (1057));
Table.States (1057).Kernel := To_Vector ((0 => (260, 122, 1, False)));
Table.States (1057).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1156)));
Add_Action (Table.States (1058), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (206, 0), 7,
full_type_declaration_0'Access, null);
Table.States (1058).Kernel := To_Vector ((0 => (206, 96, 0, False)));
Table.States (1058).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 206, 7)));
Add_Action (Table.States (1059), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (245, 2), 7,
object_renaming_declaration_2'Access, null);
Table.States (1059).Kernel := To_Vector ((0 => (245, 96, 0, False)));
Table.States (1059).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 245, 7)));
Add_Action (Table.States (1060), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (245, 1), 7,
object_renaming_declaration_1'Access, null);
Table.States (1060).Kernel := To_Vector ((0 => (245, 96, 0, False)));
Table.States (1060).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 245, 7)));
Add_Action (Table.States (1061), (21, 35, 56, 74, 77, 82, 96), (114, 1), 5, access_definition_1'Access,
null);
Table.States (1061).Kernel := To_Vector ((0 => (114, 252, 0, True)));
Table.States (1061).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 114, 5)));
Table.States (1061).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1062), (21, 35, 56, 74, 77, 82, 96), (114, 0), 5, access_definition_0'Access,
null);
Table.States (1062).Kernel := To_Vector ((0 => (114, 253, 0, False)));
Table.States (1062).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 114, 5)));
Add_Action (Table.States (1063), 96, 1157);
Add_Error (Table.States (1063));
Table.States (1063).Kernel := To_Vector ((0 => (245, 122, 1, False)));
Table.States (1063).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1157)));
Add_Action (Table.States (1064), 44, 914);
Add_Action (Table.States (1064), 104, 119);
Add_Action (Table.States (1064), 105, 33);
Add_Action (Table.States (1064), 106, 34);
Add_Error (Table.States (1064));
Add_Goto (Table.States (1064), 128, 41);
Add_Goto (Table.States (1064), 184, 916);
Add_Goto (Table.States (1064), 185, 1158);
Add_Goto (Table.States (1064), 239, 918);
Add_Goto (Table.States (1064), 272, 92);
Add_Goto (Table.States (1064), 293, 97);
Table.States (1064).Kernel := To_Vector ((0 => (187, 81, 2, False)));
Table.States (1064).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1065), 44, 914);
Add_Action (Table.States (1065), 104, 119);
Add_Action (Table.States (1065), 105, 33);
Add_Action (Table.States (1065), 106, 34);
Add_Error (Table.States (1065));
Add_Goto (Table.States (1065), 128, 41);
Add_Goto (Table.States (1065), 184, 1159);
Add_Goto (Table.States (1065), 239, 918);
Add_Goto (Table.States (1065), 272, 92);
Add_Goto (Table.States (1065), 293, 97);
Table.States (1065).Kernel := To_Vector ((0 => (185, 79, 1, True)));
Table.States (1065).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Table.States (1065).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1066), 4, 1);
Add_Action (Table.States (1066), 5, 2);
Add_Action (Table.States (1066), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1066), 15, 3);
Add_Action (Table.States (1066), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1066), 18, 4);
Add_Action (Table.States (1066), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1066), 27, 5);
Add_Action (Table.States (1066), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1066), 31, 9);
Add_Action (Table.States (1066), 32, 10);
Add_Action (Table.States (1066), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1066), 41, 13);
Add_Action (Table.States (1066), 48, 16);
Add_Action (Table.States (1066), 52, 20);
Add_Action (Table.States (1066), 57, 21);
Add_Action (Table.States (1066), 58, 22);
Add_Action (Table.States (1066), 61, 24);
Add_Action (Table.States (1066), 72, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1066), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1066), 93, 31);
Add_Action (Table.States (1066), 104, 360);
Add_Action (Table.States (1066), 105, 33);
Add_Action (Table.States (1066), 106, 34);
Add_Error (Table.States (1066));
Add_Goto (Table.States (1066), 113, 36);
Add_Goto (Table.States (1066), 123, 38);
Add_Goto (Table.States (1066), 126, 39);
Add_Goto (Table.States (1066), 128, 41);
Add_Goto (Table.States (1066), 131, 42);
Add_Goto (Table.States (1066), 132, 43);
Add_Goto (Table.States (1066), 133, 44);
Add_Goto (Table.States (1066), 139, 47);
Add_Goto (Table.States (1066), 151, 50);
Add_Goto (Table.States (1066), 152, 51);
Add_Goto (Table.States (1066), 161, 53);
Add_Goto (Table.States (1066), 190, 57);
Add_Goto (Table.States (1066), 196, 59);
Add_Goto (Table.States (1066), 217, 68);
Add_Goto (Table.States (1066), 222, 70);
Add_Goto (Table.States (1066), 232, 72);
Add_Goto (Table.States (1066), 239, 73);
Add_Goto (Table.States (1066), 257, 83);
Add_Goto (Table.States (1066), 261, 86);
Add_Goto (Table.States (1066), 272, 92);
Add_Goto (Table.States (1066), 276, 93);
Add_Goto (Table.States (1066), 290, 96);
Add_Goto (Table.States (1066), 293, 97);
Add_Goto (Table.States (1066), 294, 98);
Add_Goto (Table.States (1066), 298, 99);
Add_Goto (Table.States (1066), 299, 361);
Add_Goto (Table.States (1066), 300, 1160);
Add_Goto (Table.States (1066), 302, 100);
Add_Goto (Table.States (1066), 303, 101);
Add_Goto (Table.States (1066), 306, 363);
Add_Goto (Table.States (1066), 323, 114);
Table.States (1066).Kernel := To_Vector ((0 => (187, 87, 0, False)));
Table.States (1066).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (1067), 96, 1161);
Add_Error (Table.States (1067));
Table.States (1067).Kernel := To_Vector ((0 => (133, 220, 1, False)));
Table.States (1067).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1161)));
Add_Action (Table.States (1068), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (232, 1), 7, loop_statement_1'Access, loop_statement_1_check'Access);
Table.States (1068).Kernel := To_Vector ((0 => (232, 96, 0, False)));
Table.States (1068).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 232, 7)));
Add_Action (Table.States (1069), 96, 1162);
Add_Error (Table.States (1069));
Table.States (1069).Kernel := To_Vector ((0 => (232, 220, 1, False)));
Table.States (1069).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1162)));
Add_Action (Table.States (1070), 74, 337);
Add_Action (Table.States (1070), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1070));
Add_Goto (Table.States (1070), 122, 1163);
Table.States (1070).Kernel := To_Vector ((0 => (244, 192, 1, False)));
Table.States (1070).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1071), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 4), 7,
object_declaration_4'Access, null);
Table.States (1071).Kernel := To_Vector ((0 => (244, 96, 0, False)));
Table.States (1071).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 7)));
Add_Action (Table.States (1072), 74, 337);
Add_Action (Table.States (1072), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1072));
Add_Goto (Table.States (1072), 122, 1164);
Table.States (1072).Kernel := To_Vector ((0 => (244, 192, 1, False)));
Table.States (1072).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1073), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 5), 7,
object_declaration_5'Access, null);
Table.States (1073).Kernel := To_Vector ((0 => (244, 96, 0, False)));
Table.States (1073).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 7)));
Add_Action (Table.States (1074), 74, 337);
Add_Action (Table.States (1074), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1074));
Add_Goto (Table.States (1074), 122, 1165);
Table.States (1074).Kernel := To_Vector ((0 => (244, 192, 1, False)));
Table.States (1074).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1075), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 3), 7,
object_declaration_3'Access, null);
Table.States (1075).Kernel := To_Vector ((0 => (244, 96, 0, False)));
Table.States (1075).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 7)));
Add_Action (Table.States (1076), 74, 337);
Add_Action (Table.States (1076), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1076));
Add_Goto (Table.States (1076), 122, 1166);
Table.States (1076).Kernel := To_Vector ((0 => (179, 253, 1, False)));
Table.States (1076).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1077), 96, 1167);
Add_Error (Table.States (1077));
Table.States (1077).Kernel := To_Vector ((0 => (213, 122, 1, False)));
Table.States (1077).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1167)));
Add_Action (Table.States (1078), 96, 1168);
Add_Error (Table.States (1078));
Table.States (1078).Kernel := To_Vector ((0 => (213, 122, 1, False)));
Table.States (1078).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1168)));
Add_Action (Table.States (1079), 24, 1169);
Add_Error (Table.States (1079));
Table.States (1079).Kernel := To_Vector ((0 => (307, 218, 2, False)));
Table.States (1079).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1169)));
Add_Action (Table.States (1080), 96, 1170);
Add_Error (Table.States (1080));
Table.States (1080).Kernel := To_Vector ((0 => (113, 220, 1, False)));
Table.States (1080).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1170)));
Add_Action (Table.States (1081), 3, 121);
Add_Action (Table.States (1081), 39, 122);
Add_Action (Table.States (1081), 40, 123);
Add_Action (Table.States (1081), 41, 124);
Add_Action (Table.States (1081), 52, 125);
Add_Action (Table.States (1081), 76, 126);
Add_Action (Table.States (1081), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1081), 83, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1081), 94, 127);
Add_Action (Table.States (1081), 95, 128);
Add_Action (Table.States (1081), 103, 129);
Add_Action (Table.States (1081), 104, 119);
Add_Action (Table.States (1081), 105, 33);
Add_Action (Table.States (1081), 106, 34);
Add_Error (Table.States (1081));
Add_Goto (Table.States (1081), 117, 130);
Add_Goto (Table.States (1081), 128, 41);
Add_Goto (Table.States (1081), 191, 131);
Add_Goto (Table.States (1081), 192, 1171);
Add_Goto (Table.States (1081), 197, 133);
Add_Goto (Table.States (1081), 239, 134);
Add_Goto (Table.States (1081), 258, 135);
Add_Goto (Table.States (1081), 272, 92);
Add_Goto (Table.States (1081), 275, 136);
Add_Goto (Table.States (1081), 282, 137);
Add_Goto (Table.States (1081), 283, 138);
Add_Goto (Table.States (1081), 284, 139);
Add_Goto (Table.States (1081), 285, 140);
Add_Goto (Table.States (1081), 286, 141);
Add_Goto (Table.States (1081), 287, 142);
Add_Goto (Table.States (1081), 293, 97);
Add_Goto (Table.States (1081), 301, 143);
Add_Goto (Table.States (1081), 320, 144);
Add_Goto (Table.States (1081), 321, 145);
Add_Goto (Table.States (1081), 330, 146);
Table.States (1081).Kernel := To_Vector ((0 => (137, 87, 0, False)));
Table.States (1081).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1082), (77, 83), (138, 0), 3, case_expression_alternative_list_0'Access, null);
Table.States (1082).Kernel := To_Vector ((0 => (138, 137, 0, True)));
Table.States (1082).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 138, 3)));
Table.States (1082).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1083), (1 => 77), (221, 1), 6, if_expression_1'Access, null);
Table.States (1083).Kernel := To_Vector ((0 => (221, 192, 0, False)));
Table.States (1083).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 221, 6)));
Add_Action (Table.States (1084), 68, 1172);
Add_Error (Table.States (1084));
Table.States (1084).Kernel := To_Vector ((0 => (172, 192, 1, False)));
Table.States (1084).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 68, 1172)));
Add_Action (Table.States (1085), 3, 121);
Add_Action (Table.States (1085), 39, 122);
Add_Action (Table.States (1085), 40, 123);
Add_Action (Table.States (1085), 41, 124);
Add_Action (Table.States (1085), 52, 125);
Add_Action (Table.States (1085), 76, 126);
Add_Action (Table.States (1085), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1085), 94, 127);
Add_Action (Table.States (1085), 95, 128);
Add_Action (Table.States (1085), 103, 129);
Add_Action (Table.States (1085), 104, 119);
Add_Action (Table.States (1085), 105, 33);
Add_Action (Table.States (1085), 106, 34);
Add_Error (Table.States (1085));
Add_Goto (Table.States (1085), 117, 130);
Add_Goto (Table.States (1085), 128, 41);
Add_Goto (Table.States (1085), 191, 131);
Add_Goto (Table.States (1085), 192, 1173);
Add_Goto (Table.States (1085), 197, 133);
Add_Goto (Table.States (1085), 239, 134);
Add_Goto (Table.States (1085), 258, 135);
Add_Goto (Table.States (1085), 272, 92);
Add_Goto (Table.States (1085), 275, 136);
Add_Goto (Table.States (1085), 282, 137);
Add_Goto (Table.States (1085), 283, 138);
Add_Goto (Table.States (1085), 284, 139);
Add_Goto (Table.States (1085), 285, 140);
Add_Goto (Table.States (1085), 286, 141);
Add_Goto (Table.States (1085), 287, 142);
Add_Goto (Table.States (1085), 293, 97);
Add_Goto (Table.States (1085), 301, 143);
Add_Goto (Table.States (1085), 320, 144);
Add_Goto (Table.States (1085), 321, 145);
Add_Goto (Table.States (1085), 330, 146);
Table.States (1085).Kernel := To_Vector ((0 => (221, 22, 0, False)));
Table.States (1085).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1086), (22, 23, 77), (173, 0), 2, null, null);
Table.States (1086).Kernel := To_Vector ((0 => (173, 172, 0, True)));
Table.States (1086).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 173, 2)));
Table.States (1086).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1087), (10, 20, 21, 22, 23, 35, 37, 42, 43, 53, 68, 74, 75, 77, 79, 82, 83, 87,
96), (277, 0), 6, range_g_0'Access, null);
Table.States (1087).Kernel := To_Vector ((0 => (277, 77, 0, False)));
Table.States (1087).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 277, 6)));
Add_Action (Table.States (1088), 53, 618);
Add_Action (Table.States (1088), 76, 619);
Add_Action (Table.States (1088), 77, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (1088), 79, Reduce, (165, 1), 3, null, null);
Add_Action (Table.States (1088), 83, Reduce, (314, 1), 3, subtype_indication_1'Access, null);
Add_Action (Table.States (1088), 84, 237);
Add_Action (Table.States (1088), 87, Reduce, (165, 1), 3, null, null);
Add_Action (Table.States (1088), 101, 239);
Add_Action (Table.States (1088), 102, 240);
Add_Error (Table.States (1088));
Add_Goto (Table.States (1088), 115, 241);
Add_Goto (Table.States (1088), 155, 956);
Add_Goto (Table.States (1088), 224, 621);
Add_Goto (Table.States (1088), 322, 242);
Table.States (1088).Kernel := To_Vector (((128, 239, 2, True), (165, 239, 0, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (314, 239, 4, False), (314, 239, 0, False)));
Table.States (1088).Minimal_Complete_Actions := To_Vector (((Reduce, 165, 3), (Reduce, 314, 3)));
Add_Action (Table.States (1089), (77, 83), (168, 0), 3, null, null);
Table.States (1089).Kernel := To_Vector ((0 => (168, 167, 0, True)));
Table.States (1089).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 168, 3)));
Table.States (1089).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1090), (1 => 104), (235, 0), 4, null, null);
Table.States (1090).Kernel := To_Vector ((0 => (235, 96, 0, False)));
Table.States (1090).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 235, 4)));
Add_Action (Table.States (1091), 53, 1174);
Add_Error (Table.States (1091));
Table.States (1091).Kernel := To_Vector ((0 => (144, 301, 5, False)));
Table.States (1091).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 53, 1174)));
Add_Action (Table.States (1092), 96, 1175);
Add_Error (Table.States (1092));
Table.States (1092).Kernel := To_Vector ((0 => (281, 54, 1, False)));
Table.States (1092).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1175)));
Add_Action (Table.States (1093), 3, 121);
Add_Action (Table.States (1093), 39, 122);
Add_Action (Table.States (1093), 40, 123);
Add_Action (Table.States (1093), 41, 124);
Add_Action (Table.States (1093), 52, 125);
Add_Action (Table.States (1093), 76, 126);
Add_Action (Table.States (1093), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1093), 94, 127);
Add_Action (Table.States (1093), 95, 128);
Add_Action (Table.States (1093), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1093), 103, 129);
Add_Action (Table.States (1093), 104, 119);
Add_Action (Table.States (1093), 105, 33);
Add_Action (Table.States (1093), 106, 34);
Add_Error (Table.States (1093));
Add_Goto (Table.States (1093), 117, 130);
Add_Goto (Table.States (1093), 128, 41);
Add_Goto (Table.States (1093), 191, 131);
Add_Goto (Table.States (1093), 192, 1176);
Add_Goto (Table.States (1093), 197, 133);
Add_Goto (Table.States (1093), 239, 134);
Add_Goto (Table.States (1093), 258, 135);
Add_Goto (Table.States (1093), 272, 92);
Add_Goto (Table.States (1093), 275, 136);
Add_Goto (Table.States (1093), 282, 137);
Add_Goto (Table.States (1093), 283, 138);
Add_Goto (Table.States (1093), 284, 139);
Add_Goto (Table.States (1093), 285, 140);
Add_Goto (Table.States (1093), 286, 141);
Add_Goto (Table.States (1093), 287, 142);
Add_Goto (Table.States (1093), 293, 97);
Add_Goto (Table.States (1093), 301, 143);
Add_Goto (Table.States (1093), 320, 144);
Add_Goto (Table.States (1093), 321, 145);
Add_Goto (Table.States (1093), 330, 146);
Table.States (1093).Kernel := To_Vector ((0 => (254, 82, 0, False)));
Table.States (1093).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1094), 104, 119);
Add_Action (Table.States (1094), 105, 33);
Add_Action (Table.States (1094), 106, 34);
Add_Error (Table.States (1094));
Add_Goto (Table.States (1094), 128, 41);
Add_Goto (Table.States (1094), 239, 1177);
Add_Goto (Table.States (1094), 272, 92);
Add_Goto (Table.States (1094), 293, 97);
Table.States (1094).Kernel := To_Vector (((254, 241, 2, False), (254, 241, 1, False)));
Table.States (1094).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
end Subr_18;
procedure Subr_19
is begin
Add_Action (Table.States (1095), 80, 1178);
Add_Error (Table.States (1095));
Table.States (1095).Kernel := To_Vector ((0 => (202, 20, 1, False)));
Table.States (1095).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 1178)));
Add_Action (Table.States (1096), (29, 47, 48, 50, 69, 71, 74, 104), (201, 1), 7,
formal_type_declaration_1'Access, null);
Table.States (1096).Kernel := To_Vector ((0 => (201, 96, 0, False)));
Table.States (1096).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 201, 7)));
Add_Action (Table.States (1097), (74, 96), (202, 2), 3, null, null);
Table.States (1097).Kernel := To_Vector ((0 => (202, 77, 0, False)));
Table.States (1097).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 3)));
Add_Action (Table.States (1098), 10, 1151);
Add_Action (Table.States (1098), 74, Reduce, (119, 1), 0, null, null);
Add_Action (Table.States (1098), 76, 235);
Add_Action (Table.States (1098), 84, 237);
Add_Action (Table.States (1098), 96, Reduce, (119, 1), 0, null, null);
Add_Action (Table.States (1098), 101, 239);
Add_Action (Table.States (1098), 102, 240);
Add_Error (Table.States (1098));
Add_Goto (Table.States (1098), 115, 241);
Add_Goto (Table.States (1098), 119, 1179);
Add_Goto (Table.States (1098), 322, 242);
Table.States (1098).Kernel := To_Vector (((128, 239, 2, True), (203, 239, 2, False), (203, 239, 0, False),
(239, 239, 5, True), (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (1098).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 119, 0)));
Add_Action (Table.States (1099), (29, 47, 48, 50, 69, 71, 74, 104), (201, 0), 7,
formal_type_declaration_0'Access, null);
Table.States (1099).Kernel := To_Vector ((0 => (201, 96, 0, False)));
Table.States (1099).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 201, 7)));
Add_Action (Table.States (1100), 3, 121);
Add_Action (Table.States (1100), 15, 258);
Add_Action (Table.States (1100), 28, 259);
Add_Action (Table.States (1100), 32, 260);
Add_Action (Table.States (1100), 39, 122);
Add_Action (Table.States (1100), 40, 261);
Add_Action (Table.States (1100), 41, 124);
Add_Action (Table.States (1100), 44, 263);
Add_Action (Table.States (1100), 52, 125);
Add_Action (Table.States (1100), 76, 126);
Add_Action (Table.States (1100), 77, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (1100), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (1100), 80, 1180);
Add_Action (Table.States (1100), 83, Reduce, (124, 5), 0, null, null);
Add_Action (Table.States (1100), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (1100), 94, 127);
Add_Action (Table.States (1100), 95, 128);
Add_Action (Table.States (1100), 103, 129);
Add_Action (Table.States (1100), 104, 119);
Add_Action (Table.States (1100), 105, 33);
Add_Action (Table.States (1100), 106, 264);
Add_Error (Table.States (1100));
Add_Goto (Table.States (1100), 117, 130);
Add_Goto (Table.States (1100), 124, 265);
Add_Goto (Table.States (1100), 125, 406);
Add_Goto (Table.States (1100), 128, 41);
Add_Goto (Table.States (1100), 136, 267);
Add_Goto (Table.States (1100), 153, 407);
Add_Goto (Table.States (1100), 165, 269);
Add_Goto (Table.States (1100), 166, 270);
Add_Goto (Table.States (1100), 191, 408);
Add_Goto (Table.States (1100), 197, 133);
Add_Goto (Table.States (1100), 221, 273);
Add_Goto (Table.States (1100), 239, 274);
Add_Goto (Table.States (1100), 258, 135);
Add_Goto (Table.States (1100), 272, 92);
Add_Goto (Table.States (1100), 273, 275);
Add_Goto (Table.States (1100), 275, 136);
Add_Goto (Table.States (1100), 277, 409);
Add_Goto (Table.States (1100), 278, 410);
Add_Goto (Table.States (1100), 282, 137);
Add_Goto (Table.States (1100), 283, 138);
Add_Goto (Table.States (1100), 284, 139);
Add_Goto (Table.States (1100), 285, 140);
Add_Goto (Table.States (1100), 286, 141);
Add_Goto (Table.States (1100), 287, 142);
Add_Goto (Table.States (1100), 293, 97);
Add_Goto (Table.States (1100), 301, 277);
Add_Goto (Table.States (1100), 320, 144);
Add_Goto (Table.States (1100), 321, 145);
Add_Goto (Table.States (1100), 330, 146);
Table.States (1100).Kernel := To_Vector (((115, 76, 1, False), (115, 76, 3, False), (205, 76, 2, False),
(239, 76, 4, True)));
Table.States (1100).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 125, 0)));
Table.States (1100).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1101), 74, 337);
Add_Action (Table.States (1101), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1101));
Add_Goto (Table.States (1101), 122, 1181);
Table.States (1101).Kernel := To_Vector ((0 => (204, 205, 1, False)));
Table.States (1101).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1102), (29, 47, 48, 50, 69, 71, 74, 104), (200, 0), 7,
formal_subprogram_declaration_0'Access, null);
Table.States (1102).Kernel := To_Vector ((0 => (200, 96, 0, False)));
Table.States (1102).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 200, 7)));
Add_Action (Table.States (1103), 96, 1182);
Add_Error (Table.States (1103));
Table.States (1103).Kernel := To_Vector ((0 => (198, 122, 1, False)));
Table.States (1103).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1182)));
Add_Action (Table.States (1104), 74, 337);
Add_Action (Table.States (1104), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1104));
Add_Goto (Table.States (1104), 122, 1183);
Table.States (1104).Kernel := To_Vector ((0 => (198, 192, 1, False)));
Table.States (1104).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1105), (29, 47, 48, 50, 69, 71, 74, 104), (198, 2), 7,
formal_object_declaration_2'Access, null);
Table.States (1105).Kernel := To_Vector ((0 => (198, 96, 0, False)));
Table.States (1105).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 198, 7)));
Add_Action (Table.States (1106), 96, 1184);
Add_Error (Table.States (1106));
Table.States (1106).Kernel := To_Vector ((0 => (222, 32, 1, False)));
Table.States (1106).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1184)));
Add_Action (Table.States (1107), (22, 23, 24), (174, 0), 4, elsif_statement_item_0'Access, null);
Table.States (1107).Kernel := To_Vector ((0 => (174, 300, 0, False)));
Table.States (1107).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 174, 4)));
Add_Action (Table.States (1108), 32, 1185);
Add_Error (Table.States (1108));
Table.States (1108).Kernel := To_Vector ((0 => (222, 24, 2, False)));
Table.States (1108).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 32, 1185)));
Add_Action (Table.States (1109), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (222, 2), 8, if_statement_2'Access, null);
Table.States (1109).Kernel := To_Vector ((0 => (222, 96, 0, False)));
Table.States (1109).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 222, 8)));
Add_Action (Table.States (1110), 24, 1186);
Add_Error (Table.States (1110));
Table.States (1110).Kernel := To_Vector ((0 => (247, 218, 2, False)));
Table.States (1110).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1186)));
Add_Action (Table.States (1111), 96, 1187);
Add_Error (Table.States (1111));
Table.States (1111).Kernel := To_Vector ((0 => (247, 240, 1, False)));
Table.States (1111).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1187)));
Add_Action (Table.States (1112), 96, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (1112), 104, 119);
Add_Action (Table.States (1112), 105, 33);
Add_Action (Table.States (1112), 106, 34);
Add_Error (Table.States (1112));
Add_Goto (Table.States (1112), 128, 41);
Add_Goto (Table.States (1112), 239, 630);
Add_Goto (Table.States (1112), 240, 1188);
Add_Goto (Table.States (1112), 272, 92);
Add_Goto (Table.States (1112), 293, 97);
Table.States (1112).Kernel := To_Vector ((0 => (251, 24, 0, False)));
Table.States (1112).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 240, 0)));
Add_Action (Table.States (1113), 28, 1189);
Add_Action (Table.States (1113), 77, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (1113), 96, Reduce, (254, 4), 0, null, null);
Add_Action (Table.States (1113), 104, 164);
Add_Error (Table.States (1113));
Add_Goto (Table.States (1113), 219, 493);
Add_Goto (Table.States (1113), 254, 494);
Add_Goto (Table.States (1113), 255, 495);
Table.States (1113).Kernel := To_Vector (((177, 76, 5, False), (199, 76, 1, False)));
Table.States (1113).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 255, 0)));
Add_Action (Table.States (1114), 72, 1190);
Add_Error (Table.States (1114));
Table.States (1114).Kernel := To_Vector ((0 => (176, 177, 5, False)));
Table.States (1114).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 72, 1190)));
Add_Action (Table.States (1115), (1 => 72), (177, 1), 1, null, null);
Table.States (1115).Kernel := To_Vector ((0 => (177, 253, 0, False)));
Table.States (1115).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 177, 1)));
Add_Action (Table.States (1116), 96, 1191);
Add_Error (Table.States (1116));
Table.States (1116).Kernel := To_Vector ((0 => (264, 220, 1, False)));
Table.States (1116).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1191)));
Add_Action (Table.States (1117), 10, 1006);
Add_Action (Table.States (1117), 74, 1192);
Add_Error (Table.States (1117));
Table.States (1117).Kernel := To_Vector (((227, 227, 2, True), (271, 227, 3, False)));
Table.States (1117).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 1192)));
Add_Action (Table.States (1118), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (271, 1), 8,
protected_type_declaration_1'Access, protected_type_declaration_1_check'Access);
Table.States (1118).Kernel := To_Vector ((0 => (271, 96, 0, False)));
Table.States (1118).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 271, 8)));
Add_Action (Table.States (1119), 10, Reduce, (227, 0), 3, interface_list_0'Access, null);
Add_Action (Table.States (1119), 74, Reduce, (227, 0), 3, interface_list_0'Access, null);
Add_Action (Table.States (1119), 76, 235);
Add_Action (Table.States (1119), 84, 237);
Add_Action (Table.States (1119), 96, Reduce, (227, 0), 3, interface_list_0'Access, null);
Add_Action (Table.States (1119), 101, 239);
Add_Action (Table.States (1119), 102, 240);
Add_Error (Table.States (1119));
Add_Goto (Table.States (1119), 115, 241);
Add_Goto (Table.States (1119), 322, 242);
Table.States (1119).Kernel := To_Vector (((128, 239, 2, True), (227, 239, 0, True), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (1119).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 227, 3)));
Table.States (1119).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1120), 96, 1193);
Add_Error (Table.States (1120));
Table.States (1120).Kernel := To_Vector ((0 => (304, 266, 1, False)));
Table.States (1120).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1193)));
Add_Action (Table.States (1121), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (1121), 104, 149);
Add_Error (Table.States (1121));
Add_Goto (Table.States (1121), 220, 1194);
Table.States (1121).Kernel := To_Vector ((0 => (266, 24, 0, False)));
Table.States (1121).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (1122), (21, 96), (194, 0), 7, extended_return_object_declaration_0'Access, null);
Table.States (1122).Kernel := To_Vector ((0 => (194, 192, 0, False)));
Table.States (1122).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 194, 7)));
Add_Action (Table.States (1123), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (126, 0), 8, asynchronous_select_0'Access, null);
Table.States (1123).Kernel := To_Vector ((0 => (126, 96, 0, False)));
Table.States (1123).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 126, 8)));
Add_Action (Table.States (1124), 24, 1195);
Add_Error (Table.States (1124));
Table.States (1124).Kernel := To_Vector ((0 => (316, 218, 2, False)));
Table.States (1124).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1195)));
Add_Action (Table.States (1125), 10, 1006);
Add_Action (Table.States (1125), 74, 1196);
Add_Error (Table.States (1125));
Table.States (1125).Kernel := To_Vector (((227, 227, 2, True), (319, 227, 3, False)));
Table.States (1125).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 1196)));
Add_Action (Table.States (1126), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (1126), 104, 149);
Add_Error (Table.States (1126));
Add_Goto (Table.States (1126), 220, 1197);
Table.States (1126).Kernel := To_Vector ((0 => (319, 24, 1, False)));
Table.States (1126).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (1127), 24, 1198);
Add_Error (Table.States (1127));
Table.States (1127).Kernel := To_Vector ((0 => (305, 318, 2, False)));
Table.States (1127).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1198)));
Add_Action (Table.States (1128), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (305, 1), 8,
single_task_declaration_1'Access, single_task_declaration_1_check'Access);
Table.States (1128).Kernel := To_Vector ((0 => (305, 96, 0, False)));
Table.States (1128).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 305, 8)));
Add_Action (Table.States (1129), 76, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (1129), 77, Reduce, (242, 2), 3, null_exclusion_opt_name_type_2'Access, null);
Add_Action (Table.States (1129), 82, Reduce, (242, 2), 3, null_exclusion_opt_name_type_2'Access, null);
Add_Action (Table.States (1129), 84, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (1129), 96, Reduce, (242, 2), 3, null_exclusion_opt_name_type_2'Access, null);
Add_Action (Table.States (1129), 101, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Action (Table.States (1129), 102, Reduce, (239, 5), 1, name_5'Access, name_5_check'Access);
Add_Error (Table.States (1129));
Table.States (1129).Kernel := To_Vector (((239, 104, 0, False), (242, 104, 0, False)));
Table.States (1129).Minimal_Complete_Actions := To_Vector (((Reduce, 239, 1), (Reduce, 242, 3)));
Add_Action (Table.States (1130), 76, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Action (Table.States (1130), 77, Reduce, (242, 3), 3, null_exclusion_opt_name_type_3'Access, null);
Add_Action (Table.States (1130), 82, Reduce, (242, 3), 3, null_exclusion_opt_name_type_3'Access, null);
Add_Action (Table.States (1130), 84, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Action (Table.States (1130), 96, Reduce, (242, 3), 3, null_exclusion_opt_name_type_3'Access, null);
Add_Action (Table.States (1130), 101, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Action (Table.States (1130), 102, Reduce, (239, 2), 1, null, name_2_check'Access);
Add_Error (Table.States (1130));
Table.States (1130).Kernel := To_Vector (((239, 293, 0, True), (242, 293, 0, False)));
Table.States (1130).Minimal_Complete_Actions := To_Vector (((Reduce, 239, 1), (Reduce, 242, 3)));
Table.States (1130).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1131), (77, 96), (170, 1), 5, null, null);
Table.States (1131).Kernel := To_Vector ((0 => (170, 192, 0, False)));
Table.States (1131).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 170, 5)));
Add_Action (Table.States (1132), (77, 96), (170, 0), 5, null, null);
Table.States (1132).Kernel := To_Vector ((0 => (170, 192, 0, False)));
Table.States (1132).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 170, 5)));
Add_Action (Table.States (1133), 42, 1199);
Add_Error (Table.States (1133));
Table.States (1133).Kernel := To_Vector ((0 => (120, 77, 2, False)));
Table.States (1133).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 42, 1199)));
Add_Action (Table.States (1134), 42, 1200);
Add_Error (Table.States (1134));
Table.States (1134).Kernel := To_Vector ((0 => (120, 77, 2, False)));
Table.States (1134).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 42, 1200)));
Add_Action (Table.States (1135), 104, 119);
Add_Action (Table.States (1135), 105, 33);
Add_Action (Table.States (1135), 106, 34);
Add_Error (Table.States (1135));
Add_Goto (Table.States (1135), 128, 41);
Add_Goto (Table.States (1135), 225, 1201);
Add_Goto (Table.States (1135), 239, 1202);
Add_Goto (Table.States (1135), 272, 92);
Add_Goto (Table.States (1135), 293, 97);
Table.States (1135).Kernel := To_Vector ((0 => (226, 83, 3, True)));
Table.States (1135).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Table.States (1135).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1136), 3, 121);
Add_Action (Table.States (1136), 39, 122);
Add_Action (Table.States (1136), 40, 123);
Add_Action (Table.States (1136), 41, 124);
Add_Action (Table.States (1136), 76, 126);
Add_Action (Table.States (1136), 80, 1203);
Add_Action (Table.States (1136), 94, 127);
Add_Action (Table.States (1136), 95, 128);
Add_Action (Table.States (1136), 103, 129);
Add_Action (Table.States (1136), 104, 119);
Add_Action (Table.States (1136), 105, 33);
Add_Action (Table.States (1136), 106, 34);
Add_Error (Table.States (1136));
Add_Goto (Table.States (1136), 117, 130);
Add_Goto (Table.States (1136), 128, 41);
Add_Goto (Table.States (1136), 197, 133);
Add_Goto (Table.States (1136), 239, 274);
Add_Goto (Table.States (1136), 258, 135);
Add_Goto (Table.States (1136), 272, 92);
Add_Goto (Table.States (1136), 277, 773);
Add_Goto (Table.States (1136), 293, 97);
Add_Goto (Table.States (1136), 301, 479);
Add_Goto (Table.States (1136), 320, 144);
Add_Goto (Table.States (1136), 321, 145);
Add_Goto (Table.States (1136), 330, 146);
Table.States (1136).Kernel := To_Vector (((155, 53, 3, False), (225, 53, 1, False)));
Table.States (1136).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 1203)));
Add_Action (Table.States (1137), 53, 1036);
Add_Action (Table.States (1137), 74, Reduce, (279, 1), 0, null, null);
Add_Action (Table.States (1137), 96, Reduce, (279, 1), 0, null, null);
Add_Error (Table.States (1137));
Add_Goto (Table.States (1137), 279, 1204);
Table.States (1137).Kernel := To_Vector ((0 => (326, 192, 0, False)));
Table.States (1137).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 279, 0)));
Add_Action (Table.States (1138), 85, 1205);
Add_Error (Table.States (1138));
Table.States (1138).Kernel := To_Vector ((0 => (279, 301, 2, False)));
Table.States (1138).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 85, 1205)));
Add_Action (Table.States (1139), 10, 1006);
Add_Action (Table.States (1139), 74, Reduce, (228, 0), 4, null, null);
Add_Action (Table.States (1139), 96, Reduce, (228, 0), 4, null, null);
Add_Error (Table.States (1139));
Table.States (1139).Kernel := To_Vector (((227, 227, 2, True), (228, 227, 0, False)));
Table.States (1139).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 4)));
Add_Action (Table.States (1140), 10, 1006);
Add_Action (Table.States (1140), 74, Reduce, (228, 2), 4, null, null);
Add_Action (Table.States (1140), 96, Reduce, (228, 2), 4, null, null);
Add_Error (Table.States (1140));
Table.States (1140).Kernel := To_Vector (((227, 227, 2, True), (228, 227, 0, False)));
Table.States (1140).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 4)));
Add_Action (Table.States (1141), (74, 96), (326, 1), 4, null, null);
Table.States (1141).Kernel := To_Vector ((0 => (326, 301, 0, False)));
Table.States (1141).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 4)));
Add_Action (Table.States (1142), 72, 1206);
Add_Error (Table.States (1142));
Add_Goto (Table.States (1142), 328, 1207);
Add_Goto (Table.States (1142), 329, 1208);
Table.States (1142).Kernel := To_Vector ((0 => (327, 35, 5, False)));
Table.States (1142).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 72, 1206)));
Add_Action (Table.States (1143), (74, 96), (280, 0), 4, record_definition_0'Access, null);
Table.States (1143).Kernel := To_Vector ((0 => (280, 54, 0, False)));
Table.States (1143).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 280, 4)));
Add_Action (Table.States (1144), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (1144), 40, 742);
Add_Action (Table.States (1144), 104, 119);
Add_Action (Table.States (1144), 105, 33);
Add_Action (Table.States (1144), 106, 34);
Add_Error (Table.States (1144));
Add_Goto (Table.States (1144), 114, 1209);
Add_Goto (Table.States (1144), 128, 41);
Add_Goto (Table.States (1144), 239, 484);
Add_Goto (Table.States (1144), 241, 721);
Add_Goto (Table.States (1144), 272, 92);
Add_Goto (Table.States (1144), 293, 97);
Add_Goto (Table.States (1144), 314, 1210);
Table.States (1144).Kernel := To_Vector (((147, 8, 1, False), (147, 8, 2, False)));
Table.States (1144).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1145), (74, 82, 96), (147, 3), 1, null, null);
Table.States (1145).Kernel := To_Vector ((0 => (147, 114, 0, False)));
Table.States (1145).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 147, 1)));
Add_Action (Table.States (1146), 74, 337);
Add_Action (Table.States (1146), 82, 1211);
Add_Action (Table.States (1146), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1146));
Add_Goto (Table.States (1146), 122, 1212);
Table.States (1146).Kernel := To_Vector (((146, 147, 2, False), (146, 147, 1, False)));
Table.States (1146).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1147), (74, 82, 96), (147, 1), 1, null, null);
Table.States (1147).Kernel := To_Vector ((0 => (147, 314, 0, False)));
Table.States (1147).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 147, 1)));
Add_Action (Table.States (1148), 10, 1006);
Add_Action (Table.States (1148), 74, Reduce, (228, 3), 4, null, null);
Add_Action (Table.States (1148), 96, Reduce, (228, 3), 4, null, null);
Add_Error (Table.States (1148));
Table.States (1148).Kernel := To_Vector (((227, 227, 2, True), (228, 227, 0, False)));
Table.States (1148).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 4)));
Add_Action (Table.States (1149), 10, 1006);
Add_Action (Table.States (1149), 74, Reduce, (228, 1), 4, null, null);
Add_Action (Table.States (1149), 96, Reduce, (228, 1), 4, null, null);
Add_Error (Table.States (1149));
Table.States (1149).Kernel := To_Vector (((227, 227, 2, True), (228, 227, 0, False)));
Table.States (1149).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 228, 4)));
Add_Action (Table.States (1150), (77, 83), (181, 0), 3, null, null);
Table.States (1150).Kernel := To_Vector ((0 => (181, 180, 0, True)));
Table.States (1150).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 181, 3)));
Table.States (1150).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1151), 104, 119);
Add_Action (Table.States (1151), 105, 33);
Add_Action (Table.States (1151), 106, 34);
Add_Error (Table.States (1151));
Add_Goto (Table.States (1151), 128, 41);
Add_Goto (Table.States (1151), 227, 1213);
Add_Goto (Table.States (1151), 239, 841);
Add_Goto (Table.States (1151), 272, 92);
Add_Goto (Table.States (1151), 293, 97);
Table.States (1151).Kernel := To_Vector ((0 => (119, 10, 1, False)));
Table.States (1151).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1152), 74, 1214);
Add_Error (Table.States (1152));
Table.States (1152).Kernel := To_Vector ((0 => (259, 119, 3, False)));
Table.States (1152).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 1214)));
Add_Action (Table.States (1153), 74, 1215);
Add_Error (Table.States (1153));
Table.States (1153).Kernel := To_Vector ((0 => (162, 119, 3, False)));
Table.States (1153).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 74, 1215)));
Add_Action (Table.States (1154), (74, 96), (156, 0), 1, null, null);
Table.States (1154).Kernel := To_Vector ((0 => (156, 155, 0, False)));
Table.States (1154).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 156, 1)));
Add_Action (Table.States (1155), (74, 96), (162, 1), 4, derived_type_definition_1'Access, null);
Table.States (1155).Kernel := To_Vector ((0 => (162, 156, 0, False)));
Table.States (1155).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 162, 4)));
Add_Action (Table.States (1156), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (260, 0), 8,
private_type_declaration_0'Access, null);
Table.States (1156).Kernel := To_Vector ((0 => (260, 96, 0, False)));
Table.States (1156).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 260, 8)));
Add_Action (Table.States (1157), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (245, 0), 8,
object_renaming_declaration_0'Access, null);
Table.States (1157).Kernel := To_Vector ((0 => (245, 96, 0, False)));
Table.States (1157).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 245, 8)));
Add_Action (Table.States (1158), 79, 1065);
Add_Action (Table.States (1158), 87, 1216);
Add_Error (Table.States (1158));
Table.States (1158).Kernel := To_Vector (((185, 185, 2, True), (187, 185, 1, False)));
Table.States (1158).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 1216)));
Add_Action (Table.States (1159), (79, 87), (185, 0), 3, null, null);
Table.States (1159).Kernel := To_Vector ((0 => (185, 184, 0, True)));
Table.States (1159).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 185, 3)));
Table.States (1159).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1160), (24, 72), (187, 1), 4, exception_handler_1'Access, null);
Table.States (1160).Kernel := To_Vector ((0 => (187, 300, 0, False)));
Table.States (1160).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 187, 4)));
Add_Action (Table.States (1161), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (133, 0), 8, block_statement_0'Access, block_statement_0_check'Access);
Table.States (1161).Kernel := To_Vector ((0 => (133, 96, 0, False)));
Table.States (1161).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 133, 8)));
Add_Action (Table.States (1162), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (232, 0), 8, loop_statement_0'Access, loop_statement_0_check'Access);
Table.States (1162).Kernel := To_Vector ((0 => (232, 96, 0, False)));
Table.States (1162).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 232, 8)));
Add_Action (Table.States (1163), 96, 1217);
Add_Error (Table.States (1163));
Table.States (1163).Kernel := To_Vector ((0 => (244, 122, 1, False)));
Table.States (1163).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1217)));
Add_Action (Table.States (1164), 96, 1218);
Add_Error (Table.States (1164));
Table.States (1164).Kernel := To_Vector ((0 => (244, 122, 1, False)));
Table.States (1164).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1218)));
Add_Action (Table.States (1165), 96, 1219);
Add_Error (Table.States (1165));
Table.States (1165).Kernel := To_Vector ((0 => (244, 122, 1, False)));
Table.States (1165).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1219)));
Add_Action (Table.States (1166), 96, 1220);
Add_Error (Table.States (1166));
Table.States (1166).Kernel := To_Vector ((0 => (179, 122, 1, False)));
Table.States (1166).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1220)));
Add_Action (Table.States (1167), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (213, 2), 8,
generic_instantiation_2'Access, null);
Table.States (1167).Kernel := To_Vector ((0 => (213, 96, 0, False)));
Table.States (1167).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 213, 8)));
Add_Action (Table.States (1168), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (213, 1), 8,
generic_instantiation_1'Access, null);
Table.States (1168).Kernel := To_Vector ((0 => (213, 96, 0, False)));
Table.States (1168).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 213, 8)));
Add_Action (Table.States (1169), 96, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (1169), 104, 119);
Add_Action (Table.States (1169), 105, 33);
Add_Action (Table.States (1169), 106, 34);
Add_Error (Table.States (1169));
Add_Goto (Table.States (1169), 128, 41);
Add_Goto (Table.States (1169), 239, 630);
Add_Goto (Table.States (1169), 240, 1221);
Add_Goto (Table.States (1169), 272, 92);
Add_Goto (Table.States (1169), 293, 97);
Table.States (1169).Kernel := To_Vector ((0 => (307, 24, 1, False)));
Table.States (1169).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 240, 0)));
Add_Action (Table.States (1170), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (113, 0), 9, accept_statement_0'Access, accept_statement_0_check'Access);
Table.States (1170).Kernel := To_Vector ((0 => (113, 96, 0, False)));
Table.States (1170).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 113, 9)));
Add_Action (Table.States (1171), (77, 83), (137, 0), 4, case_expression_alternative_0'Access, null);
Table.States (1171).Kernel := To_Vector ((0 => (137, 192, 0, False)));
Table.States (1171).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 137, 4)));
Add_Action (Table.States (1172), 3, 121);
Add_Action (Table.States (1172), 22, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1172), 23, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1172), 39, 122);
Add_Action (Table.States (1172), 40, 123);
Add_Action (Table.States (1172), 41, 124);
Add_Action (Table.States (1172), 52, 125);
Add_Action (Table.States (1172), 76, 126);
Add_Action (Table.States (1172), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1172), 94, 127);
Add_Action (Table.States (1172), 95, 128);
Add_Action (Table.States (1172), 103, 129);
Add_Action (Table.States (1172), 104, 119);
Add_Action (Table.States (1172), 105, 33);
Add_Action (Table.States (1172), 106, 34);
Add_Error (Table.States (1172));
Add_Goto (Table.States (1172), 117, 130);
Add_Goto (Table.States (1172), 128, 41);
Add_Goto (Table.States (1172), 191, 131);
Add_Goto (Table.States (1172), 192, 1222);
Add_Goto (Table.States (1172), 197, 133);
Add_Goto (Table.States (1172), 239, 134);
Add_Goto (Table.States (1172), 258, 135);
Add_Goto (Table.States (1172), 272, 92);
Add_Goto (Table.States (1172), 275, 136);
Add_Goto (Table.States (1172), 282, 137);
Add_Goto (Table.States (1172), 283, 138);
Add_Goto (Table.States (1172), 284, 139);
Add_Goto (Table.States (1172), 285, 140);
Add_Goto (Table.States (1172), 286, 141);
Add_Goto (Table.States (1172), 287, 142);
Add_Goto (Table.States (1172), 293, 97);
Add_Goto (Table.States (1172), 301, 143);
Add_Goto (Table.States (1172), 320, 144);
Add_Goto (Table.States (1172), 321, 145);
Add_Goto (Table.States (1172), 330, 146);
Table.States (1172).Kernel := To_Vector ((0 => (172, 68, 0, False)));
Table.States (1172).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1173), (1 => 77), (221, 0), 7, if_expression_0'Access, null);
Table.States (1173).Kernel := To_Vector ((0 => (221, 192, 0, False)));
Table.States (1173).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 221, 7)));
Add_Action (Table.States (1174), 3, 121);
Add_Action (Table.States (1174), 39, 122);
Add_Action (Table.States (1174), 40, 123);
Add_Action (Table.States (1174), 41, 124);
Add_Action (Table.States (1174), 76, 126);
Add_Action (Table.States (1174), 94, 127);
Add_Action (Table.States (1174), 95, 128);
Add_Action (Table.States (1174), 103, 129);
Add_Action (Table.States (1174), 104, 119);
Add_Action (Table.States (1174), 105, 33);
Add_Action (Table.States (1174), 106, 34);
Add_Error (Table.States (1174));
Add_Goto (Table.States (1174), 117, 130);
Add_Goto (Table.States (1174), 128, 41);
Add_Goto (Table.States (1174), 197, 133);
Add_Goto (Table.States (1174), 239, 134);
Add_Goto (Table.States (1174), 258, 135);
Add_Goto (Table.States (1174), 272, 92);
Add_Goto (Table.States (1174), 293, 97);
Add_Goto (Table.States (1174), 301, 1223);
Add_Goto (Table.States (1174), 320, 144);
Add_Goto (Table.States (1174), 321, 145);
Add_Goto (Table.States (1174), 330, 146);
Table.States (1174).Kernel := To_Vector ((0 => (144, 53, 4, False)));
Table.States (1174).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (1175), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 74, 93, 104, 105, 106, 107), (281, 0), 9,
record_representation_clause_0'Access, null);
Table.States (1175).Kernel := To_Vector ((0 => (281, 96, 0, False)));
Table.States (1175).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 281, 9)));
Add_Action (Table.States (1176), (77, 96), (254, 2), 6, parameter_specification_2'Access, null);
Table.States (1176).Kernel := To_Vector ((0 => (254, 192, 0, False)));
Table.States (1176).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 254, 6)));
Add_Action (Table.States (1177), 76, 235);
Add_Action (Table.States (1177), 77, Reduce, (254, 1), 6, parameter_specification_1'Access, null);
Add_Action (Table.States (1177), 82, 1224);
Add_Action (Table.States (1177), 84, 237);
Add_Action (Table.States (1177), 96, Reduce, (254, 1), 6, parameter_specification_1'Access, null);
Add_Action (Table.States (1177), 101, 239);
Add_Action (Table.States (1177), 102, 240);
Add_Error (Table.States (1177));
Add_Goto (Table.States (1177), 115, 241);
Add_Goto (Table.States (1177), 322, 242);
Table.States (1177).Kernel := To_Vector (((128, 239, 2, True), (239, 239, 5, True), (239, 239, 2, True),
(254, 239, 1, False), (254, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True), (293, 239, 2, True)));
Table.States (1177).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 254, 6)));
Add_Action (Table.States (1178), (74, 96), (202, 6), 4, null, null);
Table.States (1178).Kernel := To_Vector ((0 => (202, 80, 0, False)));
Table.States (1178).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 202, 4)));
Add_Action (Table.States (1179), 74, 1225);
Add_Conflict (Table.States (1179), 74, (203, 1), 4, formal_derived_type_definition_1'Access, null);
Add_Action (Table.States (1179), 96, Reduce, (203, 1), 4, formal_derived_type_definition_1'Access, null);
Add_Error (Table.States (1179));
Table.States (1179).Kernel := To_Vector (((203, 119, 2, False), (203, 119, 0, False)));
Table.States (1179).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 203, 4)));
Add_Action (Table.States (1180), 77, 1226);
Add_Error (Table.States (1180));
Table.States (1180).Kernel := To_Vector ((0 => (205, 80, 1, False)));
Table.States (1180).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 1226)));
Add_Action (Table.States (1181), 96, 1227);
Add_Error (Table.States (1181));
Table.States (1181).Kernel := To_Vector ((0 => (204, 122, 1, False)));
Table.States (1181).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1227)));
Add_Action (Table.States (1182), (29, 47, 48, 50, 69, 71, 74, 104), (198, 1), 8,
formal_object_declaration_1'Access, null);
Table.States (1182).Kernel := To_Vector ((0 => (198, 96, 0, False)));
Table.States (1182).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 198, 8)));
Add_Action (Table.States (1183), 96, 1228);
Add_Error (Table.States (1183));
Table.States (1183).Kernel := To_Vector ((0 => (198, 122, 1, False)));
Table.States (1183).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1228)));
Add_Action (Table.States (1184), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (222, 1), 9, if_statement_1'Access, null);
Table.States (1184).Kernel := To_Vector ((0 => (222, 96, 0, False)));
Table.States (1184).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 222, 9)));
Add_Action (Table.States (1185), 96, 1229);
Add_Error (Table.States (1185));
Table.States (1185).Kernel := To_Vector ((0 => (222, 32, 1, False)));
Table.States (1185).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1229)));
Add_Action (Table.States (1186), 96, Reduce, (240, 1), 0, null, null);
Add_Action (Table.States (1186), 104, 119);
Add_Action (Table.States (1186), 105, 33);
Add_Action (Table.States (1186), 106, 34);
Add_Error (Table.States (1186));
Add_Goto (Table.States (1186), 128, 41);
Add_Goto (Table.States (1186), 239, 630);
Add_Goto (Table.States (1186), 240, 1230);
Add_Goto (Table.States (1186), 272, 92);
Add_Goto (Table.States (1186), 293, 97);
Table.States (1186).Kernel := To_Vector ((0 => (247, 24, 1, False)));
Table.States (1186).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 240, 0)));
Add_Action (Table.States (1187), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (247, 1), 9,
package_body_1'Access, package_body_1_check'Access);
Table.States (1187).Kernel := To_Vector ((0 => (247, 96, 0, False)));
Table.States (1187).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 247, 9)));
Add_Action (Table.States (1188), (1 => 96), (251, 0), 9, package_specification_0'Access,
package_specification_0_check'Access);
Table.States (1188).Kernel := To_Vector ((0 => (251, 240, 0, False)));
Table.States (1188).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 251, 9)));
Add_Action (Table.States (1189), 104, 1231);
Add_Error (Table.States (1189));
Table.States (1189).Kernel := To_Vector ((0 => (177, 28, 4, False)));
Table.States (1189).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 1231)));
Add_Action (Table.States (1190), 3, 121);
Add_Action (Table.States (1190), 35, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1190), 39, 122);
Add_Action (Table.States (1190), 40, 123);
Add_Action (Table.States (1190), 41, 124);
Add_Action (Table.States (1190), 52, 125);
Add_Action (Table.States (1190), 76, 126);
Add_Action (Table.States (1190), 94, 127);
Add_Action (Table.States (1190), 95, 128);
Add_Action (Table.States (1190), 103, 129);
Add_Action (Table.States (1190), 104, 119);
Add_Action (Table.States (1190), 105, 33);
Add_Action (Table.States (1190), 106, 34);
Add_Error (Table.States (1190));
Add_Goto (Table.States (1190), 117, 130);
Add_Goto (Table.States (1190), 128, 41);
Add_Goto (Table.States (1190), 191, 131);
Add_Goto (Table.States (1190), 192, 1232);
Add_Goto (Table.States (1190), 197, 133);
Add_Goto (Table.States (1190), 239, 134);
Add_Goto (Table.States (1190), 258, 135);
Add_Goto (Table.States (1190), 272, 92);
Add_Goto (Table.States (1190), 275, 136);
Add_Goto (Table.States (1190), 282, 137);
Add_Goto (Table.States (1190), 283, 138);
Add_Goto (Table.States (1190), 284, 139);
Add_Goto (Table.States (1190), 285, 140);
Add_Goto (Table.States (1190), 286, 141);
Add_Goto (Table.States (1190), 287, 142);
Add_Goto (Table.States (1190), 293, 97);
Add_Goto (Table.States (1190), 301, 143);
Add_Goto (Table.States (1190), 320, 144);
Add_Goto (Table.States (1190), 321, 145);
Add_Goto (Table.States (1190), 330, 146);
Table.States (1190).Kernel := To_Vector ((0 => (176, 72, 4, False)));
Table.States (1190).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1191), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (264, 0), 9,
protected_body_0'Access, protected_body_0_check'Access);
Table.States (1191).Kernel := To_Vector ((0 => (264, 96, 0, False)));
Table.States (1191).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 264, 9)));
Add_Action (Table.States (1192), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1192), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1192), 28, 183);
Add_Action (Table.States (1192), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1192), 30, 8);
Add_Action (Table.States (1192), 40, 12);
Add_Action (Table.States (1192), 46, 14);
Add_Action (Table.States (1192), 47, 15);
Add_Action (Table.States (1192), 48, 16);
Add_Action (Table.States (1192), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1192), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1192), 51, 19);
Add_Action (Table.States (1192), 63, 25);
Add_Action (Table.States (1192), 66, 26);
Add_Action (Table.States (1192), 69, 27);
Add_Action (Table.States (1192), 71, 28);
Add_Action (Table.States (1192), 104, 185);
Add_Error (Table.States (1192));
Add_Goto (Table.States (1192), 112, 35);
Add_Goto (Table.States (1192), 121, 37);
Add_Goto (Table.States (1192), 127, 40);
Add_Goto (Table.States (1192), 134, 45);
Add_Goto (Table.States (1192), 135, 46);
Add_Goto (Table.States (1192), 157, 391);
Add_Goto (Table.States (1192), 158, 392);
Add_Goto (Table.States (1192), 159, 667);
Add_Goto (Table.States (1192), 179, 54);
Add_Goto (Table.States (1192), 182, 55);
Add_Goto (Table.States (1192), 186, 56);
Add_Goto (Table.States (1192), 193, 58);
Add_Goto (Table.States (1192), 206, 60);
Add_Goto (Table.States (1192), 207, 61);
Add_Goto (Table.States (1192), 209, 62);
Add_Goto (Table.States (1192), 210, 63);
Add_Goto (Table.States (1192), 213, 64);
Add_Goto (Table.States (1192), 214, 65);
Add_Goto (Table.States (1192), 215, 66);
Add_Goto (Table.States (1192), 216, 67);
Add_Goto (Table.States (1192), 219, 69);
Add_Goto (Table.States (1192), 223, 71);
Add_Goto (Table.States (1192), 243, 74);
Add_Goto (Table.States (1192), 244, 75);
Add_Goto (Table.States (1192), 245, 76);
Add_Goto (Table.States (1192), 246, 77);
Add_Goto (Table.States (1192), 247, 78);
Add_Goto (Table.States (1192), 248, 79);
Add_Goto (Table.States (1192), 249, 80);
Add_Goto (Table.States (1192), 250, 81);
Add_Goto (Table.States (1192), 251, 82);
Add_Goto (Table.States (1192), 257, 394);
Add_Goto (Table.States (1192), 259, 84);
Add_Goto (Table.States (1192), 260, 85);
Add_Goto (Table.States (1192), 262, 87);
Add_Goto (Table.States (1192), 263, 88);
Add_Goto (Table.States (1192), 264, 89);
Add_Goto (Table.States (1192), 265, 90);
Add_Goto (Table.States (1192), 266, 1233);
Add_Goto (Table.States (1192), 271, 91);
Add_Goto (Table.States (1192), 281, 94);
Add_Goto (Table.States (1192), 289, 95);
Add_Goto (Table.States (1192), 304, 102);
Add_Goto (Table.States (1192), 305, 103);
Add_Goto (Table.States (1192), 307, 105);
Add_Goto (Table.States (1192), 308, 106);
Add_Goto (Table.States (1192), 309, 107);
Add_Goto (Table.States (1192), 311, 108);
Add_Goto (Table.States (1192), 313, 109);
Add_Goto (Table.States (1192), 316, 111);
Add_Goto (Table.States (1192), 317, 112);
Add_Goto (Table.States (1192), 319, 113);
Add_Goto (Table.States (1192), 325, 115);
Add_Goto (Table.States (1192), 331, 116);
Table.States (1192).Kernel := To_Vector ((0 => (271, 74, 2, False)));
Table.States (1192).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
end Subr_19;
procedure Subr_20
is begin
Add_Action (Table.States (1193), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (304, 0), 9,
single_protected_declaration_0'Access, single_protected_declaration_0_check'Access);
Table.States (1193).Kernel := To_Vector ((0 => (304, 96, 0, False)));
Table.States (1193).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 304, 9)));
Add_Action (Table.States (1194), (1 => 96), (266, 0), 5, protected_definition_0'Access,
protected_definition_0_check'Access);
Table.States (1194).Kernel := To_Vector ((0 => (266, 220, 0, False)));
Table.States (1194).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 266, 5)));
Add_Action (Table.States (1195), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (1195), 104, 149);
Add_Error (Table.States (1195));
Add_Goto (Table.States (1195), 220, 1234);
Table.States (1195).Kernel := To_Vector ((0 => (316, 24, 1, False)));
Table.States (1195).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (1196), 24, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1196), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1196), 28, 183);
Add_Action (Table.States (1196), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1196), 30, 8);
Add_Action (Table.States (1196), 40, 12);
Add_Action (Table.States (1196), 46, 14);
Add_Action (Table.States (1196), 47, 15);
Add_Action (Table.States (1196), 48, 16);
Add_Action (Table.States (1196), 49, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1196), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1196), 51, 19);
Add_Action (Table.States (1196), 63, 25);
Add_Action (Table.States (1196), 66, 26);
Add_Action (Table.States (1196), 69, 27);
Add_Action (Table.States (1196), 71, 28);
Add_Action (Table.States (1196), 104, 185);
Add_Error (Table.States (1196));
Add_Goto (Table.States (1196), 112, 35);
Add_Goto (Table.States (1196), 121, 37);
Add_Goto (Table.States (1196), 127, 40);
Add_Goto (Table.States (1196), 134, 45);
Add_Goto (Table.States (1196), 135, 46);
Add_Goto (Table.States (1196), 157, 391);
Add_Goto (Table.States (1196), 158, 392);
Add_Goto (Table.States (1196), 159, 692);
Add_Goto (Table.States (1196), 179, 54);
Add_Goto (Table.States (1196), 182, 55);
Add_Goto (Table.States (1196), 186, 56);
Add_Goto (Table.States (1196), 193, 58);
Add_Goto (Table.States (1196), 206, 60);
Add_Goto (Table.States (1196), 207, 61);
Add_Goto (Table.States (1196), 209, 62);
Add_Goto (Table.States (1196), 210, 63);
Add_Goto (Table.States (1196), 213, 64);
Add_Goto (Table.States (1196), 214, 65);
Add_Goto (Table.States (1196), 215, 66);
Add_Goto (Table.States (1196), 216, 67);
Add_Goto (Table.States (1196), 219, 69);
Add_Goto (Table.States (1196), 223, 71);
Add_Goto (Table.States (1196), 243, 74);
Add_Goto (Table.States (1196), 244, 75);
Add_Goto (Table.States (1196), 245, 76);
Add_Goto (Table.States (1196), 246, 77);
Add_Goto (Table.States (1196), 247, 78);
Add_Goto (Table.States (1196), 248, 79);
Add_Goto (Table.States (1196), 249, 80);
Add_Goto (Table.States (1196), 250, 81);
Add_Goto (Table.States (1196), 251, 82);
Add_Goto (Table.States (1196), 257, 394);
Add_Goto (Table.States (1196), 259, 84);
Add_Goto (Table.States (1196), 260, 85);
Add_Goto (Table.States (1196), 262, 87);
Add_Goto (Table.States (1196), 263, 88);
Add_Goto (Table.States (1196), 264, 89);
Add_Goto (Table.States (1196), 265, 90);
Add_Goto (Table.States (1196), 271, 91);
Add_Goto (Table.States (1196), 281, 94);
Add_Goto (Table.States (1196), 289, 95);
Add_Goto (Table.States (1196), 304, 102);
Add_Goto (Table.States (1196), 305, 103);
Add_Goto (Table.States (1196), 307, 105);
Add_Goto (Table.States (1196), 308, 106);
Add_Goto (Table.States (1196), 309, 107);
Add_Goto (Table.States (1196), 311, 108);
Add_Goto (Table.States (1196), 313, 109);
Add_Goto (Table.States (1196), 316, 111);
Add_Goto (Table.States (1196), 317, 112);
Add_Goto (Table.States (1196), 318, 1235);
Add_Goto (Table.States (1196), 319, 113);
Add_Goto (Table.States (1196), 325, 115);
Add_Goto (Table.States (1196), 331, 116);
Table.States (1196).Kernel := To_Vector ((0 => (319, 74, 2, False)));
Table.States (1196).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 318, 0)));
Add_Action (Table.States (1197), 96, 1236);
Add_Error (Table.States (1197));
Table.States (1197).Kernel := To_Vector ((0 => (319, 220, 1, False)));
Table.States (1197).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1236)));
Add_Action (Table.States (1198), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (1198), 104, 149);
Add_Error (Table.States (1198));
Add_Goto (Table.States (1198), 220, 1237);
Table.States (1198).Kernel := To_Vector ((0 => (305, 24, 1, False)));
Table.States (1198).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (1199), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (1199), 8, 1144);
Add_Action (Table.States (1199), 40, 742);
Add_Action (Table.States (1199), 104, 119);
Add_Action (Table.States (1199), 105, 33);
Add_Action (Table.States (1199), 106, 34);
Add_Error (Table.States (1199));
Add_Goto (Table.States (1199), 114, 1145);
Add_Goto (Table.States (1199), 128, 41);
Add_Goto (Table.States (1199), 147, 1238);
Add_Goto (Table.States (1199), 239, 484);
Add_Goto (Table.States (1199), 241, 721);
Add_Goto (Table.States (1199), 272, 92);
Add_Goto (Table.States (1199), 293, 97);
Add_Goto (Table.States (1199), 314, 1147);
Table.States (1199).Kernel := To_Vector ((0 => (120, 42, 1, False)));
Table.States (1199).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1200), 7, Reduce, (241, 1), 0, null, null);
Add_Action (Table.States (1200), 8, 1144);
Add_Action (Table.States (1200), 40, 742);
Add_Action (Table.States (1200), 104, 119);
Add_Action (Table.States (1200), 105, 33);
Add_Action (Table.States (1200), 106, 34);
Add_Error (Table.States (1200));
Add_Goto (Table.States (1200), 114, 1145);
Add_Goto (Table.States (1200), 128, 41);
Add_Goto (Table.States (1200), 147, 1239);
Add_Goto (Table.States (1200), 239, 484);
Add_Goto (Table.States (1200), 241, 721);
Add_Goto (Table.States (1200), 272, 92);
Add_Goto (Table.States (1200), 293, 97);
Add_Goto (Table.States (1200), 314, 1147);
Table.States (1200).Kernel := To_Vector ((0 => (120, 42, 1, False)));
Table.States (1200).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1201), (77, 83), (226, 0), 3, null, null);
Table.States (1201).Kernel := To_Vector ((0 => (226, 225, 0, True)));
Table.States (1201).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 226, 3)));
Table.States (1201).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1202), 53, 1240);
Add_Action (Table.States (1202), 76, 235);
Add_Action (Table.States (1202), 84, 237);
Add_Action (Table.States (1202), 101, 239);
Add_Action (Table.States (1202), 102, 240);
Add_Error (Table.States (1202));
Add_Goto (Table.States (1202), 115, 241);
Add_Goto (Table.States (1202), 322, 242);
Table.States (1202).Kernel := To_Vector (((128, 239, 2, True), (225, 239, 2, False), (239, 239, 5, True),
(239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True),
(293, 239, 2, True)));
Table.States (1202).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 53, 1240)));
Add_Action (Table.States (1203), (77, 83), (225, 0), 3, null, null);
Table.States (1203).Kernel := To_Vector ((0 => (225, 80, 0, False)));
Table.States (1203).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 225, 3)));
Add_Action (Table.States (1204), (74, 96), (326, 4), 5, null, null);
Table.States (1204).Kernel := To_Vector ((0 => (326, 279, 0, False)));
Table.States (1204).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 326, 5)));
Add_Action (Table.States (1205), 3, 121);
Add_Action (Table.States (1205), 39, 122);
Add_Action (Table.States (1205), 40, 123);
Add_Action (Table.States (1205), 41, 124);
Add_Action (Table.States (1205), 76, 126);
Add_Action (Table.States (1205), 94, 127);
Add_Action (Table.States (1205), 95, 128);
Add_Action (Table.States (1205), 103, 129);
Add_Action (Table.States (1205), 104, 119);
Add_Action (Table.States (1205), 105, 33);
Add_Action (Table.States (1205), 106, 34);
Add_Error (Table.States (1205));
Add_Goto (Table.States (1205), 117, 130);
Add_Goto (Table.States (1205), 128, 41);
Add_Goto (Table.States (1205), 197, 133);
Add_Goto (Table.States (1205), 239, 134);
Add_Goto (Table.States (1205), 258, 135);
Add_Goto (Table.States (1205), 272, 92);
Add_Goto (Table.States (1205), 293, 97);
Add_Goto (Table.States (1205), 301, 1241);
Add_Goto (Table.States (1205), 320, 144);
Add_Goto (Table.States (1205), 321, 145);
Add_Goto (Table.States (1205), 330, 146);
Table.States (1205).Kernel := To_Vector ((0 => (279, 85, 1, False)));
Table.States (1205).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (1206), 3, 121);
Add_Action (Table.States (1206), 39, 122);
Add_Action (Table.States (1206), 40, 261);
Add_Action (Table.States (1206), 41, 124);
Add_Action (Table.States (1206), 44, 263);
Add_Action (Table.States (1206), 52, 125);
Add_Action (Table.States (1206), 76, 126);
Add_Action (Table.States (1206), 79, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (1206), 87, Reduce, (166, 2), 0, null, null);
Add_Action (Table.States (1206), 94, 127);
Add_Action (Table.States (1206), 95, 128);
Add_Action (Table.States (1206), 103, 129);
Add_Action (Table.States (1206), 104, 119);
Add_Action (Table.States (1206), 105, 33);
Add_Action (Table.States (1206), 106, 34);
Add_Error (Table.States (1206));
Add_Goto (Table.States (1206), 117, 130);
Add_Goto (Table.States (1206), 128, 41);
Add_Goto (Table.States (1206), 165, 269);
Add_Goto (Table.States (1206), 166, 1242);
Add_Goto (Table.States (1206), 191, 599);
Add_Goto (Table.States (1206), 197, 133);
Add_Goto (Table.States (1206), 239, 274);
Add_Goto (Table.States (1206), 258, 135);
Add_Goto (Table.States (1206), 272, 92);
Add_Goto (Table.States (1206), 275, 136);
Add_Goto (Table.States (1206), 277, 276);
Add_Goto (Table.States (1206), 282, 137);
Add_Goto (Table.States (1206), 283, 138);
Add_Goto (Table.States (1206), 284, 139);
Add_Goto (Table.States (1206), 285, 140);
Add_Goto (Table.States (1206), 286, 141);
Add_Goto (Table.States (1206), 287, 142);
Add_Goto (Table.States (1206), 293, 97);
Add_Goto (Table.States (1206), 301, 277);
Add_Goto (Table.States (1206), 320, 144);
Add_Goto (Table.States (1206), 321, 145);
Add_Goto (Table.States (1206), 330, 146);
Table.States (1206).Kernel := To_Vector ((0 => (329, 72, 1, False)));
Table.States (1206).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 166, 0)));
Add_Action (Table.States (1207), 24, 1243);
Add_Action (Table.States (1207), 72, 1206);
Add_Error (Table.States (1207));
Add_Goto (Table.States (1207), 329, 1244);
Table.States (1207).Kernel := To_Vector (((327, 328, 3, False), (328, 328, 2, True)));
Table.States (1207).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1243)));
Add_Action (Table.States (1208), (24, 72), (328, 1), 1, null, null);
Table.States (1208).Kernel := To_Vector ((0 => (328, 329, 0, False)));
Table.States (1208).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 328, 1)));
Add_Action (Table.States (1209), (74, 82, 96), (147, 2), 2, null, null);
Table.States (1209).Kernel := To_Vector ((0 => (147, 114, 0, False)));
Table.States (1209).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 147, 2)));
Add_Action (Table.States (1210), (74, 82, 96), (147, 0), 2, null, null);
Table.States (1210).Kernel := To_Vector ((0 => (147, 314, 0, False)));
Table.States (1210).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 147, 2)));
Add_Action (Table.States (1211), 3, 121);
Add_Action (Table.States (1211), 39, 122);
Add_Action (Table.States (1211), 40, 123);
Add_Action (Table.States (1211), 41, 124);
Add_Action (Table.States (1211), 52, 125);
Add_Action (Table.States (1211), 74, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1211), 76, 126);
Add_Action (Table.States (1211), 94, 127);
Add_Action (Table.States (1211), 95, 128);
Add_Action (Table.States (1211), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1211), 103, 129);
Add_Action (Table.States (1211), 104, 119);
Add_Action (Table.States (1211), 105, 33);
Add_Action (Table.States (1211), 106, 34);
Add_Error (Table.States (1211));
Add_Goto (Table.States (1211), 117, 130);
Add_Goto (Table.States (1211), 128, 41);
Add_Goto (Table.States (1211), 191, 131);
Add_Goto (Table.States (1211), 192, 1245);
Add_Goto (Table.States (1211), 197, 133);
Add_Goto (Table.States (1211), 239, 134);
Add_Goto (Table.States (1211), 258, 135);
Add_Goto (Table.States (1211), 272, 92);
Add_Goto (Table.States (1211), 275, 136);
Add_Goto (Table.States (1211), 282, 137);
Add_Goto (Table.States (1211), 283, 138);
Add_Goto (Table.States (1211), 284, 139);
Add_Goto (Table.States (1211), 285, 140);
Add_Goto (Table.States (1211), 286, 141);
Add_Goto (Table.States (1211), 287, 142);
Add_Goto (Table.States (1211), 293, 97);
Add_Goto (Table.States (1211), 301, 143);
Add_Goto (Table.States (1211), 320, 144);
Add_Goto (Table.States (1211), 321, 145);
Add_Goto (Table.States (1211), 330, 146);
Table.States (1211).Kernel := To_Vector ((0 => (146, 82, 1, False)));
Table.States (1211).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1212), 96, 1246);
Add_Error (Table.States (1212));
Table.States (1212).Kernel := To_Vector ((0 => (146, 122, 1, False)));
Table.States (1212).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1246)));
Add_Action (Table.States (1213), 10, 1006);
Add_Action (Table.States (1213), 74, Reduce, (119, 0), 2, null, null);
Add_Action (Table.States (1213), 96, Reduce, (119, 0), 2, null, null);
Add_Error (Table.States (1213));
Table.States (1213).Kernel := To_Vector (((119, 227, 0, False), (227, 227, 2, True)));
Table.States (1213).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 119, 2)));
Add_Action (Table.States (1214), 49, 1247);
Add_Error (Table.States (1214));
Table.States (1214).Kernel := To_Vector ((0 => (259, 74, 2, False)));
Table.States (1214).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 49, 1247)));
Add_Action (Table.States (1215), 41, 705);
Add_Action (Table.States (1215), 54, 708);
Add_Error (Table.States (1215));
Add_Goto (Table.States (1215), 280, 1248);
Table.States (1215).Kernel := To_Vector ((0 => (162, 74, 2, False)));
Table.States (1215).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 41, 705)));
Add_Action (Table.States (1216), 4, 1);
Add_Action (Table.States (1216), 5, 2);
Add_Action (Table.States (1216), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1216), 15, 3);
Add_Action (Table.States (1216), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1216), 18, 4);
Add_Action (Table.States (1216), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1216), 27, 5);
Add_Action (Table.States (1216), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1216), 31, 9);
Add_Action (Table.States (1216), 32, 10);
Add_Action (Table.States (1216), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1216), 41, 13);
Add_Action (Table.States (1216), 48, 16);
Add_Action (Table.States (1216), 52, 20);
Add_Action (Table.States (1216), 57, 21);
Add_Action (Table.States (1216), 58, 22);
Add_Action (Table.States (1216), 61, 24);
Add_Action (Table.States (1216), 72, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1216), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1216), 93, 31);
Add_Action (Table.States (1216), 104, 360);
Add_Action (Table.States (1216), 105, 33);
Add_Action (Table.States (1216), 106, 34);
Add_Error (Table.States (1216));
Add_Goto (Table.States (1216), 113, 36);
Add_Goto (Table.States (1216), 123, 38);
Add_Goto (Table.States (1216), 126, 39);
Add_Goto (Table.States (1216), 128, 41);
Add_Goto (Table.States (1216), 131, 42);
Add_Goto (Table.States (1216), 132, 43);
Add_Goto (Table.States (1216), 133, 44);
Add_Goto (Table.States (1216), 139, 47);
Add_Goto (Table.States (1216), 151, 50);
Add_Goto (Table.States (1216), 152, 51);
Add_Goto (Table.States (1216), 161, 53);
Add_Goto (Table.States (1216), 190, 57);
Add_Goto (Table.States (1216), 196, 59);
Add_Goto (Table.States (1216), 217, 68);
Add_Goto (Table.States (1216), 222, 70);
Add_Goto (Table.States (1216), 232, 72);
Add_Goto (Table.States (1216), 239, 73);
Add_Goto (Table.States (1216), 257, 83);
Add_Goto (Table.States (1216), 261, 86);
Add_Goto (Table.States (1216), 272, 92);
Add_Goto (Table.States (1216), 276, 93);
Add_Goto (Table.States (1216), 290, 96);
Add_Goto (Table.States (1216), 293, 97);
Add_Goto (Table.States (1216), 294, 98);
Add_Goto (Table.States (1216), 298, 99);
Add_Goto (Table.States (1216), 299, 361);
Add_Goto (Table.States (1216), 300, 1249);
Add_Goto (Table.States (1216), 302, 100);
Add_Goto (Table.States (1216), 303, 101);
Add_Goto (Table.States (1216), 306, 363);
Add_Goto (Table.States (1216), 323, 114);
Table.States (1216).Kernel := To_Vector ((0 => (187, 87, 0, False)));
Table.States (1216).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 300, 0)));
Add_Action (Table.States (1217), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 1), 9,
object_declaration_1'Access, null);
Table.States (1217).Kernel := To_Vector ((0 => (244, 96, 0, False)));
Table.States (1217).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 9)));
Add_Action (Table.States (1218), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 2), 9,
object_declaration_2'Access, null);
Table.States (1218).Kernel := To_Vector ((0 => (244, 96, 0, False)));
Table.States (1218).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 9)));
Add_Action (Table.States (1219), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (244, 0), 9,
object_declaration_0'Access, null);
Table.States (1219).Kernel := To_Vector ((0 => (244, 96, 0, False)));
Table.States (1219).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 244, 9)));
Add_Action (Table.States (1220), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (179, 0), 9,
entry_declaration_0'Access, null);
Table.States (1220).Kernel := To_Vector ((0 => (179, 96, 0, False)));
Table.States (1220).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 179, 9)));
Add_Action (Table.States (1221), 96, 1250);
Add_Error (Table.States (1221));
Table.States (1221).Kernel := To_Vector ((0 => (307, 240, 1, False)));
Table.States (1221).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1250)));
Add_Action (Table.States (1222), (22, 23, 77), (172, 0), 4, elsif_expression_item_0'Access, null);
Table.States (1222).Kernel := To_Vector ((0 => (172, 192, 0, False)));
Table.States (1222).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 172, 4)));
Add_Action (Table.States (1223), 85, 1251);
Add_Error (Table.States (1223));
Table.States (1223).Kernel := To_Vector ((0 => (144, 301, 3, False)));
Table.States (1223).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 85, 1251)));
Add_Action (Table.States (1224), 3, 121);
Add_Action (Table.States (1224), 39, 122);
Add_Action (Table.States (1224), 40, 123);
Add_Action (Table.States (1224), 41, 124);
Add_Action (Table.States (1224), 52, 125);
Add_Action (Table.States (1224), 76, 126);
Add_Action (Table.States (1224), 77, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1224), 94, 127);
Add_Action (Table.States (1224), 95, 128);
Add_Action (Table.States (1224), 96, Reduce, (192, 1), 0, null, null);
Add_Action (Table.States (1224), 103, 129);
Add_Action (Table.States (1224), 104, 119);
Add_Action (Table.States (1224), 105, 33);
Add_Action (Table.States (1224), 106, 34);
Add_Error (Table.States (1224));
Add_Goto (Table.States (1224), 117, 130);
Add_Goto (Table.States (1224), 128, 41);
Add_Goto (Table.States (1224), 191, 131);
Add_Goto (Table.States (1224), 192, 1252);
Add_Goto (Table.States (1224), 197, 133);
Add_Goto (Table.States (1224), 239, 134);
Add_Goto (Table.States (1224), 258, 135);
Add_Goto (Table.States (1224), 272, 92);
Add_Goto (Table.States (1224), 275, 136);
Add_Goto (Table.States (1224), 282, 137);
Add_Goto (Table.States (1224), 283, 138);
Add_Goto (Table.States (1224), 284, 139);
Add_Goto (Table.States (1224), 285, 140);
Add_Goto (Table.States (1224), 286, 141);
Add_Goto (Table.States (1224), 287, 142);
Add_Goto (Table.States (1224), 293, 97);
Add_Goto (Table.States (1224), 301, 143);
Add_Goto (Table.States (1224), 320, 144);
Add_Goto (Table.States (1224), 321, 145);
Add_Goto (Table.States (1224), 330, 146);
Table.States (1224).Kernel := To_Vector ((0 => (254, 82, 0, False)));
Table.States (1224).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 192, 0)));
Add_Action (Table.States (1225), 49, 1253);
Add_Error (Table.States (1225));
Table.States (1225).Kernel := To_Vector ((0 => (203, 74, 1, False)));
Table.States (1225).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 49, 1253)));
Add_Action (Table.States (1226), (74, 96), (205, 0), 3, null, null);
Table.States (1226).Kernel := To_Vector ((0 => (205, 77, 0, False)));
Table.States (1226).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 205, 3)));
Add_Action (Table.States (1227), (29, 47, 48, 50, 69, 71, 74, 104), (204, 0), 9,
formal_package_declaration_0'Access, null);
Table.States (1227).Kernel := To_Vector ((0 => (204, 96, 0, False)));
Table.States (1227).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 204, 9)));
Add_Action (Table.States (1228), (29, 47, 48, 50, 69, 71, 74, 104), (198, 0), 9,
formal_object_declaration_0'Access, null);
Table.States (1228).Kernel := To_Vector ((0 => (198, 96, 0, False)));
Table.States (1228).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 198, 9)));
Add_Action (Table.States (1229), (4, 5, 13, 15, 17, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
107), (222, 0), 10, if_statement_0'Access, null);
Table.States (1229).Kernel := To_Vector ((0 => (222, 96, 0, False)));
Table.States (1229).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 222, 10)));
Add_Action (Table.States (1230), 96, 1254);
Add_Error (Table.States (1230));
Table.States (1230).Kernel := To_Vector ((0 => (247, 240, 1, False)));
Table.States (1230).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1254)));
Add_Action (Table.States (1231), 33, 1255);
Add_Error (Table.States (1231));
Table.States (1231).Kernel := To_Vector ((0 => (177, 104, 3, False)));
Table.States (1231).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 33, 1255)));
Add_Action (Table.States (1232), 35, 1256);
Add_Error (Table.States (1232));
Table.States (1232).Kernel := To_Vector ((0 => (176, 192, 4, False)));
Table.States (1232).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 35, 1256)));
Add_Action (Table.States (1233), 96, 1257);
Add_Error (Table.States (1233));
Table.States (1233).Kernel := To_Vector ((0 => (271, 266, 1, False)));
Table.States (1233).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1257)));
Add_Action (Table.States (1234), 96, 1258);
Add_Error (Table.States (1234));
Table.States (1234).Kernel := To_Vector ((0 => (316, 220, 1, False)));
Table.States (1234).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1258)));
Add_Action (Table.States (1235), 24, 1259);
Add_Error (Table.States (1235));
Table.States (1235).Kernel := To_Vector ((0 => (319, 318, 2, False)));
Table.States (1235).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1259)));
Add_Action (Table.States (1236), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (319, 1), 10,
task_type_declaration_1'Access, task_type_declaration_1_check'Access);
Table.States (1236).Kernel := To_Vector ((0 => (319, 96, 0, False)));
Table.States (1236).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 319, 10)));
Add_Action (Table.States (1237), 96, 1260);
Add_Error (Table.States (1237));
Table.States (1237).Kernel := To_Vector ((0 => (305, 220, 1, False)));
Table.States (1237).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1260)));
Add_Action (Table.States (1238), (74, 82, 96), (120, 1), 6, array_type_definition_1'Access, null);
Table.States (1238).Kernel := To_Vector ((0 => (120, 147, 0, False)));
Table.States (1238).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 120, 6)));
Add_Action (Table.States (1239), (74, 82, 96), (120, 0), 6, array_type_definition_0'Access, null);
Table.States (1239).Kernel := To_Vector ((0 => (120, 147, 0, False)));
Table.States (1239).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 120, 6)));
Add_Action (Table.States (1240), 80, 1203);
Add_Error (Table.States (1240));
Table.States (1240).Kernel := To_Vector ((0 => (225, 53, 1, False)));
Table.States (1240).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 80, 1203)));
Add_Action (Table.States (1241), (74, 96), (279, 0), 4, null, null);
Table.States (1241).Kernel := To_Vector ((0 => (279, 301, 0, False)));
Table.States (1241).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 279, 4)));
Add_Action (Table.States (1242), 79, 445);
Add_Action (Table.States (1242), 87, 1261);
Add_Error (Table.States (1242));
Table.States (1242).Kernel := To_Vector (((166, 166, 2, True), (329, 166, 1, False)));
Table.States (1242).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 87, 1261)));
Add_Action (Table.States (1243), 15, 1262);
Add_Error (Table.States (1243));
Table.States (1243).Kernel := To_Vector ((0 => (327, 24, 2, False)));
Table.States (1243).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 15, 1262)));
Add_Action (Table.States (1244), (24, 72), (328, 0), 2, null, null);
Table.States (1244).Kernel := To_Vector ((0 => (328, 329, 0, True)));
Table.States (1244).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 328, 2)));
Table.States (1244).Minimal_Complete_Actions_Recursive := True;
Add_Action (Table.States (1245), 74, 337);
Add_Action (Table.States (1245), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1245));
Add_Goto (Table.States (1245), 122, 1263);
Table.States (1245).Kernel := To_Vector ((0 => (146, 192, 1, False)));
Table.States (1245).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1246), (15, 24, 28, 72, 104), (146, 1), 5, component_declaration_1'Access, null);
Table.States (1246).Kernel := To_Vector ((0 => (146, 96, 0, False)));
Table.States (1246).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 146, 5)));
Add_Action (Table.States (1247), 74, 337);
Add_Action (Table.States (1247), 96, Reduce, (122, 1), 0, null, null);
Add_Error (Table.States (1247));
Add_Goto (Table.States (1247), 122, 1264);
Table.States (1247).Kernel := To_Vector ((0 => (259, 49, 1, False)));
Table.States (1247).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 122, 0)));
Add_Action (Table.States (1248), (74, 96), (162, 0), 6, derived_type_definition_0'Access, null);
Table.States (1248).Kernel := To_Vector ((0 => (162, 280, 0, False)));
Table.States (1248).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 162, 6)));
Add_Action (Table.States (1249), (24, 72), (187, 0), 6, exception_handler_0'Access, null);
Table.States (1249).Kernel := To_Vector ((0 => (187, 300, 0, False)));
Table.States (1249).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 187, 6)));
Add_Action (Table.States (1250), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (307, 0), 10,
subprogram_body_0'Access, subprogram_body_0_check'Access);
Table.States (1250).Kernel := To_Vector ((0 => (307, 96, 0, False)));
Table.States (1250).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 307, 10)));
Add_Action (Table.States (1251), 3, 121);
Add_Action (Table.States (1251), 39, 122);
Add_Action (Table.States (1251), 40, 123);
Add_Action (Table.States (1251), 41, 124);
Add_Action (Table.States (1251), 76, 126);
Add_Action (Table.States (1251), 94, 127);
Add_Action (Table.States (1251), 95, 128);
Add_Action (Table.States (1251), 103, 129);
Add_Action (Table.States (1251), 104, 119);
Add_Action (Table.States (1251), 105, 33);
Add_Action (Table.States (1251), 106, 34);
Add_Error (Table.States (1251));
Add_Goto (Table.States (1251), 117, 130);
Add_Goto (Table.States (1251), 128, 41);
Add_Goto (Table.States (1251), 197, 133);
Add_Goto (Table.States (1251), 239, 134);
Add_Goto (Table.States (1251), 258, 135);
Add_Goto (Table.States (1251), 272, 92);
Add_Goto (Table.States (1251), 293, 97);
Add_Goto (Table.States (1251), 301, 1265);
Add_Goto (Table.States (1251), 320, 144);
Add_Goto (Table.States (1251), 321, 145);
Add_Goto (Table.States (1251), 330, 146);
Table.States (1251).Kernel := To_Vector ((0 => (144, 85, 2, False)));
Table.States (1251).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 103, 129)));
Add_Action (Table.States (1252), (77, 96), (254, 0), 8, parameter_specification_0'Access, null);
Table.States (1252).Kernel := To_Vector ((0 => (254, 192, 0, False)));
Table.States (1252).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 254, 8)));
Add_Action (Table.States (1253), (74, 96), (203, 0), 6, formal_derived_type_definition_0'Access, null);
Table.States (1253).Kernel := To_Vector ((0 => (203, 49, 0, False)));
Table.States (1253).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 203, 6)));
Add_Action (Table.States (1254), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (247, 0), 11,
package_body_0'Access, package_body_0_check'Access);
Table.States (1254).Kernel := To_Vector ((0 => (247, 96, 0, False)));
Table.States (1254).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 247, 11)));
Add_Action (Table.States (1255), 3, 121);
Add_Action (Table.States (1255), 39, 122);
Add_Action (Table.States (1255), 40, 474);
Add_Action (Table.States (1255), 41, 124);
Add_Action (Table.States (1255), 76, 126);
Add_Action (Table.States (1255), 94, 127);
Add_Action (Table.States (1255), 95, 128);
Add_Action (Table.States (1255), 103, 129);
Add_Action (Table.States (1255), 104, 119);
Add_Action (Table.States (1255), 105, 33);
Add_Action (Table.States (1255), 106, 34);
Add_Error (Table.States (1255));
Add_Goto (Table.States (1255), 117, 130);
Add_Goto (Table.States (1255), 128, 41);
Add_Goto (Table.States (1255), 167, 1266);
Add_Goto (Table.States (1255), 197, 133);
Add_Goto (Table.States (1255), 239, 477);
Add_Goto (Table.States (1255), 258, 135);
Add_Goto (Table.States (1255), 272, 92);
Add_Goto (Table.States (1255), 277, 478);
Add_Goto (Table.States (1255), 293, 97);
Add_Goto (Table.States (1255), 301, 479);
Add_Goto (Table.States (1255), 314, 480);
Add_Goto (Table.States (1255), 320, 144);
Add_Goto (Table.States (1255), 321, 145);
Add_Goto (Table.States (1255), 330, 146);
Table.States (1255).Kernel := To_Vector ((0 => (177, 33, 2, False)));
Table.States (1255).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 104, 119)));
Add_Action (Table.States (1256), 13, Reduce, (159, 1), 0, null, null);
Add_Action (Table.States (1256), 25, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1256), 28, 183);
Add_Action (Table.States (1256), 29, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1256), 30, 8);
Add_Action (Table.States (1256), 40, 12);
Add_Action (Table.States (1256), 46, 14);
Add_Action (Table.States (1256), 47, 15);
Add_Action (Table.States (1256), 48, 16);
Add_Action (Table.States (1256), 50, Reduce, (246, 2), 0, null, null);
Add_Action (Table.States (1256), 51, 19);
Add_Action (Table.States (1256), 63, 25);
Add_Action (Table.States (1256), 66, 26);
Add_Action (Table.States (1256), 69, 27);
Add_Action (Table.States (1256), 71, 28);
Add_Action (Table.States (1256), 104, 185);
Add_Error (Table.States (1256));
Add_Goto (Table.States (1256), 112, 35);
Add_Goto (Table.States (1256), 121, 37);
Add_Goto (Table.States (1256), 127, 40);
Add_Goto (Table.States (1256), 134, 45);
Add_Goto (Table.States (1256), 135, 46);
Add_Goto (Table.States (1256), 157, 391);
Add_Goto (Table.States (1256), 158, 392);
Add_Goto (Table.States (1256), 159, 1267);
Add_Goto (Table.States (1256), 179, 54);
Add_Goto (Table.States (1256), 182, 55);
Add_Goto (Table.States (1256), 186, 56);
Add_Goto (Table.States (1256), 193, 58);
Add_Goto (Table.States (1256), 206, 60);
Add_Goto (Table.States (1256), 207, 61);
Add_Goto (Table.States (1256), 209, 62);
Add_Goto (Table.States (1256), 210, 63);
Add_Goto (Table.States (1256), 213, 64);
Add_Goto (Table.States (1256), 214, 65);
Add_Goto (Table.States (1256), 215, 66);
Add_Goto (Table.States (1256), 216, 67);
Add_Goto (Table.States (1256), 219, 69);
Add_Goto (Table.States (1256), 223, 71);
Add_Goto (Table.States (1256), 243, 74);
Add_Goto (Table.States (1256), 244, 75);
Add_Goto (Table.States (1256), 245, 76);
Add_Goto (Table.States (1256), 246, 77);
Add_Goto (Table.States (1256), 247, 78);
Add_Goto (Table.States (1256), 248, 79);
Add_Goto (Table.States (1256), 249, 80);
Add_Goto (Table.States (1256), 250, 81);
Add_Goto (Table.States (1256), 251, 82);
Add_Goto (Table.States (1256), 257, 394);
Add_Goto (Table.States (1256), 259, 84);
Add_Goto (Table.States (1256), 260, 85);
Add_Goto (Table.States (1256), 262, 87);
Add_Goto (Table.States (1256), 263, 88);
Add_Goto (Table.States (1256), 264, 89);
Add_Goto (Table.States (1256), 265, 90);
Add_Goto (Table.States (1256), 271, 91);
Add_Goto (Table.States (1256), 281, 94);
Add_Goto (Table.States (1256), 289, 95);
Add_Goto (Table.States (1256), 304, 102);
Add_Goto (Table.States (1256), 305, 103);
Add_Goto (Table.States (1256), 307, 105);
Add_Goto (Table.States (1256), 308, 106);
Add_Goto (Table.States (1256), 309, 107);
Add_Goto (Table.States (1256), 311, 108);
Add_Goto (Table.States (1256), 313, 109);
Add_Goto (Table.States (1256), 316, 111);
Add_Goto (Table.States (1256), 317, 112);
Add_Goto (Table.States (1256), 319, 113);
Add_Goto (Table.States (1256), 325, 115);
Add_Goto (Table.States (1256), 331, 116);
Table.States (1256).Kernel := To_Vector ((0 => (176, 35, 3, False)));
Table.States (1256).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 159, 0)));
Add_Action (Table.States (1257), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (271, 0), 11,
protected_type_declaration_0'Access, protected_type_declaration_0_check'Access);
Table.States (1257).Kernel := To_Vector ((0 => (271, 96, 0, False)));
Table.States (1257).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 271, 11)));
Add_Action (Table.States (1258), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (316, 0), 11,
task_body_0'Access, task_body_0_check'Access);
Table.States (1258).Kernel := To_Vector ((0 => (316, 96, 0, False)));
Table.States (1258).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 316, 11)));
Add_Action (Table.States (1259), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (1259), 104, 149);
Add_Error (Table.States (1259));
Add_Goto (Table.States (1259), 220, 1268);
Table.States (1259).Kernel := To_Vector ((0 => (319, 24, 1, False)));
Table.States (1259).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (1260), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (305, 0), 11,
single_task_declaration_0'Access, single_task_declaration_0_check'Access);
Table.States (1260).Kernel := To_Vector ((0 => (305, 96, 0, False)));
Table.States (1260).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 305, 11)));
Add_Action (Table.States (1261), 15, 885);
Add_Action (Table.States (1261), 24, Reduce, (150, 1), 0, null, null);
Add_Action (Table.States (1261), 28, 183);
Add_Action (Table.States (1261), 41, 886);
Add_Action (Table.States (1261), 72, Reduce, (150, 1), 0, null, null);
Add_Action (Table.States (1261), 104, 164);
Add_Error (Table.States (1261));
Add_Goto (Table.States (1261), 121, 887);
Add_Goto (Table.States (1261), 127, 40);
Add_Goto (Table.States (1261), 146, 888);
Add_Goto (Table.States (1261), 148, 889);
Add_Goto (Table.States (1261), 149, 890);
Add_Goto (Table.States (1261), 150, 1269);
Add_Goto (Table.States (1261), 182, 55);
Add_Goto (Table.States (1261), 219, 892);
Add_Goto (Table.States (1261), 281, 94);
Add_Goto (Table.States (1261), 327, 893);
Table.States (1261).Kernel := To_Vector ((0 => (329, 87, 0, False)));
Table.States (1261).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 150, 0)));
Add_Action (Table.States (1262), 96, 1270);
Add_Error (Table.States (1262));
Table.States (1262).Kernel := To_Vector ((0 => (327, 15, 1, False)));
Table.States (1262).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1270)));
Add_Action (Table.States (1263), 96, 1271);
Add_Error (Table.States (1263));
Table.States (1263).Kernel := To_Vector ((0 => (146, 122, 1, False)));
Table.States (1263).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1271)));
Add_Action (Table.States (1264), 96, 1272);
Add_Error (Table.States (1264));
Table.States (1264).Kernel := To_Vector ((0 => (259, 122, 1, False)));
Table.States (1264).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1272)));
Add_Action (Table.States (1265), 96, 1273);
Add_Error (Table.States (1265));
Table.States (1265).Kernel := To_Vector ((0 => (144, 301, 1, False)));
Table.States (1265).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1273)));
Add_Action (Table.States (1266), 77, 1274);
Add_Error (Table.States (1266));
Table.States (1266).Kernel := To_Vector ((0 => (177, 167, 1, False)));
Table.States (1266).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 77, 1274)));
Add_Action (Table.States (1267), 13, 1275);
Add_Error (Table.States (1267));
Table.States (1267).Kernel := To_Vector ((0 => (176, 159, 3, False)));
Table.States (1267).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 1275)));
Add_Action (Table.States (1268), 96, 1276);
Add_Error (Table.States (1268));
Table.States (1268).Kernel := To_Vector ((0 => (319, 220, 1, False)));
Table.States (1268).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1276)));
end Subr_20;
procedure Subr_21
is begin
Add_Action (Table.States (1269), (24, 72), (329, 0), 4, variant_0'Access, null);
Table.States (1269).Kernel := To_Vector ((0 => (329, 150, 0, False)));
Table.States (1269).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 329, 4)));
Add_Action (Table.States (1270), (15, 24, 28, 72, 104), (327, 0), 7, variant_part_0'Access, null);
Table.States (1270).Kernel := To_Vector ((0 => (327, 96, 0, False)));
Table.States (1270).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 327, 7)));
Add_Action (Table.States (1271), (15, 24, 28, 72, 104), (146, 0), 7, component_declaration_0'Access, null);
Table.States (1271).Kernel := To_Vector ((0 => (146, 96, 0, False)));
Table.States (1271).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 146, 7)));
Add_Action (Table.States (1272), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (259, 0), 12,
private_extension_declaration_0'Access, null);
Table.States (1272).Kernel := To_Vector ((0 => (259, 96, 0, False)));
Table.States (1272).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 259, 12)));
Add_Action (Table.States (1273), (24, 104), (144, 0), 8, component_clause_0'Access, null);
Table.States (1273).Kernel := To_Vector ((0 => (144, 96, 0, False)));
Table.States (1273).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 144, 8)));
Add_Action (Table.States (1274), 72, Reduce, (253, 1), 0, null, null);
Add_Action (Table.States (1274), 76, 431);
Add_Error (Table.States (1274));
Add_Goto (Table.States (1274), 199, 344);
Add_Goto (Table.States (1274), 253, 1277);
Table.States (1274).Kernel := To_Vector ((0 => (177, 77, 0, False)));
Table.States (1274).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 253, 0)));
Add_Action (Table.States (1275), 4, 1);
Add_Action (Table.States (1275), 5, 2);
Add_Action (Table.States (1275), 13, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1275), 15, 3);
Add_Action (Table.States (1275), 17, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1275), 18, 4);
Add_Action (Table.States (1275), 24, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1275), 26, Reduce, (300, 1), 0, null, null);
Add_Action (Table.States (1275), 27, 5);
Add_Action (Table.States (1275), 28, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1275), 31, 9);
Add_Action (Table.States (1275), 32, 10);
Add_Action (Table.States (1275), 37, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1275), 41, 13);
Add_Action (Table.States (1275), 48, 16);
Add_Action (Table.States (1275), 52, 20);
Add_Action (Table.States (1275), 57, 21);
Add_Action (Table.States (1275), 58, 22);
Add_Action (Table.States (1275), 61, 24);
Add_Action (Table.States (1275), 73, Reduce, (132, 1), 0, null, null);
Add_Action (Table.States (1275), 93, 31);
Add_Action (Table.States (1275), 104, 360);
Add_Action (Table.States (1275), 105, 33);
Add_Action (Table.States (1275), 106, 34);
Add_Error (Table.States (1275));
Add_Goto (Table.States (1275), 113, 36);
Add_Goto (Table.States (1275), 123, 38);
Add_Goto (Table.States (1275), 126, 39);
Add_Goto (Table.States (1275), 128, 41);
Add_Goto (Table.States (1275), 131, 42);
Add_Goto (Table.States (1275), 132, 43);
Add_Goto (Table.States (1275), 133, 44);
Add_Goto (Table.States (1275), 139, 47);
Add_Goto (Table.States (1275), 151, 50);
Add_Goto (Table.States (1275), 152, 51);
Add_Goto (Table.States (1275), 161, 53);
Add_Goto (Table.States (1275), 190, 57);
Add_Goto (Table.States (1275), 196, 59);
Add_Goto (Table.States (1275), 217, 68);
Add_Goto (Table.States (1275), 218, 1278);
Add_Goto (Table.States (1275), 222, 70);
Add_Goto (Table.States (1275), 232, 72);
Add_Goto (Table.States (1275), 239, 73);
Add_Goto (Table.States (1275), 257, 83);
Add_Goto (Table.States (1275), 261, 86);
Add_Goto (Table.States (1275), 272, 92);
Add_Goto (Table.States (1275), 276, 93);
Add_Goto (Table.States (1275), 290, 96);
Add_Goto (Table.States (1275), 293, 97);
Add_Goto (Table.States (1275), 294, 98);
Add_Goto (Table.States (1275), 298, 99);
Add_Goto (Table.States (1275), 299, 361);
Add_Goto (Table.States (1275), 300, 390);
Add_Goto (Table.States (1275), 302, 100);
Add_Goto (Table.States (1275), 303, 101);
Add_Goto (Table.States (1275), 306, 363);
Add_Goto (Table.States (1275), 323, 114);
Table.States (1275).Kernel := To_Vector ((0 => (176, 13, 2, False)));
Table.States (1275).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 218, 0)));
Add_Action (Table.States (1276), (4, 5, 13, 15, 17, 18, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 104, 105, 106, 107), (319, 0), 13,
task_type_declaration_0'Access, task_type_declaration_0_check'Access);
Table.States (1276).Kernel := To_Vector ((0 => (319, 96, 0, False)));
Table.States (1276).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 319, 13)));
Add_Action (Table.States (1277), (1 => 72), (177, 0), 7, entry_body_formal_part_0'Access, null);
Table.States (1277).Kernel := To_Vector ((0 => (177, 253, 0, False)));
Table.States (1277).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 177, 7)));
Add_Action (Table.States (1278), 24, 1279);
Add_Error (Table.States (1278));
Table.States (1278).Kernel := To_Vector ((0 => (176, 218, 2, False)));
Table.States (1278).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 1279)));
Add_Action (Table.States (1279), 96, Reduce, (220, 1), 0, null, null);
Add_Action (Table.States (1279), 104, 149);
Add_Error (Table.States (1279));
Add_Goto (Table.States (1279), 220, 1280);
Table.States (1279).Kernel := To_Vector ((0 => (176, 24, 1, False)));
Table.States (1279).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 220, 0)));
Add_Action (Table.States (1280), 96, 1281);
Add_Error (Table.States (1280));
Table.States (1280).Kernel := To_Vector ((0 => (176, 220, 1, False)));
Table.States (1280).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 96, 1281)));
Add_Action (Table.States (1281), (24, 25, 28, 29, 40, 46, 50), (176, 0), 12, entry_body_0'Access,
entry_body_0_check'Access);
Table.States (1281).Kernel := To_Vector ((0 => (176, 96, 0, False)));
Table.States (1281).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 176, 12)));
end Subr_21;
begin
Subr_1;
Subr_2;
Subr_3;
Subr_4;
Subr_5;
Subr_6;
Subr_7;
Subr_8;
Subr_9;
Subr_10;
Subr_11;
Subr_12;
Subr_13;
Subr_14;
Subr_15;
Subr_16;
Subr_17;
Subr_18;
Subr_19;
Subr_20;
Subr_21;
end;
WisiToken.Parse.LR.Parser.New_Parser
(Parser,
Trace,
Lexer.New_Lexer (Trace.Descriptor),
Table,
Language_Fixes,
Language_Matching_Begin_Tokens,
Language_String_ID_Set,
User_Data,
Max_Parallel => 15,
Terminate_Same_State => True);
end Create_Parser;
end Ada_Process_LALR_Main;
|
optikos/oasis | Ada | 2,740 | ads | -- Copyright (c) 2019 Maxim Reznik <[email protected]>
--
-- SPDX-License-Identifier: MIT
-- License-Filename: LICENSE
-------------------------------------------------------------
with Program.Elements.Declarations;
with Program.Lexical_Elements;
with Program.Elements.Defining_Names;
with Program.Elements.Expressions;
with Program.Elements.Aspect_Specifications;
package Program.Elements.Generic_Package_Renaming_Declarations is
pragma Pure (Program.Elements.Generic_Package_Renaming_Declarations);
type Generic_Package_Renaming_Declaration is
limited interface and Program.Elements.Declarations.Declaration;
type Generic_Package_Renaming_Declaration_Access is
access all Generic_Package_Renaming_Declaration'Class
with Storage_Size => 0;
not overriding function Name
(Self : Generic_Package_Renaming_Declaration)
return not null Program.Elements.Defining_Names.Defining_Name_Access
is abstract;
not overriding function Renamed_Package
(Self : Generic_Package_Renaming_Declaration)
return not null Program.Elements.Expressions.Expression_Access
is abstract;
not overriding function Aspects
(Self : Generic_Package_Renaming_Declaration)
return Program.Elements.Aspect_Specifications
.Aspect_Specification_Vector_Access is abstract;
type Generic_Package_Renaming_Declaration_Text is limited interface;
type Generic_Package_Renaming_Declaration_Text_Access is
access all Generic_Package_Renaming_Declaration_Text'Class
with Storage_Size => 0;
not overriding function To_Generic_Package_Renaming_Declaration_Text
(Self : aliased in out Generic_Package_Renaming_Declaration)
return Generic_Package_Renaming_Declaration_Text_Access is abstract;
not overriding function Generic_Token
(Self : Generic_Package_Renaming_Declaration_Text)
return not null Program.Lexical_Elements.Lexical_Element_Access
is abstract;
not overriding function Package_Token
(Self : Generic_Package_Renaming_Declaration_Text)
return not null Program.Lexical_Elements.Lexical_Element_Access
is abstract;
not overriding function Renames_Token
(Self : Generic_Package_Renaming_Declaration_Text)
return not null Program.Lexical_Elements.Lexical_Element_Access
is abstract;
not overriding function With_Token
(Self : Generic_Package_Renaming_Declaration_Text)
return Program.Lexical_Elements.Lexical_Element_Access is abstract;
not overriding function Semicolon_Token
(Self : Generic_Package_Renaming_Declaration_Text)
return not null Program.Lexical_Elements.Lexical_Element_Access
is abstract;
end Program.Elements.Generic_Package_Renaming_Declarations;
|
AdaCore/training_material | Ada | 628 | ads | -- The operations allowed in SDC (addition, subtraction, multiplication, etc.)
-- It must be a child package of Values, since the operations must have
-- access to the internal structure of a Value.
package Values.Operations is
type Operation is private;
-- The actual operation type.
function Read (Op : String) return Operation;
-- If Op contains the characters of a valid operation the operation is
-- returned, otherwise Except.User_Error is raised.
procedure Process (Op : Operation);
-- Processes an Operation.
private
type Operation is (Add, Div, Mul, Sub);
end Values.Operations;
|
Fabien-Chouteau/GESTE | Ada | 29,820 | ads | package GESTE_Fonts.FreeSansOblique8pt7b is
Font : constant Bitmap_Font_Ref;
private
FreeSansOblique8pt7bBitmaps : aliased constant Font_Bitmap := (
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0C#,
16#00#, 16#0C#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#,
16#18#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#10#,
16#00#, 16#00#, 16#00#, 16#30#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#1B#, 16#00#, 16#12#, 16#00#, 16#12#, 16#00#,
16#12#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#06#, 16#40#, 16#04#, 16#80#,
16#04#, 16#80#, 16#3F#, 16#C0#, 16#09#, 16#00#, 16#19#, 16#00#, 16#13#,
16#00#, 16#7F#, 16#80#, 16#26#, 16#00#, 16#24#, 16#00#, 16#64#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#02#, 16#00#, 16#0F#, 16#80#,
16#1A#, 16#C0#, 16#12#, 16#C0#, 16#34#, 16#00#, 16#1C#, 16#00#, 16#0F#,
16#00#, 16#05#, 16#80#, 16#04#, 16#80#, 16#49#, 16#80#, 16#69#, 16#00#,
16#3E#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#0E#, 16#08#, 16#13#, 16#10#, 16#21#, 16#20#, 16#22#, 16#40#, 16#1C#,
16#40#, 16#00#, 16#80#, 16#01#, 16#3C#, 16#02#, 16#64#, 16#04#, 16#44#,
16#04#, 16#44#, 16#08#, 16#78#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#07#, 16#80#, 16#0C#, 16#80#, 16#08#, 16#80#, 16#0D#,
16#80#, 16#0F#, 16#00#, 16#1E#, 16#00#, 16#32#, 16#40#, 16#23#, 16#C0#,
16#61#, 16#80#, 16#63#, 16#80#, 16#3C#, 16#C0#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#18#, 16#00#, 16#10#, 16#00#, 16#10#,
16#00#, 16#10#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#02#, 16#00#, 16#04#, 16#00#, 16#08#,
16#00#, 16#08#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#,
16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#10#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#10#,
16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#,
16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#18#, 16#00#, 16#10#,
16#00#, 16#10#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#40#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#04#,
16#00#, 16#04#, 16#00#, 16#1E#, 16#00#, 16#0C#, 16#00#, 16#14#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#02#, 16#00#, 16#04#, 16#00#, 16#04#, 16#00#, 16#3F#,
16#80#, 16#04#, 16#00#, 16#0C#, 16#00#, 16#08#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#,
16#20#, 16#00#, 16#40#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#38#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#20#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#02#, 16#00#, 16#04#, 16#00#, 16#04#, 16#00#, 16#08#, 16#00#, 16#08#,
16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#,
16#40#, 16#00#, 16#80#, 16#00#, 16#80#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#07#, 16#80#, 16#08#, 16#80#, 16#10#,
16#C0#, 16#30#, 16#C0#, 16#30#, 16#80#, 16#20#, 16#80#, 16#20#, 16#80#,
16#21#, 16#80#, 16#21#, 16#00#, 16#23#, 16#00#, 16#1C#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#01#, 16#00#, 16#03#,
16#00#, 16#1E#, 16#00#, 16#02#, 16#00#, 16#02#, 16#00#, 16#06#, 16#00#,
16#06#, 16#00#, 16#04#, 16#00#, 16#04#, 16#00#, 16#0C#, 16#00#, 16#0C#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#,
16#80#, 16#18#, 16#C0#, 16#10#, 16#C0#, 16#00#, 16#C0#, 16#00#, 16#80#,
16#03#, 16#80#, 16#0E#, 16#00#, 16#18#, 16#00#, 16#30#, 16#00#, 16#60#,
16#00#, 16#7F#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#0F#, 16#80#, 16#18#, 16#80#, 16#10#, 16#C0#, 16#00#, 16#80#,
16#01#, 16#80#, 16#07#, 16#00#, 16#01#, 16#80#, 16#01#, 16#80#, 16#61#,
16#80#, 16#63#, 16#00#, 16#3E#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#01#, 16#80#, 16#01#, 16#80#, 16#03#, 16#00#,
16#05#, 16#00#, 16#09#, 16#00#, 16#13#, 16#00#, 16#23#, 16#00#, 16#7F#,
16#80#, 16#02#, 16#00#, 16#02#, 16#00#, 16#06#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#, 16#C0#, 16#08#, 16#00#,
16#18#, 16#00#, 16#10#, 16#00#, 16#1F#, 16#00#, 16#31#, 16#80#, 16#00#,
16#80#, 16#00#, 16#80#, 16#61#, 16#80#, 16#63#, 16#00#, 16#3E#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#07#, 16#80#,
16#08#, 16#C0#, 16#10#, 16#C0#, 16#10#, 16#00#, 16#2F#, 16#00#, 16#31#,
16#80#, 16#20#, 16#80#, 16#20#, 16#80#, 16#61#, 16#80#, 16#23#, 16#00#,
16#1E#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#1F#, 16#E0#, 16#00#, 16#40#, 16#00#, 16#80#, 16#01#, 16#00#, 16#02#,
16#00#, 16#06#, 16#00#, 16#04#, 16#00#, 16#08#, 16#00#, 16#18#, 16#00#,
16#10#, 16#00#, 16#30#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#07#, 16#80#, 16#08#, 16#C0#, 16#10#, 16#C0#, 16#10#,
16#80#, 16#11#, 16#80#, 16#0F#, 16#00#, 16#31#, 16#80#, 16#60#, 16#80#,
16#61#, 16#80#, 16#63#, 16#00#, 16#3E#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#0F#, 16#00#, 16#18#, 16#80#, 16#10#,
16#C0#, 16#20#, 16#C0#, 16#20#, 16#80#, 16#31#, 16#80#, 16#1E#, 16#80#,
16#01#, 16#80#, 16#01#, 16#00#, 16#62#, 16#00#, 16#3C#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#08#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#20#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#08#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#20#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#40#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#01#, 16#C0#, 16#0E#, 16#00#, 16#38#, 16#00#, 16#70#, 16#00#, 16#1C#,
16#00#, 16#07#, 16#00#, 16#01#, 16#80#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#3F#, 16#C0#, 16#00#, 16#00#, 16#00#,
16#00#, 16#7F#, 16#80#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#30#, 16#00#, 16#1C#, 16#00#, 16#07#,
16#00#, 16#01#, 16#C0#, 16#03#, 16#80#, 16#0E#, 16#00#, 16#70#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#07#, 16#80#, 16#08#, 16#C0#,
16#10#, 16#40#, 16#00#, 16#C0#, 16#00#, 16#80#, 16#03#, 16#00#, 16#06#,
16#00#, 16#04#, 16#00#, 16#04#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#08#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#FC#,
16#03#, 16#06#, 16#0C#, 16#03#, 16#18#, 16#ED#, 16#11#, 16#19#, 16#32#,
16#19#, 16#26#, 16#11#, 16#66#, 16#31#, 16#64#, 16#22#, 16#66#, 16#66#,
16#23#, 16#B8#, 16#30#, 16#00#, 16#18#, 16#00#, 16#07#, 16#E0#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#01#, 16#80#, 16#03#, 16#80#, 16#02#, 16#80#, 16#06#, 16#80#, 16#0C#,
16#80#, 16#08#, 16#C0#, 16#18#, 16#C0#, 16#1F#, 16#C0#, 16#30#, 16#C0#,
16#20#, 16#40#, 16#60#, 16#40#, 16#40#, 16#40#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#0F#, 16#C0#, 16#18#, 16#60#, 16#18#, 16#20#, 16#18#,
16#20#, 16#10#, 16#20#, 16#10#, 16#40#, 16#3F#, 16#C0#, 16#30#, 16#60#,
16#30#, 16#60#, 16#20#, 16#60#, 16#20#, 16#C0#, 16#7F#, 16#80#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#03#, 16#E0#, 16#0C#, 16#30#, 16#18#,
16#10#, 16#10#, 16#00#, 16#30#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#,
16#20#, 16#00#, 16#20#, 16#20#, 16#30#, 16#60#, 16#30#, 16#C0#, 16#1F#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#, 16#C0#, 16#18#,
16#60#, 16#18#, 16#30#, 16#18#, 16#30#, 16#10#, 16#30#, 16#10#, 16#30#,
16#30#, 16#30#, 16#30#, 16#20#, 16#30#, 16#60#, 16#20#, 16#40#, 16#20#,
16#80#, 16#7F#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#,
16#F0#, 16#18#, 16#00#, 16#18#, 16#00#, 16#18#, 16#00#, 16#10#, 16#00#,
16#10#, 16#00#, 16#3F#, 16#C0#, 16#30#, 16#00#, 16#30#, 16#00#, 16#20#,
16#00#, 16#20#, 16#00#, 16#7F#, 16#C0#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#0F#, 16#E0#, 16#18#, 16#00#, 16#18#, 16#00#, 16#18#, 16#00#,
16#10#, 16#00#, 16#10#, 16#00#, 16#3F#, 16#C0#, 16#30#, 16#00#, 16#30#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#60#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#03#, 16#E0#, 16#04#, 16#18#, 16#08#, 16#18#,
16#10#, 16#00#, 16#30#, 16#00#, 16#30#, 16#00#, 16#20#, 16#F8#, 16#20#,
16#10#, 16#20#, 16#10#, 16#30#, 16#30#, 16#18#, 16#70#, 16#0F#, 16#A0#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#08#, 16#18#, 16#18#, 16#10#,
16#18#, 16#10#, 16#18#, 16#10#, 16#10#, 16#30#, 16#10#, 16#30#, 16#3F#,
16#E0#, 16#30#, 16#20#, 16#30#, 16#20#, 16#20#, 16#60#, 16#20#, 16#60#,
16#60#, 16#40#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#08#, 16#00#,
16#08#, 16#00#, 16#08#, 16#00#, 16#18#, 16#00#, 16#18#, 16#00#, 16#10#,
16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#, 16#30#, 16#00#,
16#20#, 16#00#, 16#20#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#80#, 16#01#, 16#80#, 16#01#, 16#80#, 16#01#, 16#80#, 16#01#,
16#00#, 16#01#, 16#00#, 16#03#, 16#00#, 16#03#, 16#00#, 16#43#, 16#00#,
16#42#, 16#00#, 16#66#, 16#00#, 16#3C#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#08#, 16#10#, 16#18#, 16#60#, 16#18#, 16#C0#, 16#19#,
16#80#, 16#13#, 16#00#, 16#17#, 16#00#, 16#3B#, 16#00#, 16#31#, 16#00#,
16#31#, 16#80#, 16#20#, 16#80#, 16#20#, 16#C0#, 16#60#, 16#40#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#08#, 16#00#, 16#18#, 16#00#, 16#18#,
16#00#, 16#18#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#,
16#30#, 16#00#, 16#30#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#7F#,
16#80#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0C#, 16#0E#, 16#1C#,
16#0C#, 16#1C#, 16#1C#, 16#1C#, 16#14#, 16#14#, 16#3C#, 16#16#, 16#2C#,
16#36#, 16#68#, 16#36#, 16#48#, 16#22#, 16#88#, 16#22#, 16#98#, 16#23#,
16#18#, 16#63#, 16#10#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0C#,
16#18#, 16#1C#, 16#18#, 16#1C#, 16#10#, 16#1E#, 16#10#, 16#12#, 16#10#,
16#13#, 16#30#, 16#33#, 16#30#, 16#31#, 16#20#, 16#21#, 16#A0#, 16#20#,
16#A0#, 16#20#, 16#E0#, 16#60#, 16#E0#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#03#, 16#E0#, 16#0C#, 16#30#, 16#18#, 16#18#, 16#10#, 16#08#,
16#30#, 16#08#, 16#20#, 16#08#, 16#20#, 16#18#, 16#20#, 16#18#, 16#20#,
16#10#, 16#30#, 16#20#, 16#38#, 16#60#, 16#0F#, 16#80#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#0F#, 16#E0#, 16#18#, 16#20#, 16#18#, 16#30#,
16#18#, 16#20#, 16#10#, 16#20#, 16#10#, 16#60#, 16#3F#, 16#80#, 16#30#,
16#00#, 16#30#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#60#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#03#, 16#E0#, 16#0C#, 16#30#,
16#18#, 16#18#, 16#10#, 16#08#, 16#30#, 16#08#, 16#20#, 16#08#, 16#20#,
16#18#, 16#20#, 16#18#, 16#20#, 16#10#, 16#31#, 16#B0#, 16#18#, 16#E0#,
16#0F#, 16#E0#, 16#00#, 16#20#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#, 16#E0#,
16#18#, 16#30#, 16#18#, 16#10#, 16#10#, 16#30#, 16#10#, 16#20#, 16#1F#,
16#C0#, 16#30#, 16#60#, 16#30#, 16#60#, 16#20#, 16#60#, 16#20#, 16#60#,
16#20#, 16#40#, 16#60#, 16#60#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#07#, 16#C0#, 16#08#, 16#60#, 16#10#, 16#20#, 16#10#, 16#00#, 16#18#,
16#00#, 16#1E#, 16#00#, 16#07#, 16#C0#, 16#00#, 16#C0#, 16#60#, 16#60#,
16#60#, 16#40#, 16#20#, 16#80#, 16#1F#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#1F#, 16#F0#, 16#03#, 16#00#, 16#03#, 16#00#, 16#02#,
16#00#, 16#02#, 16#00#, 16#06#, 16#00#, 16#06#, 16#00#, 16#06#, 16#00#,
16#04#, 16#00#, 16#04#, 16#00#, 16#0C#, 16#00#, 16#0C#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#08#, 16#18#, 16#18#, 16#10#, 16#18#,
16#10#, 16#18#, 16#10#, 16#10#, 16#30#, 16#10#, 16#30#, 16#30#, 16#20#,
16#30#, 16#20#, 16#30#, 16#60#, 16#20#, 16#60#, 16#30#, 16#C0#, 16#1F#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#10#, 16#10#, 16#10#,
16#30#, 16#18#, 16#20#, 16#18#, 16#60#, 16#18#, 16#40#, 16#08#, 16#C0#,
16#08#, 16#80#, 16#09#, 16#00#, 16#0B#, 16#00#, 16#0E#, 16#00#, 16#0E#,
16#00#, 16#0C#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#10#,
16#61#, 16#10#, 16#E1#, 16#10#, 16#E3#, 16#10#, 16#A3#, 16#11#, 16#A2#,
16#11#, 16#26#, 16#13#, 16#24#, 16#12#, 16#2C#, 16#1E#, 16#28#, 16#1C#,
16#38#, 16#1C#, 16#30#, 16#18#, 16#30#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#18#, 16#30#, 16#0C#, 16#20#, 16#0C#, 16#40#, 16#04#, 16#C0#,
16#07#, 16#80#, 16#03#, 16#00#, 16#07#, 16#00#, 16#0D#, 16#00#, 16#19#,
16#80#, 16#11#, 16#80#, 16#20#, 16#C0#, 16#60#, 16#C0#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#18#, 16#18#, 16#18#, 16#30#, 16#08#, 16#60#,
16#0C#, 16#40#, 16#04#, 16#C0#, 16#07#, 16#80#, 16#07#, 16#00#, 16#02#,
16#00#, 16#06#, 16#00#, 16#06#, 16#00#, 16#06#, 16#00#, 16#04#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#1F#, 16#F0#, 16#00#, 16#60#,
16#00#, 16#C0#, 16#01#, 16#80#, 16#01#, 16#00#, 16#03#, 16#00#, 16#06#,
16#00#, 16#0C#, 16#00#, 16#18#, 16#00#, 16#30#, 16#00#, 16#60#, 16#00#,
16#7F#, 16#C0#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#1C#, 16#00#,
16#18#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#30#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#60#, 16#00#,
16#60#, 16#00#, 16#40#, 16#00#, 16#40#, 16#00#, 16#40#, 16#00#, 16#E0#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#10#, 16#00#, 16#10#,
16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#,
16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#1C#, 16#00#, 16#08#, 16#00#, 16#08#,
16#00#, 16#08#, 16#00#, 16#18#, 16#00#, 16#18#, 16#00#, 16#10#, 16#00#,
16#10#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#, 16#20#, 16#00#, 16#20#,
16#00#, 16#20#, 16#00#, 16#60#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#06#, 16#00#, 16#06#,
16#00#, 16#0A#, 16#00#, 16#12#, 16#00#, 16#11#, 16#00#, 16#21#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#FF#, 16#80#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#18#,
16#00#, 16#08#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#, 16#00#,
16#11#, 16#80#, 16#00#, 16#80#, 16#01#, 16#80#, 16#1F#, 16#80#, 16#31#,
16#00#, 16#61#, 16#00#, 16#63#, 16#00#, 16#3D#, 16#80#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#18#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#,
16#17#, 16#00#, 16#19#, 16#80#, 16#30#, 16#80#, 16#20#, 16#80#, 16#20#,
16#80#, 16#20#, 16#80#, 16#61#, 16#80#, 16#73#, 16#00#, 16#5E#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#0F#, 16#00#, 16#11#, 16#80#, 16#21#, 16#80#, 16#20#,
16#00#, 16#60#, 16#00#, 16#60#, 16#00#, 16#61#, 16#00#, 16#23#, 16#00#,
16#3C#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#40#,
16#00#, 16#40#, 16#00#, 16#40#, 16#0E#, 16#C0#, 16#11#, 16#C0#, 16#21#,
16#80#, 16#20#, 16#80#, 16#60#, 16#80#, 16#61#, 16#80#, 16#61#, 16#00#,
16#23#, 16#00#, 16#3D#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#, 16#00#, 16#19#,
16#80#, 16#30#, 16#80#, 16#20#, 16#80#, 16#7F#, 16#80#, 16#60#, 16#00#,
16#60#, 16#00#, 16#21#, 16#00#, 16#1E#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#0C#, 16#00#, 16#18#, 16#00#, 16#18#, 16#00#, 16#3C#,
16#00#, 16#10#, 16#00#, 16#30#, 16#00#, 16#30#, 16#00#, 16#20#, 16#00#,
16#20#, 16#00#, 16#20#, 16#00#, 16#60#, 16#00#, 16#60#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#0F#, 16#C0#, 16#11#, 16#80#, 16#21#, 16#80#, 16#20#, 16#80#,
16#61#, 16#80#, 16#61#, 16#00#, 16#61#, 16#00#, 16#23#, 16#00#, 16#3D#,
16#00#, 16#02#, 16#00#, 16#46#, 16#00#, 16#7C#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#18#, 16#00#, 16#10#,
16#00#, 16#10#, 16#00#, 16#17#, 16#00#, 16#19#, 16#80#, 16#30#, 16#80#,
16#20#, 16#80#, 16#21#, 16#00#, 16#21#, 16#00#, 16#61#, 16#00#, 16#61#,
16#00#, 16#43#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#18#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#,
16#30#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#,
16#00#, 16#60#, 16#00#, 16#60#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#08#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#10#, 16#00#,
16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#, 16#20#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#60#, 16#00#,
16#40#, 16#00#, 16#C0#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#18#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#,
16#11#, 16#80#, 16#13#, 16#00#, 16#36#, 16#00#, 16#2C#, 16#00#, 16#34#,
16#00#, 16#26#, 16#00#, 16#62#, 16#00#, 16#62#, 16#00#, 16#43#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#18#, 16#00#, 16#18#, 16#00#,
16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#, 16#30#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#60#, 16#00#,
16#60#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#17#, 16#38#, 16#39#, 16#C8#, 16#31#,
16#88#, 16#21#, 16#08#, 16#21#, 16#08#, 16#21#, 16#18#, 16#63#, 16#18#,
16#63#, 16#10#, 16#42#, 16#10#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#17#, 16#00#, 16#39#,
16#80#, 16#30#, 16#80#, 16#21#, 16#80#, 16#21#, 16#00#, 16#21#, 16#00#,
16#61#, 16#00#, 16#61#, 16#00#, 16#43#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#,
16#00#, 16#11#, 16#80#, 16#30#, 16#80#, 16#20#, 16#80#, 16#60#, 16#80#,
16#61#, 16#80#, 16#61#, 16#00#, 16#23#, 16#00#, 16#3C#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#17#, 16#00#, 16#39#, 16#80#, 16#30#, 16#80#, 16#20#, 16#80#,
16#20#, 16#80#, 16#20#, 16#80#, 16#61#, 16#80#, 16#73#, 16#00#, 16#5E#,
16#00#, 16#40#, 16#00#, 16#40#, 16#00#, 16#C0#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#0F#, 16#C0#, 16#11#, 16#80#, 16#20#, 16#80#,
16#20#, 16#80#, 16#61#, 16#80#, 16#61#, 16#80#, 16#61#, 16#00#, 16#63#,
16#00#, 16#3D#, 16#00#, 16#03#, 16#00#, 16#03#, 16#00#, 16#02#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#16#, 16#00#, 16#38#, 16#00#,
16#30#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#60#,
16#00#, 16#60#, 16#00#, 16#40#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#0F#, 16#00#,
16#31#, 16#00#, 16#20#, 16#00#, 16#30#, 16#00#, 16#1C#, 16#00#, 16#07#,
16#00#, 16#43#, 16#00#, 16#62#, 16#00#, 16#3C#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#18#, 16#00#, 16#10#, 16#00#,
16#3C#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#, 16#20#, 16#00#, 16#20#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#60#, 16#00#, 16#30#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#10#, 16#80#, 16#30#, 16#80#, 16#20#, 16#80#, 16#21#,
16#80#, 16#21#, 16#80#, 16#21#, 16#00#, 16#61#, 16#00#, 16#63#, 16#00#,
16#3D#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#20#, 16#80#, 16#31#, 16#80#, 16#31#,
16#00#, 16#33#, 16#00#, 16#12#, 16#00#, 16#16#, 16#00#, 16#14#, 16#00#,
16#18#, 16#00#, 16#18#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#21#, 16#08#, 16#23#,
16#10#, 16#33#, 16#10#, 16#37#, 16#B0#, 16#35#, 16#A0#, 16#3D#, 16#E0#,
16#39#, 16#C0#, 16#39#, 16#C0#, 16#11#, 16#80#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#31#,
16#80#, 16#11#, 16#00#, 16#1A#, 16#00#, 16#0C#, 16#00#, 16#0C#, 16#00#,
16#1C#, 16#00#, 16#34#, 16#00#, 16#26#, 16#00#, 16#42#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#20#, 16#80#, 16#31#, 16#00#, 16#31#, 16#00#, 16#32#, 16#00#,
16#36#, 16#00#, 16#14#, 16#00#, 16#1C#, 16#00#, 16#18#, 16#00#, 16#10#,
16#00#, 16#10#, 16#00#, 16#20#, 16#00#, 16#C0#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#1F#, 16#80#, 16#01#, 16#00#, 16#02#, 16#00#,
16#04#, 16#00#, 16#0C#, 16#00#, 16#18#, 16#00#, 16#30#, 16#00#, 16#60#,
16#00#, 16#7E#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#06#,
16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#,
16#18#, 16#00#, 16#10#, 16#00#, 16#20#, 16#00#, 16#30#, 16#00#, 16#30#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#,
16#30#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#10#, 16#00#,
16#10#, 16#00#, 16#10#, 16#00#, 16#10#, 16#00#, 16#20#, 16#00#, 16#20#,
16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#40#, 16#00#,
16#40#, 16#00#, 16#40#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#18#, 16#00#, 16#08#, 16#00#,
16#08#, 16#00#, 16#08#, 16#00#, 16#08#, 16#00#, 16#18#, 16#00#, 16#18#,
16#00#, 16#08#, 16#00#, 16#10#, 16#00#, 16#30#, 16#00#, 16#20#, 16#00#,
16#20#, 16#00#, 16#20#, 16#00#, 16#20#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#1C#, 16#00#, 16#26#,
16#80#, 16#03#, 16#80#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#,
16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#, 16#00#);
Font_D : aliased constant Bitmap_Font :=
(
Bytes_Per_Glyph => 38,
Glyph_Width => 16,
Glyph_Height => 19,
Data => FreeSansOblique8pt7bBitmaps'Access);
Font : constant Bitmap_Font_Ref := Font_D'Access;
end GESTE_Fonts.FreeSansOblique8pt7b;
|
optikos/oasis | Ada | 8,141 | ads | -- Copyright (c) 2019 Maxim Reznik <[email protected]>
--
-- SPDX-License-Identifier: MIT
-- License-Filename: LICENSE
-------------------------------------------------------------
with Program.Lexical_Elements;
with Program.Elements.Defining_Names;
with Program.Elements.Parameter_Specifications;
with Program.Elements.Aspect_Specifications;
with Program.Elements.Procedure_Declarations;
with Program.Element_Visitors;
package Program.Nodes.Procedure_Declarations is
pragma Preelaborate;
type Procedure_Declaration is
new Program.Nodes.Node
and Program.Elements.Procedure_Declarations.Procedure_Declaration
and Program.Elements.Procedure_Declarations.Procedure_Declaration_Text
with private;
function Create
(Not_Token : Program.Lexical_Elements.Lexical_Element_Access;
Overriding_Token : Program.Lexical_Elements.Lexical_Element_Access;
Procedure_Token : not null Program.Lexical_Elements
.Lexical_Element_Access;
Name : not null Program.Elements.Defining_Names
.Defining_Name_Access;
Left_Bracket_Token : Program.Lexical_Elements.Lexical_Element_Access;
Parameters : Program.Elements.Parameter_Specifications
.Parameter_Specification_Vector_Access;
Right_Bracket_Token : Program.Lexical_Elements.Lexical_Element_Access;
Is_Token : Program.Lexical_Elements.Lexical_Element_Access;
Abstract_Token : Program.Lexical_Elements.Lexical_Element_Access;
With_Token : Program.Lexical_Elements.Lexical_Element_Access;
Aspects : Program.Elements.Aspect_Specifications
.Aspect_Specification_Vector_Access;
Semicolon_Token : not null Program.Lexical_Elements
.Lexical_Element_Access)
return Procedure_Declaration;
type Implicit_Procedure_Declaration is
new Program.Nodes.Node
and Program.Elements.Procedure_Declarations.Procedure_Declaration
with private;
function Create
(Name : not null Program.Elements.Defining_Names
.Defining_Name_Access;
Parameters : Program.Elements.Parameter_Specifications
.Parameter_Specification_Vector_Access;
Aspects : Program.Elements.Aspect_Specifications
.Aspect_Specification_Vector_Access;
Is_Part_Of_Implicit : Boolean := False;
Is_Part_Of_Inherited : Boolean := False;
Is_Part_Of_Instance : Boolean := False;
Has_Not : Boolean := False;
Has_Overriding : Boolean := False;
Has_Abstract : Boolean := False)
return Implicit_Procedure_Declaration
with Pre =>
Is_Part_Of_Implicit or Is_Part_Of_Inherited or Is_Part_Of_Instance;
private
type Base_Procedure_Declaration is
abstract new Program.Nodes.Node
and Program.Elements.Procedure_Declarations.Procedure_Declaration
with record
Name : not null Program.Elements.Defining_Names
.Defining_Name_Access;
Parameters : Program.Elements.Parameter_Specifications
.Parameter_Specification_Vector_Access;
Aspects : Program.Elements.Aspect_Specifications
.Aspect_Specification_Vector_Access;
end record;
procedure Initialize
(Self : aliased in out Base_Procedure_Declaration'Class);
overriding procedure Visit
(Self : not null access Base_Procedure_Declaration;
Visitor : in out Program.Element_Visitors.Element_Visitor'Class);
overriding function Name
(Self : Base_Procedure_Declaration)
return not null Program.Elements.Defining_Names.Defining_Name_Access;
overriding function Parameters
(Self : Base_Procedure_Declaration)
return Program.Elements.Parameter_Specifications
.Parameter_Specification_Vector_Access;
overriding function Aspects
(Self : Base_Procedure_Declaration)
return Program.Elements.Aspect_Specifications
.Aspect_Specification_Vector_Access;
overriding function Is_Procedure_Declaration_Element
(Self : Base_Procedure_Declaration)
return Boolean;
overriding function Is_Declaration_Element
(Self : Base_Procedure_Declaration)
return Boolean;
type Procedure_Declaration is
new Base_Procedure_Declaration
and Program.Elements.Procedure_Declarations.Procedure_Declaration_Text
with record
Not_Token : Program.Lexical_Elements.Lexical_Element_Access;
Overriding_Token : Program.Lexical_Elements.Lexical_Element_Access;
Procedure_Token : not null Program.Lexical_Elements
.Lexical_Element_Access;
Left_Bracket_Token : Program.Lexical_Elements.Lexical_Element_Access;
Right_Bracket_Token : Program.Lexical_Elements.Lexical_Element_Access;
Is_Token : Program.Lexical_Elements.Lexical_Element_Access;
Abstract_Token : Program.Lexical_Elements.Lexical_Element_Access;
With_Token : Program.Lexical_Elements.Lexical_Element_Access;
Semicolon_Token : not null Program.Lexical_Elements
.Lexical_Element_Access;
end record;
overriding function To_Procedure_Declaration_Text
(Self : aliased in out Procedure_Declaration)
return Program.Elements.Procedure_Declarations
.Procedure_Declaration_Text_Access;
overriding function Not_Token
(Self : Procedure_Declaration)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Overriding_Token
(Self : Procedure_Declaration)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Procedure_Token
(Self : Procedure_Declaration)
return not null Program.Lexical_Elements.Lexical_Element_Access;
overriding function Left_Bracket_Token
(Self : Procedure_Declaration)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Right_Bracket_Token
(Self : Procedure_Declaration)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Is_Token
(Self : Procedure_Declaration)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Abstract_Token
(Self : Procedure_Declaration)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function With_Token
(Self : Procedure_Declaration)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Semicolon_Token
(Self : Procedure_Declaration)
return not null Program.Lexical_Elements.Lexical_Element_Access;
overriding function Has_Not (Self : Procedure_Declaration) return Boolean;
overriding function Has_Overriding
(Self : Procedure_Declaration)
return Boolean;
overriding function Has_Abstract
(Self : Procedure_Declaration)
return Boolean;
type Implicit_Procedure_Declaration is
new Base_Procedure_Declaration
with record
Is_Part_Of_Implicit : Boolean;
Is_Part_Of_Inherited : Boolean;
Is_Part_Of_Instance : Boolean;
Has_Not : Boolean;
Has_Overriding : Boolean;
Has_Abstract : Boolean;
end record;
overriding function To_Procedure_Declaration_Text
(Self : aliased in out Implicit_Procedure_Declaration)
return Program.Elements.Procedure_Declarations
.Procedure_Declaration_Text_Access;
overriding function Is_Part_Of_Implicit
(Self : Implicit_Procedure_Declaration)
return Boolean;
overriding function Is_Part_Of_Inherited
(Self : Implicit_Procedure_Declaration)
return Boolean;
overriding function Is_Part_Of_Instance
(Self : Implicit_Procedure_Declaration)
return Boolean;
overriding function Has_Not
(Self : Implicit_Procedure_Declaration)
return Boolean;
overriding function Has_Overriding
(Self : Implicit_Procedure_Declaration)
return Boolean;
overriding function Has_Abstract
(Self : Implicit_Procedure_Declaration)
return Boolean;
end Program.Nodes.Procedure_Declarations;
|
AdaCore/libadalang | Ada | 23,420 | adb | --
-- Copyright (C) 2014-2022, AdaCore
-- SPDX-License-Identifier: Apache-2.0
--
with Interfaces; use Interfaces;
with Langkit_Support.Errors; use Langkit_Support.Errors;
package body Libadalang.Sources is
---------------------
-- Decode_Brackets --
---------------------
procedure Decode_Brackets
(Pattern : Text_Type;
Error : out Boolean;
Result : out Wide_Wide_Character) is
begin
if Pattern'Length < 6 or else Pattern'Length > 12
or else Pattern (Pattern'First .. Pattern'First + 1) /= "["""
or else Pattern (Pattern'Last - 1 .. Pattern'Last) /= """]"
then
Error := True;
return;
end if;
declare
Digits_String : Text_Type renames Pattern
(Pattern'First + 2 .. Pattern'Last - 2);
subtype Valid_Codepoint is Unsigned_32
range Wide_Wide_Character'Pos (Wide_Wide_Character'First)
.. Wide_Wide_Character'Pos (Wide_Wide_Character'Last);
Codepoint : Unsigned_32 := 0;
begin
if Digits_String'Length not in 2 | 4 | 6 | 8 then
Error := True;
return;
end if;
for C of Digits_String loop
declare
Charcode : constant Unsigned_32 := Wide_Wide_Character'Pos (C);
Digit : Unsigned_32;
begin
if C in '0' .. '9' then
Digit := Charcode - Wide_Wide_Character'Pos ('0');
elsif C in 'A' .. 'F' then
Digit := Charcode - Wide_Wide_Character'Pos ('A') + 10;
elsif C in 'a' .. 'f' then
Digit := Charcode - Wide_Wide_Character'Pos ('a') + 10;
else
Error := True;
return;
end if;
Codepoint := 16 * Codepoint + Digit;
end;
end loop;
if Codepoint not in Valid_Codepoint then
Error := True;
return;
end if;
Result := Wide_Wide_Character'Val (Codepoint);
Error := False;
end;
end Decode_Brackets;
------------------
-- Canonicalize --
------------------
function Canonicalize (Name : Text_Type) return Symbolization_Result is
Result : Text_Type (Name'Range);
Result_Last : Integer := Name'First - 1;
Fold_Casing : Boolean := True;
-- Whether we need to fold casing.
--
-- Our goal here is to fold the casing of everything but character
-- literals, so that 'A' and 'a' stay different. Single quotes can
-- appear in other context through (Pre'Class), so disable case folding
-- only when the first codepoint is a single quote.
I : Positive := Name'First;
begin
-- Decode bracket encodings
while I <= Name'Last loop
-- First, try to decode a brackets encoded char, if any
Result_Last := Result_Last + 1;
declare
C : constant Wide_Wide_Character := Name (I);
J : Positive := I + 1;
Error : Boolean;
begin
if C = '['
and then J in Name'Range
and then Name (J) = '"'
then
-- If we have the [" sequence, start decoding the brackets
-- construct.
while J < Name'Last and then Name (J) /= ']' loop
J := J + 1;
end loop;
Decode_Brackets (Name (I .. J), Error, Result (Result_Last));
if Error then
return Create_Error ("invalid brackets encoding");
end if;
I := J;
else
-- Otherwise, just copy the characters
Result (Result_Last) := C;
end if;
end;
-- Disable case folding if the first codepoint is a single quote
if I = Name'First and then Result (Result_Last) = ''' then
Fold_Casing := False;
end if;
-- Perform case folding when appropriate
if Fold_Casing then
Result (Result_Last) := To_Lower (Result (Result_Last));
end if;
I := I + 1;
end loop;
return Create_Symbol (Result (Result'First .. Result_Last));
end Canonicalize;
------------------------------
-- Decode_Character_Literal --
------------------------------
function Decode_Character_Literal (Text : Text_Type) return Character_Type
is
begin
if Text'Length /= 3
or else Text (Text'First) /= '''
or else Text (Text'Last) /= '''
then
raise Property_Error with "Invalid character literal";
end if;
return Text (Text'First + 1);
end Decode_Character_Literal;
---------------------------
-- Decode_String_Literal --
---------------------------
function Decode_String_Literal (Text : Text_Type) return Text_Type is
Result : Text_Type (Text'Range);
Last : Natural := Result'First - 1;
procedure Error;
procedure Put (C : Character_Type);
-----------
-- Error --
-----------
procedure Error is
begin
raise Property_Error with "Invalid string literal";
end Error;
---------
-- Put --
---------
procedure Put (C : Character_Type) is
begin
Last := Last + 1;
Result (Last) := C;
end Put;
Delimiter : Character_Type;
Last_Is_Delimiter : Boolean := False;
I : Natural;
begin
-- TODO: handle brackets encoding
-- Ensure we have valid delimiters at the start and the end of the input
-- text, and ensure they are the same delimiters.
if Text'Length < 2
or else Text (Text'First) not in '"' | '%'
or else Text (Text'First) /= Text (Text'Last)
then
Error;
end if;
Delimiter := Text (Text'First);
I := Text'First + 1;
while I < Text'Last loop
declare
C : constant Character_Type := Text (I);
begin
if C = Delimiter then
if Last_Is_Delimiter then
Put (C);
Last_Is_Delimiter := False;
else
Last_Is_Delimiter := True;
end if;
elsif C = '[' then
if Last_Is_Delimiter then
Error;
end if;
-- If this is not a brackets encoding, just forward characters
-- to Result, otherwise check that it is a valid one.
if
I + 1 = Text'Last
-- C is the last character
or else Text (I + 1) /= '"'
-- C is not followed by '"' ("[a" is not a brackets
-- encoding).
or else (I + 2 < Text'Last and then Text (I + 2) = '"')
-- C is followed by two quotes ("[""" is not a brackets
-- encoding).
then
Put (C);
else
-- Thanks to the above condition, we know that at this point
-- Text (I) is followed by a quote: look for the closing
-- sequence ('"' followed by ']').
declare
Closing_Bracket : Natural := 0;
begin
for J in I + 2 .. Text'Last - 1 loop
if Text (J) = '"' then
Closing_Bracket := J + 1;
if Closing_Bracket > Text'Last - 1
or else Text (Closing_Bracket) /= ']'
then
Error;
end if;
exit;
elsif Text (J) not in '0' .. '9'
| 'a' .. 'f'
| 'A' .. 'F'
then
Error;
end if;
end loop;
-- Make sure we found the closing sequence, then decode
-- it and move on to what comes next...
if Closing_Bracket = 0 then
Error;
end if;
declare
Denoted_Char : Character_Type;
Has_Error : Boolean;
begin
Decode_Brackets (Text (I .. Closing_Bracket),
Has_Error, Denoted_Char);
if Has_Error then
Error;
end if;
Put (Denoted_Char);
end;
I := Closing_Bracket;
end;
end if;
else
if Last_Is_Delimiter then
Error;
else
Put (C);
end if;
end if;
end;
I := I + 1;
end loop;
if Last_Is_Delimiter then
Error;
end if;
return Result (Result'First .. Last);
end Decode_String_Literal;
-------------------------------
-- Numeric literals handling --
-------------------------------
type String_Slice is record
First : Positive;
Last : Natural;
end record;
-- First class citizen type for string slices, with same semantics for
-- bounds: they are inclusive and Last < First means an empty slice.
subtype Numerical_Base is Natural range 2 .. 16;
type Parsed_Numeric_Literal is record
Base : Numerical_Base;
-- Base for the numeric literal
Numeral : String_Slice;
-- Slice for the basic number, to be interpreted in base 10 if Base is
-- empty, or in the corresponding base otherwise. This slice cannot be
-- empty and can contain underscores.
Fraction : String_Slice;
-- Slice for the fractional numeral of the number, to be interpreted in
-- base 10 if Base is empty, or in the corresponding base otherwise.
-- This slice can contain underscores. It is empty for integer literals
-- and non-empty for real literals. The leading `.` character is
-- stripped.
Exponent : Integer;
-- Exponent to apply to Numeral, so that the designated number is::
--
-- Numeral * Base ** Exponent.
end record;
-- Result of the analysis of a numeric literal string
function Is_Empty
(Slice : String_Slice) return Boolean is
(Slice.Last < Slice.First);
-- Return whether the given slice is empty
function Parse_Numeric_Literal
(Text : Text_Type) return Parsed_Numeric_Literal;
-- Parse Text as an Ada numeric literal. Raise a Property_Error if it is
-- invalid. Otherwise, return information about it.
function Strip_Underscores (Text : Text_Type) return String;
-- Turn Text, a wide wide string that contains only base-16 digits and
-- underscores, into a simple string, with the underscores stripped.
function Evaluate_Simple_Number (Text : Text_Type) return Integer is
(Integer'Value (Strip_Underscores (Text)));
procedure Error;
-- Raise a Property_Error for an invalid numeric literal
-----------------------
-- Strip_Underscores --
-----------------------
function Strip_Underscores (Text : Text_Type) return String is
subtype Expected_Character is Character_Type with Static_Predicate =>
Expected_Character in '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_';
Text_First : Positive;
Result : String (Text'Range);
Next : Natural := Result'First;
procedure Put (I : Positive);
-- Append Text (I) to Result, incrementing Next
---------
-- Put --
---------
procedure Put (I : Positive) is
begin
Result (Next) := Character'Val (Wide_Wide_Character'Pos (Text (I)));
Next := Next + 1;
end Put;
begin
-- Process the sign, if present
if Text /= "" and then Text (Text'First) in '+' | '-' then
Put (Text'First);
Text_First := Text'First + 1;
else
Text_First := Text'First;
end if;
-- Then process digits
for I in Text_First .. Text'Last loop
case Expected_Character (Text (I)) is
when '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' => Put (I);
when '_' => null;
end case;
end loop;
return Result (Result'First .. Next - 1);
end Strip_Underscores;
-----------
-- Error --
-----------
procedure Error is
begin
raise Property_Error with "invalid numeric literal";
end Error;
---------------------------
-- Parse_Numeric_Literal --
---------------------------
function Parse_Numeric_Literal
(Text : Text_Type) return Parsed_Numeric_Literal
is
subtype Index is Integer range Text'First - 1 .. Text'Last;
No_Index : constant Index := Index'First;
Result : Parsed_Numeric_Literal;
Base_First_Delimiter : Index := No_Index;
Base_Second_Delimiter : Index := No_Index;
Radix_Point : Index := No_Index;
begin
if Text = "" then
Error;
end if;
-- First, look for the two base delimiters ('#' or ':' characters) and
-- the radix point character: '.'.
for I in Text'Range loop
case Text (I) is
when '#' | ':' =>
if Base_Second_Delimiter /= No_Index then
Error;
elsif Base_First_Delimiter /= No_Index then
Base_Second_Delimiter := I;
-- When we have the second delimiter, make sure it is the
-- same as the first one.
if Text (Base_First_Delimiter)
/= Text (Base_Second_Delimiter)
then
Error;
end if;
else
Base_First_Delimiter := I;
end if;
when '.' =>
if Radix_Point /= No_Index then
Error;
else
Radix_Point := I;
end if;
when others =>
null;
end case;
end loop;
-- Either only two are present, either no one is
if Base_First_Delimiter /= No_Index
and then Base_Second_Delimiter = No_Index
then
Error;
end if;
if Base_First_Delimiter /= No_Index then
-- Decode the base, when present
declare
Base_Image : Text_Type renames
Text (Text'First .. Base_First_Delimiter - 1);
begin
if Base_Image'Length = 0 then
Error;
end if;
declare
Base : constant Integer := Evaluate_Simple_Number (Base_Image);
begin
if Base not in Numerical_Base then
Error;
end if;
Result.Base := Base;
end;
exception
when Constraint_Error =>
Error;
end;
Result.Numeral := (Base_First_Delimiter + 1,
Base_Second_Delimiter - 1);
-- Decode the exponent, if present
if Base_Second_Delimiter < Text'Last then
if Text (Base_Second_Delimiter + 1) not in 'e' | 'E' then
Error;
end if;
begin
Result.Exponent := Evaluate_Simple_Number
(Text (Base_Second_Delimiter + 2 .. Text'Last));
exception
when Constraint_Error =>
Error;
end;
else
Result.Exponent := 0;
end if;
else
-- When absent, fallback to its default and look for an exponent
Result.Base := 10;
-- Look for an exponent: whether we find it or not, we'll then know
-- how the numeral spans.
declare
Exponent_Delimiter : Index := No_Index;
begin
for I in Text'Range loop
if Text (I) in 'E' | 'e' then
if Exponent_Delimiter /= No_Index then
Error;
end if;
Exponent_Delimiter := I;
end if;
end loop;
Result.Numeral.First := Text'First;
if Exponent_Delimiter /= No_Index then
Result.Numeral.Last := Exponent_Delimiter - 1;
Result.Exponent := Evaluate_Simple_Number
(Text (Exponent_Delimiter + 1 .. Text'Last));
else
Result.Numeral.Last := Text'Last;
Result.Exponent := 0;
end if;
end;
end if;
-- Set fractional part if radix point is present
if Radix_Point /= No_Index then
Result.Fraction := (Radix_Point + 1,
Result.Numeral.Last);
Result.Numeral.Last := Radix_Point - 1;
-- Make sure the fractional part isn't empty
if Is_Empty (Result.Fraction) then
Error;
end if;
else
Result.Fraction := (1, 0);
end if;
-- Make sure the numeral only uses digits allowed by the base
declare
function Rebase
(Value, From, To : Wide_Wide_Character) return Wide_Wide_Character;
------------
-- Rebase --
------------
function Rebase
(Value, From, To : Wide_Wide_Character) return Wide_Wide_Character
is
From_Pos : constant Natural := Wide_Wide_Character'Pos (From);
To_Pos : constant Natural := Wide_Wide_Character'Pos (To);
Offset : constant Integer := To_Pos - From_Pos;
begin
return Wide_Wide_Character'Val
(Wide_Wide_Character'Pos (Value) + Offset);
end Rebase;
Digits_First : constant Wide_Wide_Character := '0';
Digits_Last : constant Wide_Wide_Character :=
(if Result.Base <= 10
then Wide_Wide_Character'Val (Wide_Wide_Character'Pos ('0')
+ Result.Base - 1)
else '9');
Lower_Ext_Digits_First : constant Wide_Wide_Character := 'a';
Lower_Ext_Digits_Last : constant Wide_Wide_Character :=
Wide_Wide_Character'Val
(Wide_Wide_Character'Pos (Lower_Ext_Digits_First)
+ Result.Base - 11);
Upper_Ext_Digits_First : constant Wide_Wide_Character := 'A';
Upper_Ext_Digits_Last : constant Wide_Wide_Character :=
Rebase (Lower_Ext_Digits_Last, 'a', 'A');
C : Wide_Wide_Character;
begin
for I in Result.Numeral.First .. Result.Numeral.Last loop
C := Text (I);
if C not in '_' | Digits_First .. Digits_Last
| Lower_Ext_Digits_First .. Lower_Ext_Digits_Last
| Upper_Ext_Digits_First .. Upper_Ext_Digits_Last
then
Error;
end if;
end loop;
end;
return Result;
end Parse_Numeric_Literal;
----------------------------
-- Decode_Integer_Literal --
----------------------------
procedure Decode_Integer_Literal
(Text : Text_Type;
Result : out GNATCOLL.GMP.Integers.Big_Integer)
is
use GNATCOLL.GMP;
use GNATCOLL.GMP.Integers;
function Slice (SS : String_Slice) return String is
(Strip_Underscores (Text (SS.First .. SS.Last)));
Parsed : constant Parsed_Numeric_Literal :=
Parse_Numeric_Literal (Text);
begin
-- Ensure that the literal doesn't contain a fractional part
if not Is_Empty (Parsed.Fraction) then
Error;
end if;
-- Evaluate the numeral part of the literal
declare
Numeral : constant String := Slice (Parsed.Numeral);
begin
Result.Set (Numeral, Int (Parsed.Base));
end;
-- Then evaluate and apply the exponent. For integer literals, negative
-- exponents are invalid.
if Parsed.Exponent < 0 then
Error;
elsif Parsed.Exponent > 0 then
declare
Exponent : GNATCOLL.GMP.Integers.Big_Integer;
begin
Exponent.Set (Long (Parsed.Base));
Exponent.Raise_To_N (Unsigned_Long (Parsed.Exponent));
Result.Multiply (Exponent);
end;
end if;
end Decode_Integer_Literal;
-------------------------
-- Decode_Real_Literal --
-------------------------
procedure Decode_Real_Literal
(Text : Text_Type;
Result : out GNATCOLL.GMP.Rational_Numbers.Rational)
is
use GNATCOLL.GMP;
use GNATCOLL.GMP.Integers;
use GNATCOLL.GMP.Rational_Numbers;
function Slice (SS : String_Slice) return String is
(Strip_Underscores (Text (SS.First .. SS.Last)));
Parsed : constant Parsed_Numeric_Literal :=
Parse_Numeric_Literal (Text);
Denominator, Exponent_BI : Big_Integer;
Exponent_R : Rational;
begin
-- Evaluate the numeral parts of the literal
declare
-- A real literal is of the following form:
--
-- numeral.numeral [exponent]
--
-- The Parsed record represents this literal, Parsed.Numeral
-- represents the integer part of the real while Parsed.Fraction
-- represents its fractional part. Parsed.Exponent is set to 0 if no
-- exponent is given.
Numeral : constant String := Slice (Parsed.Numeral);
Fraction : constant String := Slice (Parsed.Fraction);
begin
-- Ensure there is a fractional part
if Fraction'Length = 0 then
Error;
end if;
-- Turn a fractional number of the form III.FFF to a real fraction
-- First, eliminate the radix point by moving it to the right in
-- order to have an integer of the form IIIFFF (just concat the
-- Numeral and Fraction Strings here).
Result.Set (Numeral & Fraction, Int (Parsed.Base));
-- Build the denominator, which is the base raised to the number of
-- right-shifts we had to do to get rid of the fractional point (the
-- length of Fractional here).
Denominator.Set (Long (Parsed.Base));
Denominator.Raise_To_N (Unsigned_Long (Fraction'Length));
Result.Set_Den (Denominator);
-- Build the exponent fraction and apply it to Result
Exponent_BI.Set (Long (Parsed.Base));
-- Multiply result by exponent if positive, 1/exponent if negative
Exponent_BI.Raise_To_N (Unsigned_Long (abs Parsed.Exponent));
Exponent_R.Set (Exponent_BI);
if Parsed.Exponent < 0 then
declare
One : Rational;
begin
One.Set ("1");
Exponent_R.Set (One / Exponent_R);
end;
end if;
Result.Set (Result * Exponent_R);
end;
end Decode_Real_Literal;
end Libadalang.Sources;
|
zhmu/ananas | Ada | 6,857 | adb | ------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- G N A T . T H R E A D S --
-- --
-- B o d y --
-- --
-- Copyright (C) 1998-2022, AdaCore --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with Ada.Task_Identification; use Ada.Task_Identification;
with System.Task_Primitives.Operations;
with System.Tasking;
with System.Tasking.Stages; use System.Tasking.Stages;
with System.Tasking.Utilities;
with System.OS_Interface; use System.OS_Interface;
with System.Soft_Links; use System.Soft_Links;
with Ada.Unchecked_Conversion;
package body GNAT.Threads is
use System;
package STPO renames System.Task_Primitives.Operations;
type Thread_Id_Ptr is access all Thread_Id;
pragma Warnings (Off);
-- The following unchecked conversions are aliasing safe, since they
-- are never used to create pointers to improperly aliased data.
function To_Addr is new Ada.Unchecked_Conversion (Task_Id, Address);
function To_Id is new Ada.Unchecked_Conversion (Address, Task_Id);
function To_Id is new Ada.Unchecked_Conversion (Address, Tasking.Task_Id);
function To_Tid is new Ada.Unchecked_Conversion
(Address, Ada.Task_Identification.Task_Id);
function To_Thread is new Ada.Unchecked_Conversion (Address, Thread_Id_Ptr);
pragma Warnings (On);
type Code_Proc is access procedure (Id : Address; Parm : Void_Ptr);
task type Thread
(Stsz : Natural;
Prio : Any_Priority;
Parm : Void_Ptr;
Code : Code_Proc)
is
pragma Priority (Prio);
pragma Storage_Size (Stsz);
end Thread;
task body Thread is
begin
Code.all (To_Addr (Current_Task), Parm);
end Thread;
type Tptr is access Thread;
-------------------
-- Create_Thread --
-------------------
function Create_Thread
(Code : Address;
Parm : Void_Ptr;
Size : Natural;
Prio : Integer) return System.Address
is
TP : Tptr;
function To_CP is new Ada.Unchecked_Conversion (Address, Code_Proc);
begin
TP := new Thread (Size, Prio, Parm, To_CP (Code));
return To_Addr (TP'Identity);
end Create_Thread;
---------------------
-- Register_Thread --
---------------------
function Register_Thread return System.Address is
begin
return Task_Primitives.Operations.Register_Foreign_Thread.all'Address;
end Register_Thread;
-----------------------
-- Unregister_Thread --
-----------------------
procedure Unregister_Thread is
Self_Id : constant Tasking.Task_Id := Task_Primitives.Operations.Self;
begin
Self_Id.Common.State := Tasking.Terminated;
Destroy_TSD (Self_Id.Common.Compiler_Data);
Free_Task (Self_Id);
end Unregister_Thread;
--------------------------
-- Unregister_Thread_Id --
--------------------------
procedure Unregister_Thread_Id (Thread : System.Address) is
Thr : constant Thread_Id := To_Thread (Thread).all;
T : Tasking.Task_Id;
use type Tasking.Task_Id;
-- This use clause should be removed once a visibility problem
-- with the MaRTE run time has been fixed. ???
pragma Warnings (Off);
use type System.OS_Interface.Thread_Id;
pragma Warnings (On);
begin
STPO.Lock_RTS;
T := Tasking.All_Tasks_List;
loop
exit when T = null or else STPO.Get_Thread_Id (T) = Thr;
T := T.Common.All_Tasks_Link;
end loop;
STPO.Unlock_RTS;
if T /= null then
T.Common.State := Tasking.Terminated;
Destroy_TSD (T.Common.Compiler_Data);
Free_Task (T);
end if;
end Unregister_Thread_Id;
--------------------
-- Destroy_Thread --
--------------------
procedure Destroy_Thread (Id : Address) is
Tid : constant Task_Id := To_Id (Id);
begin
Abort_Task (Tid);
end Destroy_Thread;
----------------
-- Get_Thread --
----------------
procedure Get_Thread (Id : Address; Thread : Address) is
begin
To_Thread (Thread).all :=
Task_Primitives.Operations.Get_Thread_Id (To_Id (Id));
end Get_Thread;
procedure Get_Thread (Id : Task_Id; Thread : Address) is
begin
Get_Thread (To_Addr (Id), Thread);
end Get_Thread;
----------------------
-- Make_Independent --
----------------------
function Make_Independent return Boolean is
begin
return System.Tasking.Utilities.Make_Independent;
end Make_Independent;
----------------
-- To_Task_Id --
----------------
function To_Task_Id
(Id : System.Address) return Ada.Task_Identification.Task_Id
is
begin
return To_Tid (Id);
end To_Task_Id;
end GNAT.Threads;
|
gui-works/libagar | Ada | 19,619 | adb | ------------------------------------------------------------------------------
-- AGAR CORE LIBRARY --
-- A G A R . O B J E C T --
-- B o d y --
-- --
-- Copyright (c) 2018-2019, Julien Nadeau Carriere ([email protected]) --
-- Copyright (c) 2010, coreland ([email protected]) --
-- --
-- Permission to use, copy, modify, and/or distribute this software for any --
-- purpose with or without fee is hereby granted, provided that the above --
-- copyright notice and this permission notice appear in all copies. --
-- --
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES --
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF --
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR --
-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES --
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN --
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF --
-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. --
------------------------------------------------------------------------------
with Agar.Error;
package body Agar.Object is
use Interfaces.C;
use Agar.Event;
function New_Object
(Parent : in Object_Access;
Name : in String;
Class : in Class_Not_Null_Access) return Object_Access
is
Ch_Name : aliased C.char_array := C.To_C(Name);
begin
return AG_ObjectNew
(Parent => Parent.all'Address,
Name => CS.To_Chars_Ptr(Ch_Name'Unchecked_Access),
Class => Class);
end;
function New_Object
(Parent : in Object_Access;
Class : in Class_Not_Null_Access) return Object_Access is
begin
return AG_ObjectNew
(Parent => Parent.all'Address,
Name => CS.Null_Ptr,
Class => Class);
end;
function New_Object
(Class : in Class_Not_Null_Access) return Object_Access is
begin
return AG_ObjectNew
(Parent => System.Null_Address,
Name => CS.Null_Ptr,
Class => Class);
end;
procedure Init_Object
(Object : in Object_Not_Null_Access;
Class : in Class_Not_Null_Access;
Static : in Boolean := False) is
begin
if Static then
AG_ObjectInitStatic (Object, Class);
else
AG_ObjectInit (Object, Class);
end if;
end;
procedure Attach
(Parent : in Object_Access;
Child : in Object_not_null_Access)
is
begin
AG_ObjectAttach
(Parent => Parent,
Child => Child);
end;
function Find
(Root : in Object_Not_Null_Access;
Path : in String) return Object_Access
is
Ch_Path : aliased C.char_array := C.To_C(Path);
begin
return AG_ObjectFindS
(Root => Root,
Path => CS.To_Chars_Ptr(Ch_Path'Unchecked_Access));
end;
function Find_Parent
(Object : in Object_Not_Null_Access;
Name : in String;
Class : in String) return Object_Access
is
Ch_Name : aliased C.char_array := C.To_C(Name);
Ch_Class : aliased C.char_array := C.To_C(Class);
begin
return AG_ObjectFindParent
(Object => Object,
Name => CS.To_Chars_Ptr(Ch_Name'Unchecked_Access),
Class => CS.To_Chars_Ptr(Ch_Class'Unchecked_Access));
end;
function Find_Child
(Parent : in Object_Not_Null_Access;
Name : in String) return Object_Access
is
Ch_Name : aliased C.char_array := C.To_C(Name);
begin
return AG_ObjectFindChild
(Parent => Parent,
Name => CS.To_Chars_Ptr(Ch_Name'Unchecked_Access));
end;
function Get_Name (Object : in Object_Not_Null_Access) return String
is
Ch_Name : aliased C.char_array (0 .. C.size_t(HIERARCHY_MAX));
Result : C.int;
begin
Result := AG_ObjectCopyName
(Object => Object,
Buffer => Ch_Name'Address,
Size => Ch_Name'Length);
if Integer(Result) /= 0 then
raise Program_Error with Agar.Error.Get_Error;
end if;
return C.To_Ada(Ch_Name);
end;
procedure Set_Name
(Object : in Object_Not_Null_Access;
Name : in String)
is
Ch_Name : aliased C.char_array := C.To_C(Name);
begin
AG_ObjectSetNameS
(Object => Object,
Name => CS.To_Chars_Ptr(Ch_Name'Unchecked_Access));
end;
function Generate_Name
(Object : in Object_Not_Null_Access;
Class : in Class_Not_Null_Access) return String
is
Ch_Name : aliased C.char_array (0 .. C.size_t(NAME_MAX));
begin
AG_ObjectGenName
(Object => Object,
Class => Class,
Buffer => Ch_Name'Address,
Size => Ch_Name'Length);
return C.To_Ada(Ch_Name);
end;
function Generate_Name
(Object : in Object_Not_Null_Access;
Prefix : in String) return String
is
Ch_Name : aliased C.char_array (0 .. C.size_t(NAME_MAX));
Ch_Prefix : aliased C.char_array := C.To_C(Prefix);
begin
AG_ObjectGenNamePfx
(Object => Object,
Prefix => CS.To_Chars_Ptr(Ch_Prefix'Unchecked_Access),
Buffer => Ch_Name'Address,
Size => Ch_Name'Length);
return C.To_Ada(Ch_Name);
end;
procedure Register_Namespace
(Name : in String;
Prefix : in String;
URL : in String)
is
Ch_Name : aliased C.char_array := C.To_C(Name);
Ch_Prefix : aliased C.char_array := C.To_C(Prefix);
Ch_URL : aliased C.char_array := C.To_C(URL);
begin
AG_RegisterNamespace
(Name => CS.To_Chars_Ptr(Ch_Name'Unchecked_Access),
Prefix => CS.To_Chars_Ptr(Ch_Prefix'Unchecked_Access),
URL => CS.To_Chars_Ptr(Ch_URL'Unchecked_Access));
end;
procedure Unregister_Namespace
(Name : in String)
is
Ch_Name : aliased C.char_array := C.To_C(Name);
begin
AG_UnregisterNamespace(CS.To_Chars_Ptr(Ch_Name'Unchecked_Access));
end;
function Create_Class
(Hierarchy : in String;
Object_Size : in Natural;
Class_Size : in Natural;
Major : in Natural := 1;
Minor : in Natural := 0;
Init_Func : in Init_Func_Access := null;
Reset_Func : in Reset_Func_Access := null;
Destroy_Func : in Destroy_Func_Access := null;
Load_Func : in Load_Func_Access := null;
Save_Func : in Save_Func_Access := null;
Edit_Func : in Edit_Func_Access := null) return Class_Not_Null_Access
is
Ch_Hierarchy : aliased C.char_array := C.To_C(Hierarchy);
Class : Class_Access;
begin
Class := AG_CreateClass
(Hierarchy => CS.To_Chars_Ptr(Ch_Hierarchy'Unchecked_Access),
Object_Size => AG_Size(Object_Size / System.Storage_Unit),
Class_Size => AG_Size(Class_Size / System.Storage_Unit),
Major => C.unsigned(Major),
Minor => C.unsigned(Minor));
if Class = null then
raise Program_Error with Agar.Error.Get_Error;
end if;
if Init_Func /= null then AG_ClassSetInit (Class, Init_Func); end if;
if Reset_Func /= null then AG_ClassSetReset (Class, Reset_Func); end if;
if Destroy_Func /= null then AG_ClassSetDestroy (Class, Destroy_Func); end if;
if Load_Func /= null then AG_ClassSetLoad (Class, Load_Func); end if;
if Save_Func /= null then AG_ClassSetSave (Class, Save_Func); end if;
if Edit_Func /= null then AG_ClassSetEdit (Class, Edit_Func); end if;
return Class;
end Create_Class;
procedure Class_Set_Init
(Class : in Class_Not_Null_Access;
Init_Func : in Init_Func_Access) is
begin
AG_ClassSetInit(Class, Init_Func);
end;
function Class_Set_Init
(Class : in Class_Not_Null_Access;
Init_Func : in Init_Func_Access) return Init_Func_Access is
begin
return AG_ClassSetInit(Class, Init_Func);
end;
procedure Class_Set_Reset
(Class : in Class_Not_Null_Access;
Reset_Func : in Reset_Func_Access) is
begin
AG_ClassSetReset(Class, Reset_Func);
end;
function Class_Set_Reset
(Class : in Class_Not_Null_Access;
Reset_Func : in Reset_Func_Access) return Reset_Func_Access is
begin
return AG_ClassSetReset(Class, Reset_Func);
end;
procedure Class_Set_Destroy
(Class : in Class_Not_Null_Access;
Destroy_Func : in Destroy_Func_Access) is
begin
AG_ClassSetDestroy(Class, Destroy_Func);
end;
function Class_Set_Destroy
(Class : in Class_Not_Null_Access;
Destroy_Func : in Destroy_Func_Access) return Destroy_Func_Access is
begin
return AG_ClassSetDestroy(Class, Destroy_Func);
end;
procedure Class_Set_Load
(Class : in Class_Not_Null_Access;
Load_Func : in Load_Func_Access) is
begin
AG_ClassSetLoad(Class, Load_Func);
end;
function Class_Set_Load
(Class : in Class_Not_Null_Access;
Load_Func : in Load_Func_Access) return Load_Func_Access is
begin
return AG_ClassSetLoad(Class, Load_Func);
end;
procedure Class_Set_Save
(Class : in Class_Not_Null_Access;
Save_Func : in Save_Func_Access) is
begin
AG_ClassSetSave(Class, Save_Func);
end;
function Class_Set_Save
(Class : in Class_Not_Null_Access;
Save_Func : in Save_Func_Access) return Save_Func_Access is
begin
return AG_ClassSetSave(Class, Save_Func);
end;
procedure Class_Set_Edit
(Class : in Class_Not_Null_Access;
Edit_Func : in Edit_Func_Access) is
begin
AG_ClassSetEdit(Class, Edit_Func);
end;
function Class_Set_Edit
(Class : in Class_Not_Null_Access;
Edit_Func : in Edit_Func_Access) return Edit_Func_Access is
begin
return AG_ClassSetEdit(Class, Edit_Func);
end;
function Lookup_Class
(Class : in String) return Class_Access
is
Ch_Class : aliased C.char_array := C.To_C(Class);
begin
return AG_LookupClass
(Class => CS.To_Chars_Ptr(Ch_Class'Unchecked_Access));
end;
function Load_Class
(Class : in String) return Class_Access
is
Ch_Class : aliased C.char_array := C.To_C(Class);
begin
return AG_LoadClass
(Class => CS.To_Chars_Ptr(Ch_Class'Unchecked_Access));
end;
procedure Register_Module_Directory
(Path : in String)
is
Ch_Path : aliased C.char_array := C.To_C(Path);
begin
AG_RegisterModuleDirectory
(Path => CS.To_Chars_Ptr(Ch_Path'Unchecked_Access));
end;
procedure Unregister_Module_Directory
(Path : in String)
is
Ch_Path : aliased C.char_array := C.To_C(Path);
begin
AG_UnregisterModuleDirectory
(Path => CS.To_Chars_Ptr(Ch_Path'Unchecked_Access));
end;
function Is_Of_Class
(Object : in Object_Not_Null_Access;
Pattern : in String) return Boolean
is
Ch_Pattern : aliased C.char_array := C.To_C(Pattern);
begin
return AG_OfClass
(Object => Object,
Pattern => CS.To_Chars_Ptr(Ch_Pattern'Unchecked_Access)) = 1;
end;
function Is_A
(Object : in Object_Not_Null_Access;
Pattern : in String) return Boolean
is
Ch_Pattern : aliased C.char_array := C.To_C(Pattern);
begin
return AG_OfClass
(Object => Object,
Pattern => CS.To_Chars_Ptr(Ch_Pattern'Unchecked_Access)) = 1;
end;
function In_Use (Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectInUse(Object) = 1;
end;
-------------------
-- Serialization --
-------------------
function Load (Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectLoad(Object) = 0;
end;
function Load
(Object : in Object_Not_Null_Access;
File : in String) return Boolean
is
Ch_File : aliased C.char_array := C.To_C(File);
begin
return AG_ObjectLoadFromFile
(Object => Object,
File => CS.To_Chars_Ptr(Ch_File'Unchecked_Access)) = 0;
end;
function Load_Data (Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectLoadData(Object) = 0;
end;
function Load_Data
(Object : in Object_Not_Null_Access;
File : in String) return Boolean
is
Ch_File : aliased C.char_array := C.To_C(File);
begin
return AG_ObjectLoadDataFromFile
(Object => Object,
File => CS.To_Chars_Ptr(Ch_File'Unchecked_Access)) = 0;
end;
function Load_Generic (Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectLoadGeneric(Object) = 0;
end;
function Load_Generic
(Object : in Object_Not_Null_Access;
File : in String) return Boolean
is
Ch_File : aliased C.char_array := C.To_C(File);
begin
return AG_ObjectLoadGenericFromFile
(Object => Object,
File => CS.To_Chars_Ptr(Ch_File'Unchecked_Access)) = 0;
end;
function Save (Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectSave(Object) = 0;
end;
function Save
(Object : in Object_Not_Null_Access;
File : in String) return Boolean
is
Ch_File : aliased C.char_array := C.To_C(File);
begin
return AG_ObjectSaveToFile
(Object => Object,
File => CS.To_Chars_Ptr(Ch_File'Unchecked_Access)) = 0;
end;
function Save_All (Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectSaveAll(Object) = 0;
end;
function Serialize
(Object : in Object_Not_Null_Access;
Source : in DS.Data_Source_Not_Null_Access) return Boolean is
begin
return AG_ObjectSerialize(Object, Source) = 0;
end;
function Unserialize
(Object : in Object_Not_Null_Access;
Source : in DS.Data_Source_Not_Null_Access) return Boolean is
begin
return AG_ObjectUnserialize(Object, Source) = 0;
end;
function Read_Header
(Source : in DS.Data_Source_Not_Null_Access;
Header : in Header_Access) return Boolean is
begin
return AG_ObjectReadHeader (Source, Header) = 0;
end;
function Page_In
(Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectPageIn (Object) = 0;
end;
function Page_Out
(Object : in Object_Not_Null_Access) return Boolean is
begin
return AG_ObjectPageOut (Object) = 0;
end;
------------
-- Events --
------------
function Set_Event
(Object : in Object_Not_Null_Access;
Event : in String;
Func : in Event_Func_Access;
Async : in Boolean := False;
Propagate : in Boolean := False) return Event_Not_Null_Access
is
Ch_Event : aliased C.char_array := C.To_C(Event);
Result : constant Event_Not_Null_Access := AG_SetEvent
(Object => Object,
Event => CS.To_Chars_Ptr(Ch_Event'Unchecked_Access),
Func => Func,
Format => CS.Null_Ptr);
begin
-- TODO Async, Propagate
return (Result);
end;
procedure Set_Event
(Object : in Object_Not_Null_Access;
Event : in String;
Func : in Event_Func_Access;
Async : in Boolean := False;
Propagate : in Boolean := False)
is
Ch_Event : aliased C.char_array := C.To_C(Event);
begin
AG_SetEvent
(Object => Object,
Event => CS.To_Chars_Ptr(Ch_Event'Unchecked_Access),
Func => Func,
Format => CS.Null_Ptr);
end;
function Add_Event
(Object : in Object_Not_Null_Access;
Event : in String;
Func : in Event_Func_Access;
Async : in Boolean := False;
Propagate : in Boolean := False) return Event_Not_Null_Access
is
Ch_Event : aliased C.char_array := C.To_C(Event);
Result : constant Event_Not_Null_Access := AG_AddEvent
(Object => Object,
Event => CS.To_Chars_Ptr(Ch_Event'Unchecked_Access),
Func => Func,
Format => CS.Null_Ptr);
begin
return (Result);
end;
procedure Add_Event
(Object : in Object_Not_Null_Access;
Event : in String;
Func : in Event_Func_Access;
Async : in Boolean := False;
Propagate : in Boolean := False)
is
Ch_Event : aliased C.char_array := C.To_C(Event);
begin
AG_AddEvent
(Object => Object,
Event => CS.To_Chars_Ptr(Ch_Event'Unchecked_Access),
Func => Func,
Format => CS.Null_Ptr);
end;
procedure Post_Event
(Source : in Object_Access;
Target : in Object_Not_Null_Access;
Event : in String)
is
Ch_Event : aliased C.char_array := C.To_C(Event);
begin
AG_PostEvent
(Source => Source,
Target => Target,
Event => CS.To_Chars_Ptr(Ch_Event'Unchecked_Access),
Format => CS.Null_Ptr);
end;
procedure Post_Event
(Source : in Object_Access;
Target : in Object_Not_Null_Access;
Event : in Event_Not_Null_Access) is
begin
AG_PostEventByPtr
(Source => Source,
Target => Target,
Event => Event,
Format => CS.Null_Ptr);
end;
procedure Post_Event
(Target : in Object_Not_Null_Access;
Event : in String)
is
Ch_Event : aliased C.char_array := C.To_C(Event);
begin
AG_PostEvent
(Source => Null,
Target => Target,
Event => CS.To_Chars_Ptr(Ch_Event'Unchecked_Access),
Format => CS.Null_Ptr);
end;
procedure Post_Event
(Target : in Object_Not_Null_Access;
Event : in Event_Not_Null_Access) is
begin
AG_PostEventByPtr
(Source => Null,
Target => Target,
Event => Event,
Format => CS.Null_Ptr);
end;
procedure Debug
(Object : in Object_Access;
Message : in String)
is
Ch_Format : aliased C.char_array := C.To_C("%s");
Ch_Message : aliased C.char_array := C.To_C(Message);
begin
AG_Debug
(Object => Object,
Format => CS.To_Chars_Ptr(Ch_Format'Unchecked_Access),
Message => CS.To_Chars_Ptr(Ch_Message'Unchecked_Access));
end;
------------
-- Timers --
------------
function Add_Timer
(Object : in Object_Access;
Timer : in TMR.Timer_not_null_Access;
Interval : in Interfaces.Unsigned_32;
Func : in TMR.Timer_Callback) return Boolean
is
begin
return 0 = AG_AddTimer
(Object => Object,
Timer => Timer,
Interval => Interval,
Func => Func,
Flags => 0,
Format => CS.Null_Ptr);
end;
function Add_Timer
(Object : in Object_Access;
Interval : in Interfaces.Unsigned_32;
Func : in TMR.Timer_Callback) return TMR.Timer_Access
is
begin
return AG_AddTimerAuto
(Object => Object,
Interval => Interval,
Func => Func,
Format => CS.Null_Ptr);
end;
---------------
-- Variables --
---------------
function Defined
(Object : in Object_not_null_Access;
Variable : in String) return Boolean
is
Ch_Name : aliased C.char_array := C.To_C(Variable);
Result : C.int;
begin
Lock(Object);
Result := AG_Defined
(Object => Object,
Name => CS.To_Chars_Ptr(Ch_Name'Unchecked_Access));
Unlock(Object);
return Result = 1;
end;
--
-- Compare two variables with no dereference. Discrete types are compared
-- by value. Strings are compared case-sensitively. Reference types are
-- compared by their pointer value.
--
function "=" (Left, Right : in Variable_not_null_Access) return Boolean is
begin
return 0 = AG_CompareVariables (Left, Right);
end;
end Agar.Object;
|
jscparker/math_packages | Ada | 25,890 | ads |
-- package Orthogonal_Polys
--
-- Generates orthogonal polynomials on dicrete grid points using the
-- Gram-Schmidt method. The package also provides a routine for
-- polynomial least-squares curve fitting: procedure Poly_Fit.
--
-- The least-squares curve fitting routine could have been defined in
-- another package, but it turned out to be useful in the test procedures,
-- and least-squares curve fitting is the primary application of the code.
-- The algorithm is due to Shampine (1), who was the first to show how
-- high order least squares polynomial fits could be performed on arbitrary
-- data sets.
--
-- Given a set of X-axis grid points {X_0, ..., X_m} and a set of weights
-- associated with those points {W_0, ..., W_m} there is a unique set of
-- Gram-Schmidt orthogonal polynomials {Q_0(X), ..., Q_m(X)} that range in
-- degree from 0 to m, where m is one less than the number of distinct
-- data points.
--
-- This package defines routines for generating the polynomials Q_j(X)
-- and routines for calculating values, derivatives, and integrals of
-- functions F(X) composed of linear combinations of these polynomials:
-- F(X) = SUM [C_j * Q_j(X)]. The Clenshaw summation formula is used
-- for most of the work.
--
-- The polynomials generated are Legendre polynomials if the weights
-- are constant. If the weights go like W_j = Sqrt (1 - X_j**2) on
-- X in [-1,1], then Tchebychev polys are generated. Other well-known
-- polys are associated with other weights and intervals on X. These
-- polys are not identical to the kind associated with continuous
-- intervals of X, (although they agree in the limit of large data sets.)
-- The continuous kind are orthogonal respect integration:
-- Integral_Of [Q_j(X) * Q_k(X) * W(X) * dX] = 0 if j /= k.
-- The discrete
-- polys are orthogonal respect an inner product, a summation over
-- discrete data points SUM [Q_j(X_i) * Q_k(X_i) * W_i] = 0 if j /= k.
-- (A different package provides routines that generate values of the
-- continuous polys. It also uses the Clenshaw summation formula.)
--
-- Notes On Use
--
-- The procedure Poly_Fit fits a polynomial in variable X to a
-- function F(X) defined by a set of points in the form (X_i, F(X_i)).
-- The fit minimizes the sum of the squares of the residuals,
-- the error terms Error_i in the equation:
--
-- N
-- F (X_i) = SUM ( C_m * Q_m(X_i) ) + Error_i
-- m=0
--
-- where the functions Q are orthogonal polynomials, and N is the
-- order of the polynomial we are fitting to F.
-- A linear combination of Q_m, with coefficients C_m is the best fit:
--
-- N
-- Best_Fit_Poly (X) = SUM ( C_m * Q_m (X) )
-- m=0
--
-- The procedure returns this sum, and also the coefficients C_m.
--
-- C(i) is the array of coefficients of the orthogonal Polynomials
-- that are fit to the data. Alpha(i) and Beta(i) are returned in the
-- record Poly_Set of type Polynomial. These are
-- used to generate the orthogonal polynomials via the recurrence relations
-- given below.
--
-- If the user wants the values of the best fit polynomial at values
-- of X not among those in the data set, then one uses function
-- Poly_Value to sum the polynomial at X via the recurrence relation
-- defined by Alpha, Beta and C.
--
-- Often one wants the coefficients of the powers of X in the
-- least-squares polynomial, instead of the coefficients of the
-- orthogonal polynomials Q_m. For example, one commonly want
-- the best linear fit to the data, or the best parabolic fit
-- to the data, F = E_0 + E_1 * X + E_2 * X**2,
-- and so one wants the coefficients E_m in the sum:
--
-- N
-- Best_Fit_Poly (X) = SUM ( E_m * X**m ).
-- m=0
--
-- The coefficients E_m are returned in the array Poly_Coeffients by
-- the procedure Get_Coeffs_Of_Powers_Of_X.
--
-- The procedure Poly_Fit also returns:
--
-- Mean_Square_Error = SUM (Error_i * Error_i) / Number_Of_Data_Points.
--
-- If the data set is noisy, then it often happens that as you raise the
-- order polynomial, the Mean_Square_Error quickly reaches some minimum.
-- On the other hand, if you are fitting to a noiseless function, say
-- to calculate its derivatives numerically, then one can often see
-- continued improvement in the fit even as the order of the polynomial
-- becomes very large.
--
-- Notes On the Algorithm
--
-- Take any set of orthogonal functions, {Q_n}, project them one by one
-- onto a data set exactly as you would construct a Fourier series,
-- and you have performed a linear least squares fit to the data.
-- More precisely, you have found coefficients C_n such that the
-- function formed by summing the orthogonal functions Q_n with
-- coefficients C_n has minimum distance from the data in the least
-- squares sense. No matrix inversion is required because the
-- functions Q_n are orthogonal.
-- A more rigorous definition: Given functions
-- Q_0, Q_1, ... Q_n, ...we want to find coefficients C_0, C_1, ...
-- C_n,... such that the sum of the squares of the errors Error_i are
-- minimized in the equation:
--
-- N
-- F (X_i) = SUM ( C_m * Q_m(X_i) ) + Error_i,
-- m=0
--
-- where the functions Q will be orthogonal in this package, and N is the
-- order of the polynomial we are fitting to F. The problem is best
-- formulated in terms of inner products with respect weights
-- W(X_i). Inner product is defined (A, B) = SUM (A(X_i)*B(X_i)*W(X_i)).
-- You get the formula for the least squares fit by setting the gradiant
-- of the sum of the squares of Error_i to zero and solving for the
-- coefficients C_n. The equation to solve for C_n turns out to be:
--
-- N
-- (Q_n, F) = SUM ( C_m * (Q_n, Q_m) ).
-- m=0
--
-- This is a matrix equation whose solution requires an LU decomposition
-- or the like when the basis functions Q are not orthogonal. But
-- when the basis functions Q are orthogonal, the solution of this
-- set of simultaneous equations is trivial:
--
-- C_n = (Q_n, F) / (Q_n, Q_n),
--
-- since the matrix on the RHS of the matrix equation is diagonal.
--
-- Here is the algorithm. First we construct the orthogonal polynomials
-- Q with respect to the weights W_i as follows:
--
-- Q_0 = 1
-- Q_m = x*Q_m-1 - SUM (B_mj * Q_j )
-- j<k
--
-- The sum on the RHS is there only to make Q_m orthogonal to all previous
-- Q's. The coefficients Beta_mj that achieve this are
--
-- Beta_mj = (x*Q_m-1, Q_j) / (Q_j, Q_j).
--
-- To see this take the inner product of the equation for Q_m with Q_j,
-- j<k, set it equal to zero, use recursion. The form given above is the
-- one that generalizes to many dimensions. In one dimension the formula
-- simplifies so that only two of the Beta coefficients are nonzero.
-- We call these two Alpha and Beta:
--
-- Q_0 = 1
-- Q_1 = (X - Alpha_1)
-- Q_m = (X - Alpha_m) * Q_m-1 - Beta_m*Q_m-2
-- where
-- Alpha_m = (X*Q_m-1, Q_m-1) / (Q_m-1, Q_m-1)
-- Beta_m = (X*Q_m-1, Q_m-2) / (Q_m-2, Q_m-2)
--
-- Can be shown: Beta_m = (Q_m-1, Q_m-1) / (Q_m-2, Q_m-2) which is
-- the form used below. (Just use X*Q_m-2 = (X-Alpha)*Q_m-2 + ... = Q_m-1 + ...).
--
-- function Poly_Value:
--
-- So now we've calculated coefficients A_m and B_m which, via the
-- recurrence relation given above, generate the orthogonal polynomials
-- Q_m. Along the way we calculated the coefficients C_m which
-- sum the Q_m's to give a least-squares fit to the function F. Now
-- to make use of these coefficients to calculate the value of the
-- the least-squares polynomial at any X, we use Clenshaw's formula.
-- Clenshaw's method is a well known algorithm for summing any
-- series C_m*Q_m(X) where Q_m is defined by a recurrence relation.
-- Clenshaw's recurrence formula is used in everything that follows,
-- so we review it next in its most general form.
--
-- Clenshaw's formula is an algorithm for evaluating sums over
-- functions Q_m (X) that are defined by recurrence relations of the sort:
--
-- Q_0 = some given function of X
-- Q_1 = Alpha (1, X) * Q_0 (X)
-- Q_m = Alpha (m, X) * Q_m-1 (X) + Beta (m, X) * Q_m-2 (X)
--
-- The procedure here evaluates the sum
-- n
-- F_n(X) = SUM ( C_m * Q_m(X) )
-- m=0
--
-- where the coefficients C_m are given quantities, as are Alpha and
-- Beta. The scheme implemented here is stabler and more accurate
-- than attempts to directly perform the sum for F_n.
--
-- Clenshaw proved that F_n is given by the following formula
--
-- (*) F_n(X) = D_0*Q_0(X) + D_1*(Q_1(X) - Alpha(1,X)*Q_0(X)).
--
-- where the D_m are functions of X that satisfy:
--
-- D_n+2 = 0
-- D_n+1 = 0
-- D_m = C_m + Alpha(m+1,X) * D_m+1(X) + Beta(m+2,X) * D_m+2(X)
--
-- The proof of (*) is straightforward. Solve for C_m in the equation for
-- D_m above and plug it into the sum that defines F_n to get
--
-- n
-- F_n = SUM (D_m - Alpha(m+1)*D_m+1 - Beta(m+1)*D_m+2 ) * Q_m
-- k=0
-- n
-- F_n = D_0*Q_0 + D_1*Q_1 + SUM ( D_m*Q_m )
-- m=2
-- n
-- -Alpha(1)*D_1*Q_0 + SUM (-Alpha(m)*D_m*Q_m-1 )
-- m=2
-- n
-- + SUM (-Beta(m) *D_m*Q_m-2 ).
-- m=2
--
-- Now factor out D_m from the three SUM terms above, and notice
-- that what remains is just the recurrance relation that defines
-- Q_m for m > 1. It evaluates to zero, leaving
--
-- F_n(X) = D_0*Q_0(X) + D_1*(Q_1(X) - Alpha(1,X)*Q_0(X)).
--
-- In the special case of Othogonal polynomials, where Q_0 = 1, and
-- Q_1(X) = Alpha(1,X)*Q_0(X), we have that F_n(X) = D_0.
--
--
-- procedure Poly_Derivatives:
--
-- How do we get the derivatives of the best-fit polynomial? Just
-- take the derivative of the Clenshaw recurrence formula given above.
-- In the special case of orthogonal polynomials it is particulary
-- easy. By differentiating the formula given above p times it's easy
-- to see that the p-th derivative of the D_m functions of X satisfy:
--
-- D_n+2(p,X) = 0
-- D_n+1(p,X) = 0
-- D_m(p,X)
-- = p*D_m+1(p-1,X) + (X - Alpha_m)*D_m+1(p,X) - Beta_m*D_m+2(p,X)
--
-- where D(p,X) is the pth derivative of D(X). It follows that the
-- p-th derivative of the sum of C_m*Q_m(X) equals D_0(p,X).
--
--
-- procedure Get_Coefficients_Of_Powers_Of_X:
--
-- Clenshaw's formula is used to get Coeffs. The
-- coefficients of the following D polynomials are put into arrays
-- D_0, D_1, and D_2, and advanced recursively until the final
-- D_0 = SUM {C_k * Q_k} is found. This will be named Poly_Coefficients.
--
-- D_n+2(X) = 0
-- D_n+1(X) = 0
-- D_m(X) = C_m + (X - Alpha_m+1)*D_m+1(X) - Beta_m+2*D_m+2(X)
--
-- where n = Desired_Poly_Degree and m is in 0..n.
-- The arrays D_0, D_1, and D_2 are already initialized.
-- They contain the coeff's of powers of X in the orthogonal
-- polynomials D_m, D_m+1, D_m+2. The formulas above
-- imply: for m in Desired_Poly_Degree .. 0:
--
-- D_0(k) := D_1(k-1) - Alpha(m)*D_1(k) - Beta(m)*D_2(k)
-- D_0(0) := D_0(0) + C(m)
--
-- where k goes from 1 to Desired_Poly_Degree in the first equation.
-- Notice that the above formula must be modified at m = n and m = n-1.
-- This gives the Poly coefficients for X in the range [-2,2]. Some
-- poly shifting has to be done to get the coefficients in the the
-- true range. (Common source of floating point overflow.)
--
-- The algorithm can be generalized to functions F of many variables (2).
--
-- (1) Forsythe, G. E., J. SIAM 5 (1957), 74-87.
-- This package follows Shampine:
-- Shampine and Allen, Numerical Computing, An Introduction,(1973).
-- (2) Bartels and Jezioranski, ACM Transactions on Math. Software,
-- Vol. 11 (1985), p. 201-217.
--
generic
type Real is private;
-- The package can be instantiated with either conventional Floats,
-- or with an abstract (extended precision) floating point.
type Points_Index is range <>;
type Data is array (Points_Index) of Real;
Zero : Real;
One : Real;
-- For initializing objects of private type Real. 'Real' can be
-- an extended precision abstract float type.
with function "*" (X : Real; Y : Real) return Real is <>;
with function "+" (X : Real; Y : Real) return Real is <>;
with function "-" (X : Real; Y : Real) return Real is <>;
with function "/" (X : Real; Y : Real) return Real is <>;
with function "<" (X : Real; Y : Real) return Boolean is <>;
with function "**" (X : Real; N : Integer) return Real is <>;
with function "-" (X : Real) return Real is <>;
package Orthogonal_Polys is
type Integer32 is range -2**31 .. 2**31-1;
Max_Order_Of_Poly : constant Integer32 := Integer32 (Data'Length - 1);
-- May want to set this to a smaller value if the number of
-- data points is >> the max order of polys. In any case,
-- this constant cannot be greater than Data'Length - 1.
-- Section 1.
--
-- Data structures for polynomials.
-- Type Poly_Data holds the actual values of individual Polys at X-axis
-- grid points X_j. Also holds a normalization factor for the Poly.
-- Type Polynomial holds coefficients Alpha and Beta for generating
-- Polys recursively via the Gram-Schmidt method. (Plus other things.)
subtype Coeff_Index is Integer32 range 0..Max_Order_Of_Poly;
-- Index for array of polynomial coefficients. The Max_Order must be
-- less than the number of data points. An assertion verifies this.
-- (The max number if data points is taken to be Data'Length.)
type Poly_Data is record
Points : Data := (others => Zero);
First : Points_Index := Points_Index'First;
Last : Points_Index := Points_Index'Last;
Squared : Real := Zero;
Degree : Coeff_Index := Coeff_Index'First;
end record;
-- Value of the polynomial at the X axis grid points. Squared will
-- contain a factor for normalizing the polys. The Polys are not
-- contained in normalized form in the field Points. Squared will
-- contain Inner_Product (Poly, Poly, First, Last, Weights).
-- Poly_data.Points holds the explicit Y values of the poly defined at
-- points X_j .. X_k, where j and k are Data_First amd Data_Last as
-- stored in Points. These end points are input by the user on
-- a call to Start_Gram_Schmidt_Poly_Recursion. This is where the
-- Data_First and Data_Last, (start and end of the Polys) are input,
-- nowhere else. After this, all operations on this data are in
-- the range Data_First..Data_Last. To turn off data points in that
-- range you set their associated weights to 0.0.
type Recursion_Coeffs is array (Coeff_Index) of Real;
-- The Alpha and Beta coefficients for generating polynomial recursively.
-- These are calculated in calls to Get_Next_Poly and
-- Start_Gram_Schmidt_Poly_Recursion.
type Polynomials is limited private;
-- Contains the Gram_Schmidt recursion coefficients Alpha and Beta
-- for generating polynomials up to some order. That order is given
-- by Degree_Of_Poly, also contained in Polynomials. The only way
-- to use type Polynomials is to initialize it with a call to
-- Start_Gram_Schmidt_Poly_Recursion, and to update it with calls
-- to Get_Next_Poly.
-- Section 2.
--
-- Construct the unique set of orthogonal polys associated with
-- X-axis grid points "X_axis" and weights "Weights", on range
-- First .. Last of Points_Index.
procedure Start_Gram_Schmidt_Poly_Recursion
(X_axis : in Data;
Weights : in Data;
First, Last : in Points_Index;
Poly_0, Poly_1 : in out Poly_Data;
Poly_Set : out Polynomials);
-- Starts off the process of generating polys. All computation
-- is henceforth done on interval First..Last of Points_Index.
-- If you want to leave out point (X(i), Y(i)) during the fitting,
-- then set the corresponding weight to
-- Weight(i) := Zero;
-- Typical setting for Weights is simply Weights := (others => 1.0).
-- This is the only place that First, Last, and X_axis are input. They
-- are stored in Poly_Set and Poly_N, and subsequent operations
-- read them from these objects.
-- The in out parameters (Poly_O and Poly_1) need no initialization.
procedure Get_Next_Poly
(Poly_0, Poly_1 : in Poly_Data;
Weights : in Data;
Poly_2 : in out Poly_Data;
Poly_Set : in out Polynomials);
-- Generate successive polys given the 2 previous polys.
-- This procedure creates Poly_2, and updates Poly_Set so that it
-- includes recursion coefficients for generating Poly_2.
-- "Weights" must contain the same weights used in the call to
-- Start_Gram_Schmidt_Poly_Recursion that started off the
-- process of creating poly_0 and poly_1.
-- Section 3.
--
-- Section contains procedures that operate on type Polynomial.
-- The procedures sum linear combinations of orthogonal polynomials, and
-- calculate values, derivatives and integrals of these sums.
-- The coefficients
-- of the polynomials in the linear combinations, called C_k,
-- will be stored in array C of type Poly_Sum_Coeffs.
-- If you want the value of a single Poly, its derivatives, or
-- integrals, then you use a delta-function for C_k: let C_k = 0.0
-- everywhere except at the index of the desired Poly, which you set to
-- 1.0. Can also get coefficients of powers of X, but be aware that
-- this is an error prone process.
function Max_Permissable_Degree_Of (P : Polynomials) return Coeff_Index;
-- P is the unique set of (GS) orthogonal polys associated with a set
-- of grid points {X_j} and a set of weights {W_j}. The max degree
-- of this set of orthogonal polys is limited by the number of distinct
-- points in set {X_j}, (the number that have nonzero weight). That
-- number is returned by this function.
subtype Poly_Sum_Coeffs is Recursion_Coeffs;
-- Multiply these coefficients by polynomials, sum to make linear
-- combinations. These sums (usually Least squares
-- fits) are evaluated by calls to Poly_Value, Derivatives_Of etc.
function Poly_Value
(X : in Real;
C : in Poly_Sum_Coeffs;
Poly_Set : in Polynomials)
return Real;
-- Returns the value of poly Q(X) = SUM {C_m * Q_m(X) }, at arbitrary X.
-- The orthogonal polys Q_m are defined by Poly_Set. Uses the Clenshaw
-- summation formula.
-- (The procedure Polynomial_Fit, by the way, only calculates
-- Q for values of X that are in the data set (X_j), and returns them in
-- the array Best_Fit_Poly.)
function Poly_Integral
(X : in Real;
C : in Poly_Sum_Coeffs;
Poly_Set : in Polynomials;
Order_Of_Integration : in Coeff_Index := 1)
return Real;
-- Returns the indefinite integral of poly Q(X) = SUM [ C_k * Q_k(X) ].
-- The orthogonal polys Q_k are defined by Poly_Set. To get the
-- integral of Q on [A, B] use Integral(B) - Integral(A). Uses Clenshaw
-- summation formula to get coefficients of powers of X, then integrates
-- by summing the poly with Horner's rule. Not the best way to do
-- quadrature in general, but it's a good way to get integrals of
-- polynomial least-square fits to data.
subtype Derivative_List is Recursion_Coeffs;
subtype Derivatives_Index is Coeff_Index; -- Starts at 0.
procedure Poly_Derivatives
(Derivatives : in out Derivative_List;
X : in Real;
Order_Of_Deriv : in Derivatives_Index;
C : in Poly_Sum_Coeffs;
Poly_Set : in Polynomials);
-- Returns the derivative of the polynomial
-- Q(X) = SUM [ C_k * Q_k(X) ]. The m-th derivative is returned
-- as the m-th component of the array Derivatives. All lower order
-- derivatives are return also, since they must be calculated along
-- along the way. You may not need them, but when you do, it is
-- better not to call the procedure m times (when you can call it
-- only once).
--
-- Procedure Poly_Derivatives provides another way of
-- of getting the coefficients (E) of powers of X. The m-th derivative
-- of the polynomial, evaluated at X = 0, equals E_m multiplied
-- by m!. In many ways this method may be superior to that used in
-- in procedure Get_Coefficients_Of_Powers_Of_X. It's likely
-- to work in situations where Get_Coeffs... fails, (and vice-versa).
-- Also, if you calculate a high degree polynomial fit, you may use
-- Poly_Derivative to get just the first few E_m, rather than all
-- of them, which is what Get_Coeffs_Of_Powers_Of_X does, and which
-- may lead to floating point exceptions.
type Powers_Of_X_Coeffs is array (Coeff_Index) of Real;
procedure Get_Coeffs_Of_Powers_Of_X
(Coeffs : out Powers_Of_X_Coeffs;
C : in Poly_Sum_Coeffs;
Poly_Set : in Polynomials);
-- Often one wants the coefficients of the powers of X in the
-- least-squares polynomial, instead of the coefficients C_m of the
-- orthogonal polynomials Q_m. For example, one commonly wants
-- the best linear fit to the data, or the best parabolic fit
-- to the data, F = E_0 + E_1 * X + E_2 * X**2,
-- and so one wants the coefficients E_m in the sum:
--
-- N
-- Best_Fit_Poly (X) = SUM ( E_m * X**m ).
-- m=0
--
-- The coefficients E_m are returned in the array Coeffs.
-- This procedure attempts to get all of the coefficients of the powers
-- of X up to the degree of the polynomial that is contained in
-- the Data structure Poly_Set. This polynomial degree is usually,
-- but not always, the degree set by the parameter Desired_Poly_Degree
-- in the procedure Poly_Fit.
-- If you calculate a high order polynomial least squares fit,
-- it may not be a good idea the use this routine. This is a common
-- source of floating point overflow, catastrophic loss of precision,
-- etc. These problems depend on a lot of things, so you can give it
-- a try if you want, but this routine is really mostly for
-- getting the best fit line, or parabola. In these cases set
-- Desired_Poly_Degree to 1 or 2 in procedure polynomial_fit to get
-- the polynomial fit Poly_Set. Then send Poly_Set into this routine.
--
-- The procedure Poly_Derivatives above provides another way of
-- of getting the coefficients of powers of X. See the above note.
function Inner_Product
(X, Y : in Data;
First, Last : in Points_Index;
Weights : in Data)
return Real;
-- Usually you project the polynomials onto the data with the
-- function Inner_Product in order to make least squares fits.
-- Also useful in testing orthogonality of polys. This is the
-- weighted inner product over which the polynomials (calculated
-- below) are orthogonal.
procedure Poly_Fit
(Data_To_Fit : in Data;
X_axis, Weights : in Data;
First, Last : in Points_Index;
Desired_Poly_Degree : in Coeff_Index;
Best_Fit_Poly : in out Poly_Data;
Best_Fit_Coeffs : in out Poly_Sum_Coeffs;
Poly_Set : in out Polynomials;
Mean_Square_Error : out Real);
private
Two : constant Real := One + One;
Four : constant Real := Two + Two;
Smallest_Delta_X : constant Real := Two ** (-128);
-- Some arbitrary small number. Another choice might be:
-- Smallest_Delta_X : constant Real := 2.0**(-Real'Safe_Emax / 2);
-- If Data points are not separated by greater than Smallest_Delta_X,
-- then an exception will be raised.
-- Prevents some of the more immediate of the possible overflows.
-- This number is comparable to the square root of Real'Safe_Small
-- because Safe_Small is 2.0**(-Safe_Emax-1). (Safe_Emin = -Safe_Emax.)
-- A typical Safe_Small for IEEE 754 is 10**(-308). The number
-- here would be approximately 10**(-154).
Smallest_Weight : constant Real := Two ** (-256);
-- Set it to some arbitrary small number. Another choice
-- might be Smallest_Weight : constant Real := Real'Safe_Small;
-- If a weight is set below this value, then we pretend
-- that the data point is not in the set.
Max_No_Of_Data_Points : constant Integer32 := Integer32 (Data'Length);
-- So can verify that polynomial degree is less than
-- the number of data points.
type X_Axis_Scale is record
Slope : Real := One;
Const : Real := Zero;
end record;
type Polynomials is record
Alpha : Recursion_Coeffs := (others => Zero);
Beta : Recursion_Coeffs := (others => Zero);
Scale_Factors : X_Axis_Scale;
X_scaled : Data := (others => Zero);
Degree_Of_Poly : Coeff_Index := Coeff_Index'First;
Max_Permissable_Degree_Of_Poly : Coeff_Index := Coeff_Index'First;
end record;
pragma Assert (Coeff_Index'First = 0);
pragma Assert (Coeff_Index'Last >= 3);
end Orthogonal_Polys;
|
Componolit/libsparkcrypto | Ada | 2,584 | ads | -------------------------------------------------------------------------------
-- This file is part of libsparkcrypto.
--
-- @author Alexander Senier
-- @date 2019-01-10
--
-- Copyright (C) 2018 Componolit GmbH
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- * Redistributions of source code must retain the above copyright notice,
-- this list of conditions and the following disclaimer.
--
-- * Redistributions in binary form must reproduce the above copyright
-- notice, this list of conditions and the following disclaimer in the
-- documentation and/or other materials provided with the distribution.
--
-- * Neither the name of the nor the names of its contributors may be used
-- to endorse or promote products derived from this software without
-- specific prior written permission.
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
-- BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-- POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------
with AUnit; use AUnit;
with AUnit.Test_Cases;
with Ada.Calendar;
-- @summary Benchmarks
package LSC_Internal_Benchmark is
type Test_Case is new AUnit.Test_Cases.Test_Case with
record
Reference_Start : Ada.Calendar.Time;
Reference_Stop : Ada.Calendar.Time;
Test_Start : Ada.Calendar.Time;
Test_Stop : Ada.Calendar.Time;
end record;
overriding
function Routine_Name (T : Test_Case) return Message_String;
procedure Register_Tests (T : in out Test_Case);
-- Register routines to be run
function Name (T : Test_Case) return Message_String;
-- Provide name identifying the test case
end LSC_Internal_Benchmark;
|
ekoeppen/STM32_Generic_Ada_Drivers | Ada | 212 | ads | with STM32_SVD.TIM;
with STM32_SVD; use STM32_SVD;
package STM32GD.Timer is
type Timer_Callback_Type is access procedure;
type Timer_Type is (Timer_14, Timer_15, Timer_16, Timer_17);
end STM32GD.Timer;
|
reznikmm/matreshka | Ada | 4,216 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Localization, Internationalization, Globalization for Ada --
-- --
-- Tools Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2011, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
-- Provides test to search for 'install' utility.
------------------------------------------------------------------------------
with Configure.Abstract_Tests;
package Configure.Tests.Install is
type Install_Test is
new Configure.Abstract_Tests.Abstract_Test with private;
overriding function Name (Self : Install_Test) return String;
-- Returns name of the test to be used in reports.
overriding function Help
(Self : Install_Test) return Unbounded_String_Vector;
-- Returns help information for test.
overriding procedure Execute
(Self : in out Install_Test;
Arguments : in out Unbounded_String_Vector);
-- Executes test's actions. All used arguments must be removed from
-- Arguments.
private
type Install_Test is
new Configure.Abstract_Tests.Abstract_Test with null record;
end Configure.Tests.Install;
|
landgraf/nanomsg-ada | Ada | 1,574 | ads | -- The MIT License (MIT)
-- Copyright (c) 2015 Pavel Zhukov <[email protected]>
-- Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:
-- The above copyright notice and this permission notice shall be included in all
-- copies or substantial portions of the Software.
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-- SOFTWARE.
with Aunit; use Aunit;
with Nanomsg.Socket;
with Aunit.Simple_Test_Cases;
package Nanomsg.Test_Socket_Create_Close is
type TC is new Simple_Test_Cases.Test_Case with record
Socket : Nanomsg.Socket.Socket_T;
end record;
overriding
procedure Run_Test (T : in out TC);
overriding
function Name (T : TC) return Message_String;
end Nanomsg.Test_Socket_Create_Close;
|
zhmu/ananas | Ada | 4,600 | ads | ------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- S Y S T E M . V A L _ R E A L --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2022, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This package contains routines for scanning real values for use in
-- Text_IO.Float_IO and the Value attribute.
generic
type Num is digits <>;
Maxpow : Positive;
Powten_Address : System.Address;
type Uns is mod <>;
package System.Val_Real is
pragma Preelaborate;
function Scan_Real
(Str : String;
Ptr : not null access Integer;
Max : Integer) return Num;
-- This function scans the string starting at Str (Ptr.all) for a valid
-- real literal according to the syntax described in (RM 3.5(43)). The
-- substring scanned extends no further than Str (Max). There are three
-- cases for the return:
--
-- If a valid real is found after scanning past any initial spaces, then
-- Ptr.all is updated past the last character of the real (but trailing
-- spaces are not scanned out).
--
-- If no valid real is found, then Ptr.all points either to an initial
-- non-blank character, or to Max + 1 if the field is all spaces and the
-- exception Constraint_Error is raised.
--
-- If a syntactically valid real is scanned, but the value is out of
-- range, or, in the based case, the base value is out of range or there
-- is an out of range digit, then Ptr.all points past the real literal,
-- and Constraint_Error is raised.
--
-- Note: these rules correspond to the requirements for leaving the
-- pointer positioned in Text_Io.Get
--
-- Note: if Str is null, i.e. if Max is less than Ptr, then this is a
-- special case of an all-blank string, and Ptr is unchanged, and hence
-- is greater than Max as required in this case.
--
-- Note: this routine should not be called with Str'Last = Positive'Last.
-- If this occurs Program_Error is raised with a message noting that this
-- case is not supported. Most such cases are eliminated by the caller.
function Value_Real (Str : String) return Num;
-- Used in computing X'Value (Str) where X is a floating-point type or an
-- ordinary fixed-point type. Str is the string argument of the attribute.
-- Constraint_Error is raised if the string is malformed, or if the value
-- out of range of Num.
end System.Val_Real;
|
burratoo/Acton | Ada | 3,725 | ads | ------------------------------------------------------------------------------------------
-- --
-- OAK PROCESSOR SUPPORT PACKAGE --
-- ATMEL ATMEGA128P --
-- --
-- AVR.IO --
-- --
-- Copyright (C) 2012-2021, Patrick Bernardi --
-- --
------------------------------------------------------------------------------------------
with System.Storage_Elements; use System.Storage_Elements;
package AVR.IO with Preelaborate is
----------------------------------------------------------------------------
-- Memory Address
----------------------------------------------------------------------------
PINA_Address : constant Integer_Address := 16#20#;
DDRA_Address : constant Integer_Address := 16#21#;
PORTA_Address : constant Integer_Address := 16#22#;
PINB_Address : constant Integer_Address := 16#23#;
DDRB_Address : constant Integer_Address := 16#24#;
PORTB_Address : constant Integer_Address := 16#25#;
PINC_Address : constant Integer_Address := 16#26#;
DDRC_Address : constant Integer_Address := 16#27#;
PORTC_Address : constant Integer_Address := 16#28#;
----------------------------------------------------------------------------
-- IO Types
----------------------------------------------------------------------------
type Pin_Numbers is range 0 .. 7;
type Direction_Type is (Input, Output);
type IO_Port_Type is array (Pin_Numbers) of Boolean with Pack;
type Direction_Port_Type is array (Pin_Numbers) of Direction_Type
with Pack;
----------------------------------------------------------------------------
-- Hardware Respresentations
----------------------------------------------------------------------------
for Direction_Type use (Input => 0, Output => 1);
----------------------------------------------------------------------------
-- IO Registers
----------------------------------------------------------------------------
Port_A_Data_Register : IO_Port_Type;
for Port_A_Data_Register'Address use
System'To_Address (PORTA_Address);
Port_A_Data_Direction_Register : Direction_Port_Type;
for Port_A_Data_Direction_Register'Address use
System'To_Address (DDRA_Address);
Port_A_Input_Pin_Address : IO_Port_Type;
for Port_A_Input_Pin_Address'Address use
System'To_Address (PINA_Address);
Port_B_Data_Register : IO_Port_Type;
for Port_B_Data_Register'Address use
System'To_Address (PORTB_Address);
Port_B_Data_Direction_Register : Direction_Port_Type;
for Port_B_Data_Direction_Register'Address use
System'To_Address (DDRB_Address);
Port_B_Input_Pin_Address : IO_Port_Type;
for Port_B_Input_Pin_Address'Address use
System'To_Address (PINB_Address);
Port_C_Data_Register : IO_Port_Type;
for Port_C_Data_Register'Address use
System'To_Address (PORTC_Address);
Port_C_Data_Direction_Register : Direction_Port_Type;
for Port_C_Data_Direction_Register'Address use
System'To_Address (DDRC_Address);
Port_C_Input_Pin_Address : IO_Port_Type;
for Port_C_Input_Pin_Address'Address use
System'To_Address (PINC_Address);
end AVR.IO;
|
PThierry/ewok-kernel | Ada | 1,507 | adb | --
-- Copyright 2018 The wookey project team <[email protected]>
-- - Ryad Benadjila
-- - Arnauld Michelizza
-- - Mathieu Renard
-- - Philippe Thierry
-- - Philippe Trebuchet
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
--
--
with ewok.tasks; use ewok.tasks;
with ewok.tasks_shared; use ewok.tasks_shared;
with ewok.perm; use ewok.perm;
with ewok.debug;
with m4.scb;
package body ewok.syscalls.reset
with spark_mode => off
is
procedure svc_reset
(caller_id : in ewok.tasks_shared.t_task_id;
mode : in ewok.tasks_shared.t_task_mode)
is
begin
if not ewok.perm.ressource_is_granted (PERM_RES_TSK_RESET, caller_id)
then
set_return_value (caller_id, mode, SYS_E_DENIED);
ewok.tasks.set_state (caller_id, mode, TASK_STATE_RUNNABLE);
return;
end if;
m4.scb.reset;
debug.panic ("soc.nvic.reset failed !?!");
end svc_reset;
end ewok.syscalls.reset;
|
micahwelf/FLTK-Ada | Ada | 525 | ads |
package FLTK.Images.Pixmaps.XPM is
type XPM_Image is new Pixmap with private;
type XPM_Image_Reference (Data : not null access XPM_Image'Class) is
limited null record with Implicit_Dereference => Data;
package Forge is
function Create
(Filename : in String)
return XPM_Image;
end Forge;
private
type XPM_Image is new Pixmap with null record;
overriding procedure Finalize
(This : in out XPM_Image);
end FLTK.Images.Pixmaps.XPM;
|
reznikmm/matreshka | Ada | 5,498 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Web Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2015, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with League.Calendars;
with League.Strings;
with SQL.Options;
with OPM.Engines;
with AWFC.Accounts.Users;
with Forum.Categories.References;
with Forum.Topics.References;
with Forum.Posts.References;
package Forum.Forums is
type Forum is tagged limited record
Engine : aliased OPM.Engines.Engine;
end record;
procedure Initialize
(Self : in out Forum'Class;
Driver : League.Strings.Universal_String;
Options : SQL.Options.SQL_Options);
function Get_Categories
(Self : in out Forum'Class)
return Standard.Forum.Categories.References.Category_Vector;
procedure Get_Category
(Self : in out Forum'Class;
Identifier : Standard.Forum.Categories.Category_Identifier;
Value : out Standard.Forum.Categories.References.Category;
Found : out Boolean);
function Create_Category
(Self : in out Forum'Class;
Title : League.Strings.Universal_String;
Description : League.Strings.Universal_String)
return Standard.Forum.Categories.References.Category;
procedure Get_Topic
(Self : in out Forum'Class;
Category : Standard.Forum.Categories.Category_Identifier;
Identifier : Standard.Forum.Topics.Topic_Identifier;
Value : out Standard.Forum.Topics.References.Topic;
Found : out Boolean);
function Create_Topic
(Self : in out Forum'Class;
User : AWFC.Accounts.Users.User_Access;
Category : Standard.Forum.Categories.References.Category;
Title : League.Strings.Universal_String;
Description : League.Strings.Universal_String;
Creation_Time : League.Calendars.Date_Time := League.Calendars.Clock)
return Standard.Forum.Topics.References.Topic;
function Create_Post
(Self : in out Forum'Class;
User : AWFC.Accounts.Users.User_Access;
Topic : Standard.Forum.Topics.References.Topic;
Text : League.Strings.Universal_String;
Creation_Time : League.Calendars.Date_Time := League.Calendars.Clock)
return Standard.Forum.Posts.References.Post;
end Forum.Forums;
|
AdaCore/libadalang | Ada | 395 | ads | -- This tests that directly navigating to the body of a nested package (here:
-- Bar) will automatically load the body unit. If that's not the case,
-- navigation will not be able to find the body of the nested package.
package Foo_Child_Only
with Disable_Navigation
is
I : Integer;
package Bar is
procedure Baz;
end Bar;
S : String := "hello!";
end Foo_Child_Only;
|
zhmu/ananas | Ada | 4,647 | ads | ------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- A D A . S T R I N G S . U N B O U N D E D . A U X --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2022, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This child package of Ada.Strings.Unbounded provides some specialized
-- access functions which are intended to allow more efficient use of the
-- facilities of Ada.Strings.Unbounded, particularly by other layered
-- utilities (such as GNAT.SPITBOL.Patterns).
package Ada.Strings.Unbounded.Aux is
pragma Preelaborate;
subtype Big_String is String (1 .. Positive'Last);
pragma Suppress_Initialization (Big_String);
-- Type used to obtain string access to given address. Initialization is
-- suppressed, since we never want to have variables of this type, and
-- we never want to attempt initialiazation of virtual variables of this
-- type (e.g. when pragma Normalize_Scalars is used).
type Big_String_Access is access all Big_String;
for Big_String_Access'Storage_Size use 0;
-- We use this access type to pass a pointer to an area of storage to be
-- accessed as a string. Of course when this pointer is used, it is the
-- responsibility of the accessor to ensure proper bounds. The storage
-- size clause ensures we do not allocate variables of this type.
procedure Get_String
(U : Unbounded_String;
S : out Big_String_Access;
L : out Natural);
pragma Inline (Get_String);
-- Return the internal string pointer used in the representation of an
-- unbounded string as well as the actual current length (which may be less
-- than S.all'Length because in general there can be extra space assigned).
-- The characters of this string may be not be modified via the returned
-- pointer, and are valid only as long as the original unbounded string is
-- not accessed or modified.
--
-- This procedure is much more efficient than the use of To_String
-- since it avoids the need to copy the string. The lower bound of the
-- referenced string returned by this call is always one, so the actual
-- string data is always accessible as S (1 .. L).
procedure Set_String
(U : out Unbounded_String;
Length : Positive;
Set : not null access procedure (S : out String));
pragma Inline (Set_String);
-- Create an unbounded string U with the given Length, using Set to fill
-- the contents of U.
end Ada.Strings.Unbounded.Aux;
|
reznikmm/matreshka | Ada | 6,836 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Ada Modeling Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2012, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
-- This file is generated, don't edit it.
------------------------------------------------------------------------------
with AMF.Elements;
with AMF.Internals.Helpers;
with AMF.Internals.Tables.Utp_Attributes;
with AMF.UML.Call_Operation_Actions;
with AMF.Visitors.Utp_Iterators;
with AMF.Visitors.Utp_Visitors;
package body AMF.Internals.Utp_Start_Timer_Actions is
------------------------------------
-- Get_Base_Call_Operation_Action --
------------------------------------
overriding function Get_Base_Call_Operation_Action
(Self : not null access constant Utp_Start_Timer_Action_Proxy)
return AMF.UML.Call_Operation_Actions.UML_Call_Operation_Action_Access is
begin
return
AMF.UML.Call_Operation_Actions.UML_Call_Operation_Action_Access
(AMF.Internals.Helpers.To_Element
(AMF.Internals.Tables.Utp_Attributes.Internal_Get_Base_Call_Operation_Action
(Self.Element)));
end Get_Base_Call_Operation_Action;
------------------------------------
-- Set_Base_Call_Operation_Action --
------------------------------------
overriding procedure Set_Base_Call_Operation_Action
(Self : not null access Utp_Start_Timer_Action_Proxy;
To : AMF.UML.Call_Operation_Actions.UML_Call_Operation_Action_Access) is
begin
AMF.Internals.Tables.Utp_Attributes.Internal_Set_Base_Call_Operation_Action
(Self.Element,
AMF.Internals.Helpers.To_Element
(AMF.Elements.Element_Access (To)));
end Set_Base_Call_Operation_Action;
-------------------
-- Enter_Element --
-------------------
overriding procedure Enter_Element
(Self : not null access constant Utp_Start_Timer_Action_Proxy;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control) is
begin
if Visitor in AMF.Visitors.Utp_Visitors.Utp_Visitor'Class then
AMF.Visitors.Utp_Visitors.Utp_Visitor'Class
(Visitor).Enter_Start_Timer_Action
(AMF.Utp.Start_Timer_Actions.Utp_Start_Timer_Action_Access (Self),
Control);
end if;
end Enter_Element;
-------------------
-- Leave_Element --
-------------------
overriding procedure Leave_Element
(Self : not null access constant Utp_Start_Timer_Action_Proxy;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control) is
begin
if Visitor in AMF.Visitors.Utp_Visitors.Utp_Visitor'Class then
AMF.Visitors.Utp_Visitors.Utp_Visitor'Class
(Visitor).Leave_Start_Timer_Action
(AMF.Utp.Start_Timer_Actions.Utp_Start_Timer_Action_Access (Self),
Control);
end if;
end Leave_Element;
-------------------
-- Visit_Element --
-------------------
overriding procedure Visit_Element
(Self : not null access constant Utp_Start_Timer_Action_Proxy;
Iterator : in out AMF.Visitors.Abstract_Iterator'Class;
Visitor : in out AMF.Visitors.Abstract_Visitor'Class;
Control : in out AMF.Visitors.Traverse_Control) is
begin
if Iterator in AMF.Visitors.Utp_Iterators.Utp_Iterator'Class then
AMF.Visitors.Utp_Iterators.Utp_Iterator'Class
(Iterator).Visit_Start_Timer_Action
(Visitor,
AMF.Utp.Start_Timer_Actions.Utp_Start_Timer_Action_Access (Self),
Control);
end if;
end Visit_Element;
end AMF.Internals.Utp_Start_Timer_Actions;
|
xeenta/learning-ada | Ada | 919 | adb | with Ada.Text_IO; use Ada.Text_IO;
procedure Steps_3 is
task Step_By_Step is
entry Step_One;
entry Step_Two;
entry Step_Three;
end Step_By_Step;
task body Step_By_Step is
begin
loop
select
accept Step_One do
Put_Line ("1");
end Step_One;
or
accept Step_Two do
Put_Line ("2");
end Step_Two;
or
accept Step_Three do
Put_Line ("3");
end Step_Three;
end select;
Put_Line ("Again!");
end loop;
Put_Line ("I will NEVER say this!");
-- in fact the compiler warns us:
-- warning: unreachable code
end Step_By_Step;
begin
delay 1.0;
Put_Line ("Bye?");
Step_By_Step.Step_Three;
delay 1.0;
Step_By_Step.Step_Two;
delay 1.0;
Put_Line ("Bye by me, not by the task!");
end;
|
dilawar/ahir | Ada | 113 | ads | -- This file is generated by SWIG. Do *not* modify by hand.
--
package LLVM_bit_Writer is
end LLVM_bit_Writer;
|
reznikmm/matreshka | Ada | 5,801 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- XML Processor --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2010-2011, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
-- The SAX_Locator type provides the XML handlers with information about the
-- parsing position within a file.
--
-- The reader reports a SAX_Locator to the content handler before is starts
-- to parse the document. This is done with the Set_Document_Locator
-- procedure. The handlers can now use this locator to get the position
-- (line and column numbers) that the reader has reached.
--
-- SAX_Locator uses explicit sharing technique for safety, the handler can
-- save any number of copies of the objects but all of them will provides
-- the same information.
------------------------------------------------------------------------------
private with Ada.Finalization;
with League.IRIs;
with League.Strings;
private with Matreshka.Internals.SAX_Locators;
package XML.SAX.Locators is
pragma Preelaborate;
type SAX_Locator is tagged private;
function Column (Self : SAX_Locator'Class) return Natural;
-- Returns the column number (starting at 1) or 0 if there is no column
-- number available.
function Encoding
(Self : SAX_Locator'Class) return League.Strings.Universal_String;
-- Returns the name of the character encoding for the entity.
function Line (Self : SAX_Locator'Class) return Natural;
-- Returns the line number (starting at 1) or 0 if there is no line
-- number available.
function Public_Id
(Self : SAX_Locator'Class) return League.Strings.Universal_String;
-- Returns the public identifier for the current document event.
function System_Id
(Self : SAX_Locator'Class) return League.Strings.Universal_String;
-- Returns the system identifier for the current document event.
function Version
(Self : SAX_Locator'Class) return League.Strings.Universal_String;
-- Returns the version of XML used for the entity.
function Base_URI (Self : SAX_Locator'Class) return League.IRIs.IRI;
-- Returns base URI. XXX This is Matreshka's extension!
private
type SAX_Locator is new Ada.Finalization.Controlled with record
Data : Matreshka.Internals.SAX_Locators.Shared_Locator_Access;
end record;
overriding procedure Adjust (Self : in out SAX_Locator);
overriding procedure Finalize (Self : in out SAX_Locator);
pragma Inline (Adjust);
pragma Inline (Column);
pragma Inline (Encoding);
pragma Inline (Finalize);
pragma Inline (Line);
pragma Inline (Public_Id);
pragma Inline (System_Id);
end XML.SAX.Locators;
|
jscparker/math_packages | Ada | 2,072 | adb |
with Tridiagonal_LU;
With Text_IO; use Text_IO;
procedure tridiag_tst_1 is
type Real is digits 15;
package rio is new Text_IO.Float_IO(Real);
use rio;
Type Index is range 1..40;
Package Tri is new Tridiagonal_LU (Real, Index);
use Tri;
SolutionVector : Column;
D : Matrix := (others => (others => 0.0));
A : Matrix;
UnitVector : Column;
ZeroVector : constant Column := (others => 0.0);
Index_First : Index := Index'First;
Index_Last : Index := Index'Last;
RealMaxIndex : Real;
Test : Real;
begin
Put("Input First Index Of Matrix To Invert. (e.g. 2)"); New_Line;
get(RealMaxIndex);
Index_First := Index (RealMaxIndex);
Put("Input Last Index Of Matrix To Invert. (e.g. 8)"); New_Line;
get(RealMaxIndex);
Index_Last := Index (RealMaxIndex);
-- if Banded_Matrix_Desired then
-- Construct a banded matrix:
for I in Index loop
D(0)(I) := 0.3;
end loop;
for Row in Index'First..Index'Last loop
D(1)(Row) := 0.9;
end loop;
for Row in Index'First..Index'Last loop
D(-1)(Row) := 0.5;
end loop;
A := D;
LU_Decompose (A, Index_First, Index_Last);
-- Get Nth column of the inverse matrix
-- Col := N;
Put("Output should be the Identity matrix."); new_Line;
for Col in Index range Index_First..Index_Last loop
UnitVector := ZeroVector;
UnitVector(Col) := 1.0;
Solve (SolutionVector, A, UnitVector, Index_First, Index_Last);
New_Line;
-- Multiply SolutionVector times tridiagonal D:
for Row in Index_First..Index_Last loop
Test := 0.0;
if Row > Index_First then
Test := Test + D(-1)(Row) * SolutionVector(Row-1);
end if;
Test := Test + D(0)(Row) * SolutionVector(Row);
if Row < Index_Last then
Test := Test + D(1)(Row) * SolutionVector(Row+1);
end if;
Put (Test, 2, 3, 3); Put (" ");
end loop;
end loop;
end;
|
reznikmm/matreshka | Ada | 12,406 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- SQL Database Access --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2011-2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with League.Strings.Internals;
with Matreshka.Internals.SQL_Drivers.Oracle.Queries;
with Matreshka.Internals.Strings.C;
package body Matreshka.Internals.SQL_Drivers.Oracle.Databases is
use type Interfaces.Unsigned_32;
use type Matreshka.Internals.Strings.Shared_String_Access;
procedure Create_Environment (Self : not null access OCI_Database);
procedure Set_Error
(Self : not null access OCI_Database;
Text : Wide_Wide_String);
protected Env_Lock is
procedure Set_Env (Value : Environment; Success : out Boolean);
end Env_Lock;
-----------------
-- Check_Error --
-----------------
function Check_Error
(Self : not null access OCI_Database;
Code : Error_Code) return Boolean is
begin
case Code is
when OCI_SUCCESS =>
Set_Error (Self, "");
when OCI_NEED_DATA =>
Set_Error (Self, "OCI_NEED_DATA");
return True;
when OCI_SUCCESS_WITH_INFO | OCI_ERROR | OCI_NO_DATA =>
declare
use Matreshka.Internals.Strings;
use type Utf16.Utf16_String_Index;
Ok : Boolean;
Size : Utf16.Utf16_String_Index := 512;
Next : Error_Code;
Error : aliased Ub4;
begin
for J in 1 .. 10 loop
if Self.Error_Text = null then
Self.Error_Text := Allocate (Size);
elsif not Can_Be_Reused (Self.Error_Text, Size) then
Dereference (Self.Error_Text);
Self.Error_Text := Allocate (Size);
end if;
Next :=
OCIErrorGet
(Self.Error, 1,
Ora_Code => Error'Access,
Buffer => Self.Error_Text.Value,
Buffer_Size => Self.Error_Text.Value'Length * 2,
H_Type => OCI_HTYPE_ERROR);
if Next = OCI_SUCCESS then
Matreshka.Internals.Strings.C.Validate_And_Fixup
(Self.Error_Text, Ok);
return True;
else
Size := 2 * Size;
end if;
end loop;
Dereference (Self.Error_Text);
Self.Error_Text := Shared_Empty'Access;
return True;
end;
when OCI_INVALID_HANDLE =>
Set_Error (Self, "OCI_INVALID_HANDLE");
return True;
when OCI_STILL_EXECUTING =>
Set_Error (Self, "OCI_STILL_EXECUTING");
return True;
when OCI_CONTINUE =>
Set_Error (Self, "OCI_CONTINUE");
return True;
when others =>
Set_Error
(Self, "Unexpected code" & Error_Code'Wide_Wide_Image (Code));
return True;
end case;
return False;
end Check_Error;
-----------
-- Close --
-----------
overriding procedure Close (Self : not null access OCI_Database) is
Code : Error_Code;
begin
if Self.Service /= null then
Self.Invalidate_Queries;
Code := OCILogoff (Self.Service, Self.Error);
if Check_Error (Self, Code) then
null; -- How to report errors?
end if;
Self.Service := null;
end if;
end Close;
------------
-- Commit --
------------
overriding procedure Commit (Self : not null access OCI_Database) is
Code : Error_Code;
begin
if Self.Service /= null then
Code := OCITransCommit (Self.Service, Self.Error);
if Check_Error (Self, Code) then
null; -- How to report errors?
end if;
end if;
end Commit;
------------------------
-- Create_Environment --
------------------------
procedure Create_Environment (Self : not null access OCI_Database) is
Created : aliased Environment;
Code : Error_Code := OCIEnvNlsCreate
(Created'Access, OCI_THREADED + OCI_OBJECT);
Success : Boolean;
begin
if Code = OCI_SUCCESS then
Env_Lock.Set_Env (Created, Success);
if not Success then
Code := OCIHandleFree (Handle (Created), OCI_HTYPE_ENV);
end if;
else
Set_Error (Self, "OCIEnvNlsCreate fails");
end if;
end Create_Environment;
--------------
-- Env_Lock --
--------------
protected body Env_Lock is
-------------
-- Set_Env --
-------------
procedure Set_Env
(Value : Environment;
Success : out Boolean) is
begin
Success := Env = null;
if Success then
Env := Value;
end if;
end Set_Env;
end Env_Lock;
-------------------
-- Error_Message --
-------------------
overriding function Error_Message
(Self : not null access OCI_Database)
return League.Strings.Universal_String is
begin
if Self.Error_Text = null then
return League.Strings.Empty_Universal_String;
else
return League.Strings.Internals.Create (Self.Error_Text);
end if;
end Error_Message;
--------------
-- Finalize --
--------------
overriding procedure Finalize (Self : not null access OCI_Database) is
begin
if Self.Service /= null then
Self.Close;
end if;
if Self.Error_Text /= null then
Matreshka.Internals.Strings.Dereference (Self.Error_Text);
Self.Error_Text := null;
end if;
end Finalize;
----------
-- Open --
----------
overriding function Open
(Self : not null access OCI_Database;
Options : SQL.Options.SQL_Options) return Boolean
is
function Get_User return League.Strings.Universal_String;
function Get_Password return League.Strings.Universal_String;
function Get_Database return League.Strings.Universal_String;
------------------
-- Get_Database --
------------------
function Get_Database return League.Strings.Universal_String is
begin
return Options.Get (Database_Option);
end Get_Database;
------------------
-- Get_Password --
------------------
function Get_Password return League.Strings.Universal_String is
begin
return Options.Get (Password_Option);
end Get_Password;
--------------
-- Get_User --
--------------
function Get_User return League.Strings.Universal_String is
begin
return Options.Get (User_Option);
end Get_User;
Code : Error_Code;
begin
if Self.Service /= null then
Self.Close;
end if;
if Env = null then
Create_Environment (Self);
if Env = null then
return False;
end if;
end if;
if Self.Error = null then
Code := OCIHandleAlloc (Env, Self.Error'Access, OCI_HTYPE_ERROR);
if Code /= OCI_SUCCESS then
Set_Error (Self, "OCIHandleAlloc fails");
return False;
end if;
end if;
declare
User : constant League.Strings.Universal_String := Get_User;
Pwd : constant League.Strings.Universal_String := Get_Password;
DB : constant League.Strings.Universal_String := Get_Database;
begin
Code :=
OCILogon
(Env, Self.Error, Self.Service'Access,
League.Strings.Internals.Internal (User).Value,
Ub4 (League.Strings.Internals.Internal (User).Unused) * 2,
League.Strings.Internals.Internal (Pwd).Value,
Ub4 (League.Strings.Internals.Internal (Pwd).Unused) * 2,
League.Strings.Internals.Internal (DB).Value,
Ub4 (League.Strings.Internals.Internal (DB).Unused) * 2);
if Check_Error (Self, Code) then
return False;
end if;
end;
return True;
end Open;
-----------
-- Query --
-----------
overriding function Query
(Self : not null access OCI_Database) return not null Query_Access is
begin
return Aux : constant not null Query_Access
:= new Queries.OCI_Query (Self)
do
Aux.Initialize (Database_Access (Self));
end return;
end Query;
---------------
-- Set_Error --
---------------
procedure Set_Error
(Self : not null access OCI_Database;
Text : Wide_Wide_String)
is
String : constant League.Strings.Universal_String
:= League.Strings.To_Universal_String (Text);
begin
if Self.Error_Text /= null then
Matreshka.Internals.Strings.Dereference (Self.Error_Text);
Self.Error_Text := null;
end if;
if Text /= "" then
Self.Error_Text := League.Strings.Internals.Internal (String);
Matreshka.Internals.Strings.Reference (Self.Error_Text);
end if;
end Set_Error;
end Matreshka.Internals.SQL_Drivers.Oracle.Databases;
|
AdaCore/langkit | Ada | 1,164 | adb | with Ada.Text_IO; use Ada.Text_IO;
with System.Assertions;
with Langkit_Support.Vectors;
procedure Main is
package Int_Vectors is new Langkit_Support.Vectors (Integer);
procedure Put (V : Int_Vectors.Vector);
---------
-- Put --
---------
procedure Put (V : Int_Vectors.Vector) is
begin
Put ('[');
for I in V.First_Index .. V.Last_Index loop
if I > V.First_Index then
Put (", ");
end if;
Put (Integer'Image (V.Get (I)));
end loop;
Put (']');
New_Line;
end Put;
V : Int_Vectors.Vector;
begin
Put_Line ("Empty vector");
Put (V);
Put_Line ("Add 5 elements");
for I in 1 .. 5 loop
V.Append (I);
end loop;
Put (V);
declare
Dummy : Integer;
begin
Dummy := V.Get (6);
exception
when Constraint_Error =>
Put_Line ("Out of bound access");
end;
declare
Dummy : Integer;
begin
for I in 1 .. 6 loop
Dummy := V.Pop;
end loop;
exception
when System.Assertions.Assert_Failure =>
Put_Line ("Out of bound access");
end;
V.Destroy;
end Main;
|
reznikmm/matreshka | Ada | 4,059 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with ODF.DOM.Style_Auto_Text_Indent_Attributes;
package Matreshka.ODF_Style.Auto_Text_Indent_Attributes is
type Style_Auto_Text_Indent_Attribute_Node is
new Matreshka.ODF_Style.Abstract_Style_Attribute_Node
and ODF.DOM.Style_Auto_Text_Indent_Attributes.ODF_Style_Auto_Text_Indent_Attribute
with null record;
overriding function Create
(Parameters : not null access Matreshka.DOM_Attributes.Attribute_L2_Parameters)
return Style_Auto_Text_Indent_Attribute_Node;
overriding function Get_Local_Name
(Self : not null access constant Style_Auto_Text_Indent_Attribute_Node)
return League.Strings.Universal_String;
end Matreshka.ODF_Style.Auto_Text_Indent_Attributes;
|
reznikmm/matreshka | Ada | 3,759 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with XML.DOM.Attributes;
package ODF.DOM.Presentation_Start_Scale_Attributes is
pragma Preelaborate;
type ODF_Presentation_Start_Scale_Attribute is limited interface
and XML.DOM.Attributes.DOM_Attribute;
type ODF_Presentation_Start_Scale_Attribute_Access is
access all ODF_Presentation_Start_Scale_Attribute'Class
with Storage_Size => 0;
end ODF.DOM.Presentation_Start_Scale_Attributes;
|
silky/synth | Ada | 1,587 | ads | -- This file is covered by the Internet Software Consortium (ISC) License
-- Reference: ../License.txt
package Definitions is
pragma Pure;
synth_version_major : constant String := "1";
synth_version_minor : constant String := "70";
copyright_years : constant String := "2015-2017";
host_localbase : constant String := "/usr/local";
host_make : constant String := "/usr/bin/make";
host_pkg8 : constant String := host_localbase & "/sbin/pkg";
host_bmake : constant String := host_localbase & "/bin/bmake";
host_make_program : constant String := host_make;
chroot_make : constant String := "/usr/bin/make";
chroot_bmake : constant String := "/usr/pkg/bin/bmake -m /usr/pkg/share/mk";
chroot_make_program : constant String := chroot_make;
jobs_per_cpu : constant := 2;
type cpu_range is range 1 .. 32;
type scanners is range cpu_range'First .. cpu_range'Last;
type builders is range cpu_range'First .. cpu_range'Last * jobs_per_cpu;
type package_system is (ports_collection, pkgsrc);
software_framework : constant package_system := ports_collection;
-- Notes for tailoring Synth. Use sed to:
-- 1. Modify host_localbase to value of LOCALBASE
-- 2. Change software_framework to "pkgsrc" for pkgsrc version
-- 3. Change host_make_program to "host_bmake" for Non-NetBSD pkgsrc platforms
-- 4. Change chroot_make_program to "chroot_bmake" for pkgsrc version
-- 5. On replicant.ads, change "/usr/local" to "/usr/pkg" on pkgsrc
end Definitions;
|
Letractively/ada-ado | Ada | 14,505 | adb | -----------------------------------------------------------------------
-- ADO SQL -- Basic SQL Generation
-- Copyright (C) 2010, 2011, 2012 Stephane Carrez
-- Written by Stephane Carrez ([email protected])
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
-- Utilities for creating SQL queries and statements.
package body ADO.SQL is
function Escape (Str : in Unbounded_String) return String is
begin
return Escape (To_String (Str));
end Escape;
function Escape (Str : in String) return String is
S : String (1 .. 2 + Str'Length * 2);
J : Positive := S'First;
begin
if Str = "" then
return "NULL";
end if;
S (J) := ''';
for K in Str'Range loop
if Str (K) = ''' then
J := J + 1;
S (J) := ''';
end if;
J := J + 1;
S (J) := Str (K);
end loop;
J := J + 1;
S (J) := ''';
return S (1 .. J);
end Escape;
-- --------------------
-- Buffer
-- --------------------
-- --------------------
-- Clear the SQL buffer.
-- --------------------
procedure Clear (Target : in out Buffer) is
begin
Target.Buf := To_Unbounded_String ("");
end Clear;
-- --------------------
-- Append an SQL extract into the buffer.
-- --------------------
procedure Append (Target : in out Buffer;
SQL : in String) is
begin
Append (Target.Buf, SQL);
end Append;
-- --------------------
-- Append a name in the buffer and escape that
-- name if this is a reserved keyword.
-- --------------------
procedure Append_Name (Target : in out Buffer;
Name : in String) is
use type ADO.Drivers.Dialects.Dialect_Access;
Dialect : constant ADO.Drivers.Dialects.Dialect_Access := Target.Get_Dialect;
begin
if Dialect /= null and then Dialect.Is_Reserved (Name) then
declare
Quote : constant Character := Dialect.Get_Identifier_Quote;
begin
Append (Target.Buf, Quote);
Append (Target.Buf, Name);
Append (Target.Buf, Quote);
end;
else
Append (Target.Buf, Name);
end if;
end Append_Name;
-- --------------------
-- Append a string value in the buffer and
-- escape any special character if necessary.
-- --------------------
procedure Append_Value (Target : in out Buffer;
Value : in String) is
begin
Append (Target.Buf, Value);
end Append_Value;
-- --------------------
-- Append a string value in the buffer and
-- escape any special character if necessary.
-- --------------------
procedure Append_Value (Target : in out Buffer;
Value : in Unbounded_String) is
begin
Append (Target.Buf, Value);
end Append_Value;
-- --------------------
-- Append the integer value in the buffer.
-- --------------------
procedure Append_Value (Target : in out Buffer;
Value : in Long_Integer) is
S : constant String := Long_Integer'Image (Value);
begin
Append (Target.Buf, S (S'First + 1 .. S'Last));
end Append_Value;
-- --------------------
-- Append the integer value in the buffer.
-- --------------------
procedure Append_Value (Target : in out Buffer;
Value : in Integer) is
S : constant String := Integer'Image (Value);
begin
Append (Target.Buf, S (S'First + 1 .. S'Last));
end Append_Value;
-- --------------------
-- Append the identifier value in the buffer.
-- --------------------
procedure Append_Value (Target : in out Buffer;
Value : in Identifier) is
S : constant String := Identifier'Image (Value);
begin
Append (Target.Buf, S (S'First + 1 .. S'Last));
end Append_Value;
-- --------------------
-- Get the SQL string that was accumulated in the buffer.
-- --------------------
function To_String (From : in Buffer) return String is
begin
return To_String (From.Buf);
end To_String;
-- --------------------
-- Clear the query object.
-- --------------------
overriding
procedure Clear (Target : in out Query) is
begin
ADO.Parameters.List (Target).Clear;
Target.Join.Clear;
Target.Filter.Clear;
Target.SQL.Clear;
end Clear;
-- --------------------
-- Set the SQL dialect description object.
-- --------------------
procedure Set_Dialect (Target : in out Query;
D : in ADO.Drivers.Dialects.Dialect_Access) is
begin
ADO.Parameters.Abstract_List (Target).Set_Dialect (D);
Set_Dialect (Target.SQL, D);
Set_Dialect (Target.Filter, D);
Set_Dialect (Target.Join, D);
end Set_Dialect;
procedure Set_Filter (Target : in out Query;
Filter : in String) is
begin
Target.Filter.Buf := To_Unbounded_String (Filter);
end Set_Filter;
function Get_Filter (Source : in Query) return String is
begin
if Source.Filter.Buf = Null_Unbounded_String then
return "";
else
return To_String (Source.Filter.Buf);
end if;
end Get_Filter;
function Has_Filter (Source : in Query) return Boolean is
begin
return Source.Filter.Buf /= Null_Unbounded_String
and Length (Source.Filter.Buf) > 0;
end Has_Filter;
-- --------------------
-- Set the join condition.
-- --------------------
procedure Set_Join (Target : in out Query;
Join : in String) is
begin
Target.Join.Buf := To_Unbounded_String (Join);
end Set_Join;
-- --------------------
-- Returns true if there is a join condition
-- --------------------
function Has_Join (Source : in Query) return Boolean is
begin
return Source.Join.Buf /= Null_Unbounded_String
and Length (Source.Join.Buf) > 0;
end Has_Join;
-- --------------------
-- Get the join condition
-- --------------------
function Get_Join (Source : in Query) return String is
begin
if Source.Join.Buf = Null_Unbounded_String then
return "";
else
return To_String (Source.Join.Buf);
end if;
end Get_Join;
-- --------------------
-- Set the parameters from another parameter list.
-- If the parameter list is a query object, also copy the filter part.
-- --------------------
procedure Set_Parameters (Params : in out Query;
From : in ADO.Parameters.Abstract_List'Class) is
begin
ADO.Parameters.List (Params).Set_Parameters (From);
if From in Query'Class then
declare
L : constant Query'Class := Query'Class (From);
begin
Params.Filter := L.Filter;
Params.Join := L.Join;
end;
end if;
end Set_Parameters;
-- --------------------
-- Expand the parameters into the query and return the expanded SQL query.
-- --------------------
function Expand (Source : in Query) return String is
begin
return ADO.Parameters.Abstract_List (Source).Expand (To_String (Source.SQL.Buf));
end Expand;
procedure Add_Field (Update : in out Update_Query'Class;
Name : in String) is
begin
Update.Pos := Update.Pos + 1;
if Update.Pos > 1 then
Append (Target => Update.Set_Fields, SQL => ",");
Append (Target => Update.Fields, SQL => ",");
end if;
Append_Name (Target => Update.Set_Fields, Name => Name);
if Update.Is_Update_Stmt then
Append (Target => Update.Set_Fields, SQL => " = ?");
end if;
Append (Target => Update.Fields, SQL => "?");
end Add_Field;
-- ------------------------------
-- Set the SQL dialect description object.
-- ------------------------------
procedure Set_Dialect (Target : in out Update_Query;
D : in ADO.Drivers.Dialects.Dialect_Access) is
begin
Target.Set_Fields.Set_Dialect (D);
Target.Fields.Set_Dialect (D);
Query (Target).Set_Dialect (D);
end Set_Dialect;
-- ------------------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- ------------------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in Boolean) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Bind_Param (Position => Update.Pos, Value => Value);
end Save_Field;
-- --------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- --------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in Integer) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Bind_Param (Position => Update.Pos, Value => Value);
end Save_Field;
-- --------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- --------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in Long_Long_Integer) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Bind_Param (Position => Update.Pos, Value => Value);
end Save_Field;
-- --------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- --------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in Identifier) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Add_Param (Value => Value);
end Save_Field;
-- --------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- --------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in Entity_Type) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Add_Param (Value => Integer (Value));
end Save_Field;
-- --------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- --------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in Ada.Calendar.Time) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Add_Param (Value => Value);
end Save_Field;
-- --------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- --------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in String) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Bind_Param (Position => Update.Pos, Value => Value);
end Save_Field;
-- --------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- --------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in Unbounded_String) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Bind_Param (Position => Update.Pos, Value => Value);
end Save_Field;
-- ------------------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to the <b>Value</b>.
-- ------------------------------
procedure Save_Field (Update : in out Update_Query;
Name : in String;
Value : in ADO.Blob_Ref) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Bind_Param (Position => Update.Pos, Value => Value);
end Save_Field;
-- ------------------------------
-- Prepare the update/insert query to save the table field
-- identified by <b>Name</b> and set it to NULL.
-- ------------------------------
procedure Save_Null_Field (Update : in out Update_Query;
Name : in String) is
begin
Update.Add_Field (Name => Name);
Update_Query'Class (Update).Bind_Null_Param (Position => Update.Pos);
end Save_Null_Field;
-- --------------------
-- Check if the update/insert query has some fields to update.
-- --------------------
function Has_Save_Fields (Update : in Update_Query) return Boolean is
begin
return Update.Pos > 0;
end Has_Save_Fields;
procedure Set_Insert_Mode (Update : in out Update_Query) is
begin
Update.Is_Update_Stmt := False;
end Set_Insert_Mode;
procedure Append_Fields (Update : in out Update_Query;
Mode : in Boolean := False) is
begin
if Mode then
Append (Target => Update.SQL, SQL => To_String (Update.Fields.Buf));
else
Append (Target => Update.SQL, SQL => To_String (Update.Set_Fields.Buf));
end if;
end Append_Fields;
end ADO.SQL;
|
zhmu/ananas | Ada | 8,494 | adb | ------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- E X P _ S E L --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2022, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with Einfo; use Einfo;
with Einfo.Entities; use Einfo.Entities;
with Nlists; use Nlists;
with Nmake; use Nmake;
with Opt; use Opt;
with Rtsfind; use Rtsfind;
with Sinfo; use Sinfo;
with Sinfo.Nodes; use Sinfo.Nodes;
with Snames; use Snames;
with Stand; use Stand;
with Tbuild; use Tbuild;
package body Exp_Sel is
-----------------------
-- Build_Abort_Block --
-----------------------
function Build_Abort_Block
(Loc : Source_Ptr;
Abr_Blk_Ent : Entity_Id;
Cln_Blk_Ent : Entity_Id;
Blk : Node_Id) return Node_Id
is
begin
return
Make_Block_Statement (Loc,
Identifier => New_Occurrence_Of (Abr_Blk_Ent, Loc),
Declarations => No_List,
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Statements =>
New_List (
Make_Implicit_Label_Declaration (Loc,
Defining_Identifier => Cln_Blk_Ent,
Label_Construct => Blk),
Blk),
Exception_Handlers =>
New_List (Build_Abort_Block_Handler (Loc))));
end Build_Abort_Block;
-------------------------------
-- Build_Abort_Block_Handler --
-------------------------------
function Build_Abort_Block_Handler (Loc : Source_Ptr) return Node_Id is
begin
return Make_Implicit_Exception_Handler (Loc,
Exception_Choices =>
New_List (New_Occurrence_Of (Stand.Abort_Signal, Loc)),
Statements => New_List (Make_Null_Statement (Loc)));
end Build_Abort_Block_Handler;
-------------
-- Build_B --
-------------
function Build_B
(Loc : Source_Ptr;
Decls : List_Id) return Entity_Id
is
B : constant Entity_Id := Make_Temporary (Loc, 'B');
begin
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => B,
Object_Definition => New_Occurrence_Of (Standard_Boolean, Loc),
Expression => New_Occurrence_Of (Standard_False, Loc)));
return B;
end Build_B;
-------------
-- Build_C --
-------------
function Build_C
(Loc : Source_Ptr;
Decls : List_Id) return Entity_Id
is
C : constant Entity_Id := Make_Temporary (Loc, 'C');
begin
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => C,
Object_Definition =>
New_Occurrence_Of (RTE (RE_Prim_Op_Kind), Loc)));
return C;
end Build_C;
-------------------------
-- Build_Cleanup_Block --
-------------------------
function Build_Cleanup_Block
(Loc : Source_Ptr;
Blk_Ent : Entity_Id;
Stmts : List_Id;
Clean_Ent : Entity_Id) return Node_Id
is
Cleanup_Block : constant Node_Id :=
Make_Block_Statement (Loc,
Identifier =>
New_Occurrence_Of (Blk_Ent, Loc),
Declarations => No_List,
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Statements => Stmts),
Is_Asynchronous_Call_Block => True);
begin
Set_Entry_Cancel_Parameter (Blk_Ent, Clean_Ent);
return Cleanup_Block;
end Build_Cleanup_Block;
-------------
-- Build_K --
-------------
function Build_K
(Loc : Source_Ptr;
Decls : List_Id;
Obj : Entity_Id) return Entity_Id
is
K : constant Entity_Id := Make_Temporary (Loc, 'K');
Tag_Node : Node_Id;
begin
if Tagged_Type_Expansion then
Tag_Node := Unchecked_Convert_To (RTE (RE_Tag), Obj);
else
Tag_Node :=
Make_Attribute_Reference (Loc,
Prefix => Obj,
Attribute_Name => Name_Tag);
end if;
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => K,
Object_Definition =>
New_Occurrence_Of (RTE (RE_Tagged_Kind), Loc),
Expression =>
Make_Function_Call (Loc,
Name => New_Occurrence_Of (RTE (RE_Get_Tagged_Kind), Loc),
Parameter_Associations => New_List (Tag_Node))));
return K;
end Build_K;
-------------
-- Build_S --
-------------
function Build_S
(Loc : Source_Ptr;
Decls : List_Id) return Entity_Id
is
S : constant Entity_Id := Make_Temporary (Loc, 'S');
begin
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => S,
Object_Definition => New_Occurrence_Of (Standard_Integer, Loc)));
return S;
end Build_S;
------------------------
-- Build_S_Assignment --
------------------------
function Build_S_Assignment
(Loc : Source_Ptr;
S : Entity_Id;
Obj : Entity_Id;
Call_Ent : Entity_Id) return Node_Id
is
Typ : constant Entity_Id := Etype (Obj);
begin
if Tagged_Type_Expansion then
return
Make_Assignment_Statement (Loc,
Name => New_Occurrence_Of (S, Loc),
Expression =>
Make_Function_Call (Loc,
Name => New_Occurrence_Of (RTE (RE_Get_Offset_Index), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Tag), Obj),
Make_Integer_Literal (Loc, DT_Position (Call_Ent)))));
-- VM targets
else
return
Make_Assignment_Statement (Loc,
Name => New_Occurrence_Of (S, Loc),
Expression =>
Make_Function_Call (Loc,
Name => New_Occurrence_Of (RTE (RE_Get_Offset_Index), Loc),
Parameter_Associations => New_List (
-- Obj_Typ
Make_Attribute_Reference (Loc,
Prefix => Obj,
Attribute_Name => Name_Tag),
-- Iface_Typ
Make_Attribute_Reference (Loc,
Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag),
-- Position
Make_Integer_Literal (Loc, DT_Position (Call_Ent)))));
end if;
end Build_S_Assignment;
end Exp_Sel;
|
zhmu/ananas | Ada | 260 | adb | -- { dg-compile }
procedure Alignment15 is
type T0 is record
X : Integer;
end record;
for T0'Alignment use 0;
type T00 is record
X : Integer;
end record with Alignment => 0;
Dummy0 : T0;
Dummy00 : T00;
begin
null;
end;
|
reznikmm/matreshka | Ada | 4,739 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with XML.DOM.Visitors;
with ODF.DOM.Text_Toc_Mark_End_Elements;
package Matreshka.ODF_Text.Toc_Mark_End_Elements is
type Text_Toc_Mark_End_Element_Node is
new Matreshka.ODF_Text.Abstract_Text_Element_Node
and ODF.DOM.Text_Toc_Mark_End_Elements.ODF_Text_Toc_Mark_End
with null record;
overriding function Create
(Parameters : not null access Matreshka.DOM_Elements.Element_L2_Parameters)
return Text_Toc_Mark_End_Element_Node;
overriding function Get_Local_Name
(Self : not null access constant Text_Toc_Mark_End_Element_Node)
return League.Strings.Universal_String;
overriding procedure Enter_Node
(Self : not null access Text_Toc_Mark_End_Element_Node;
Visitor : in out XML.DOM.Visitors.Abstract_Visitor'Class;
Control : in out XML.DOM.Visitors.Traverse_Control);
overriding procedure Leave_Node
(Self : not null access Text_Toc_Mark_End_Element_Node;
Visitor : in out XML.DOM.Visitors.Abstract_Visitor'Class;
Control : in out XML.DOM.Visitors.Traverse_Control);
overriding procedure Visit_Node
(Self : not null access Text_Toc_Mark_End_Element_Node;
Iterator : in out XML.DOM.Visitors.Abstract_Iterator'Class;
Visitor : in out XML.DOM.Visitors.Abstract_Visitor'Class;
Control : in out XML.DOM.Visitors.Traverse_Control);
end Matreshka.ODF_Text.Toc_Mark_End_Elements;
|
redparavoz/ada-wiki | Ada | 2,889 | ads | -----------------------------------------------------------------------
-- wiki-helpers -- Helper operations for wiki parsers and renderer
-- Copyright (C) 2016 Stephane Carrez
-- Written by Stephane Carrez ([email protected])
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Wiki.Strings;
package Wiki.Helpers is
pragma Preelaborate;
LF : constant Wiki.Strings.WChar := Wiki.Strings.WChar'Val (16#0A#);
CR : constant Wiki.Strings.WChar := Wiki.Strings.WChar'Val (16#0D#);
HT : constant Wiki.Strings.WChar := Wiki.Strings.WChar'Val (16#09#);
-- Returns True if the character is a space or tab.
function Is_Space (C : in Wiki.Strings.WChar) return Boolean;
-- Returns True if the character is a space, tab or a newline.
function Is_Space_Or_Newline (C : in Wiki.Strings.WChar) return Boolean;
-- Returns True if the character is a line terminator.
function Is_Newline (C : in Wiki.Strings.WChar) return Boolean;
-- Returns True if the text is a valid URL
function Is_Url (Text : in Wiki.Strings.WString) return Boolean;
-- Returns True if the extension part correspond to an image.
-- Recognized extension are: .png, .gif, .jpg, .jpeg.
-- The extension case is ignored.
function Is_Image_Extension (Ext : in Wiki.Strings.WString) return Boolean;
-- Given the current tag on the top of the stack and the new tag that will be pushed,
-- decide whether the current tag must be closed or not.
-- Returns True if the current tag must be closed.
function Need_Close (Tag : in Html_Tag;
Current_Tag : in Html_Tag) return Boolean;
-- Get the dimension represented by the string. The string has one of the following
-- formats:
-- original -> Width, Height := Natural'Last
-- default -> Width := 800, Height := 0
-- upright -> Width := 800, Height := 0
-- <width>px -> Width := <width>, Height := 0
-- x<height>px -> Width := 0, Height := <height>
-- <width>x<height>px -> Width := <width>, Height := <height>
procedure Get_Sizes (Dimension : in Wiki.Strings.WString;
Width : out Natural;
Height : out Natural);
end Wiki.Helpers;
|
charlie5/lace | Ada | 6,178 | ads | with
ada.Containers,
ada.Streams;
package lace.Text
--
-- Models a string of text characters.
--
is
pragma Pure;
type Item (Capacity : Natural) is private;
function Image (Self : in Item) return String;
Error : exception;
--------------
-- Stock Items
--
subtype Item_2 is Item (Capacity => 2);
subtype Item_4 is Item (Capacity => 4);
subtype Item_8 is Item (Capacity => 8);
subtype Item_16 is Item (Capacity => 16);
subtype Item_32 is Item (Capacity => 32);
subtype Item_64 is Item (Capacity => 64);
subtype Item_128 is Item (Capacity => 128);
subtype Item_256 is Item (Capacity => 256);
subtype Item_512 is Item (Capacity => 512);
subtype Item_1k is Item (Capacity => 1024);
subtype Item_2k is Item (Capacity => 2 * 1024);
subtype Item_4k is Item (Capacity => 4 * 1024);
subtype Item_8k is Item (Capacity => 8 * 1024);
subtype Item_16k is Item (Capacity => 16 * 1024);
subtype Item_32k is Item (Capacity => 32 * 1024);
subtype Item_64k is Item (Capacity => 64 * 1024);
subtype Item_128k is Item (Capacity => 128 * 1024);
subtype Item_256k is Item (Capacity => 256 * 1024);
subtype Item_512k is Item (Capacity => 512 * 1024);
subtype Item_1m is Item (Capacity => 1024 * 1024);
subtype Item_2m is Item (Capacity => 2 * 1024 * 1024);
subtype Item_4m is Item (Capacity => 4 * 1024 * 1024);
subtype Item_8m is Item (Capacity => 8 * 1024 * 1024);
subtype Item_16m is Item (Capacity => 16 * 1024 * 1024);
subtype Item_32m is Item (Capacity => 32 * 1024 * 1024);
subtype Item_64m is Item (Capacity => 64 * 1024 * 1024);
subtype Item_128m is Item (Capacity => 128 * 1024 * 1024);
subtype Item_256m is Item (Capacity => 256 * 1024 * 1024);
subtype Item_512m is Item (Capacity => 512 * 1024 * 1024);
---------------
-- Stock Arrays
--
type Items_2 is array (Positive range <>) of aliased Item_2;
type Items_4 is array (Positive range <>) of aliased Item_4;
type Items_8 is array (Positive range <>) of aliased Item_8;
type Items_16 is array (Positive range <>) of aliased Item_16;
type Items_32 is array (Positive range <>) of aliased Item_32;
type Items_64 is array (Positive range <>) of aliased Item_64;
type Items_128 is array (Positive range <>) of aliased Item_128;
type Items_256 is array (Positive range <>) of aliased Item_256;
type Items_512 is array (Positive range <>) of aliased Item_512;
type Items_1k is array (Positive range <>) of aliased Item_1k;
type Items_2k is array (Positive range <>) of aliased Item_2k;
type Items_4k is array (Positive range <>) of aliased Item_4k;
type Items_8k is array (Positive range <>) of aliased Item_8k;
type Items_16k is array (Positive range <>) of aliased Item_16k;
type Items_32k is array (Positive range <>) of aliased Item_32k;
type Items_64k is array (Positive range <>) of aliased Item_64k;
type Items_128k is array (Positive range <>) of aliased Item_128k;
type Items_256k is array (Positive range <>) of aliased Item_256k;
type Items_512k is array (Positive range <>) of aliased Item_512k;
type Items_1m is array (Positive range <>) of aliased Item_1m;
type Items_2m is array (Positive range <>) of aliased Item_2m;
type Items_4m is array (Positive range <>) of aliased Item_4m;
type Items_8m is array (Positive range <>) of aliased Item_8m;
type Items_16m is array (Positive range <>) of aliased Item_16m;
type Items_32m is array (Positive range <>) of aliased Item_32m;
type Items_64m is array (Positive range <>) of aliased Item_64m;
type Items_128m is array (Positive range <>) of aliased Item_128m;
type Items_256m is array (Positive range <>) of aliased Item_256m;
type Items_512m is array (Positive range <>) of aliased Item_512m;
---------------
-- Construction
--
function to_Text (From : in String;
Trim : in Boolean := False) return Item;
function to_Text (From : in String;
Capacity : in Natural;
Trim : in Boolean := False) return Item;
function "+" (From : in String) return Item;
-------------
-- Attributes
--
procedure String_is (Self : in out Item; Now : in String);
function to_String (Self : in Item) return String;
function "+" (Self : in Item) return String renames to_String;
function is_Empty (Self : in Item) return Boolean;
function Length (Self : in Item) return Natural;
function Hashed (Self : in Item) return ada.Containers.Hash_type;
overriding
function "=" (Left, Right : in Item) return Boolean;
function to_Lowercase (Self : in Item) return Item;
function mono_Spaced (Self : in Item) return Item;
function Element (Self : in Item; Index : in Positive) return Character;
procedure append (Self : in out Item; Extra : in String);
--
-- Raises an Error if capacity is exceeded.
function delete (Self : in Text.item; From : Positive;
Through : Natural := Natural'Last) return Text.item;
procedure delete (Self : in out Text.item; From : Positive;
Through : Natural := Natural'Last);
private
type Item (Capacity : Natural) is
record
Length : Natural := 0;
Data : String (1 .. Capacity);
end record;
----------
-- Streams
--
function Item_input (Stream : access ada.Streams.root_Stream_type'Class) return Item;
procedure Item_output (Stream : access ada.Streams.root_Stream_type'Class; the_Item : in Item);
procedure read (Stream : access ada.Streams.root_Stream_type'Class; Self : out Item);
procedure write (Stream : access ada.Streams.root_Stream_type'Class; Self : in Item);
for Item'input use Item_input;
for Item'output use Item_output;
for Item'write use write;
for Item'read use read;
end lace.Text;
|
psyomn/afile | Ada | 809 | adb | -- Copyright 2017-2019 Simon Symeonidis (psyomn)
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
with Ada.Text_IO; use Ada.Text_IO;
package body Headers is
procedure Print_File_Info (F : File_Signature) is
begin
Put_Line (F.Description.all);
end Print_File_Info;
end Headers;
|
onox/orka | Ada | 1,682 | adb | -- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2020 onox <[email protected]>
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
with EGL.API;
package body EGL.Errors is
procedure Raise_Exception_On_EGL_Error is
Error : constant Error_Code := API.Get_Error;
begin
case Error is
when Success =>
null;
when Not_Initialized =>
raise Not_Initialized_Error with Error'Image;
when Context_Lost =>
raise Context_Lost_Error with Error'Image;
when Bad_Access | Bad_Alloc =>
raise Invalid_Operation_Error with Error'Image;
when Bad_Attribute =>
raise Internal_Error with Error'Image;
when Bad_Config | Bad_Context | Bad_Current_Surface | Bad_Surface
| Bad_Display | Bad_Device | Bad_Native_Pixmap | Bad_Native_Window =>
raise Invalid_Operation_Error with Error'Image;
when Bad_Match | Bad_Parameter =>
raise Invalid_Value_Error with Error'Image;
end case;
exception
when Constraint_Error => raise Internal_Error;
end Raise_Exception_On_EGL_Error;
end EGL.Errors;
|
reznikmm/matreshka | Ada | 4,624 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Matreshka.DOM_Documents;
with Matreshka.ODF_String_Constants;
with ODF.DOM.Iterators;
with ODF.DOM.Visitors;
package body Matreshka.ODF_Style.Font_Relief_Attributes is
------------
-- Create --
------------
overriding function Create
(Parameters : not null access Matreshka.DOM_Attributes.Attribute_L2_Parameters)
return Style_Font_Relief_Attribute_Node is
begin
return Self : Style_Font_Relief_Attribute_Node do
Matreshka.ODF_Style.Constructors.Initialize
(Self'Unchecked_Access,
Parameters.Document,
Matreshka.ODF_String_Constants.Style_Prefix);
end return;
end Create;
--------------------
-- Get_Local_Name --
--------------------
overriding function Get_Local_Name
(Self : not null access constant Style_Font_Relief_Attribute_Node)
return League.Strings.Universal_String
is
pragma Unreferenced (Self);
begin
return Matreshka.ODF_String_Constants.Font_Relief_Attribute;
end Get_Local_Name;
begin
Matreshka.DOM_Documents.Register_Attribute
(Matreshka.ODF_String_Constants.Style_URI,
Matreshka.ODF_String_Constants.Font_Relief_Attribute,
Style_Font_Relief_Attribute_Node'Tag);
end Matreshka.ODF_Style.Font_Relief_Attributes;
|
persan/gprTools | Ada | 934 | ads | with GNATCOLL.JSON;
package GPR_Tools.Gprslaves.DB.JSON is
function Create (Item : Info_Struct) return GNATCOLL.JSON.JSON_Value;
function Create (Item : Host_Address) return GNATCOLL.JSON.JSON_Value;
function Create (Item : GNAT.Spitbol.Table_VString.Table) return GNATCOLL.JSON.JSON_Value;
function Create (Item : Host_Info_Vectors.Vector) return GNATCOLL.JSON.JSON_Value;
function Create (Item : GNAT.Spitbol.Table_VString.Table_Entry) return GNATCOLL.JSON.JSON_Value;
function Get (Item : GNATCOLL.JSON.JSON_Value) return Info_Struct;
function Get (Item : GNATCOLL.JSON.JSON_Value) return Host_Address;
function Get (Item : GNATCOLL.JSON.JSON_Value) return GNAT.Spitbol.Table_VString.Table;
function Get (Item : GNATCOLL.JSON.JSON_Value) return Host_Info_Vectors.Vector;
function Get (Item : GNATCOLL.JSON.JSON_Value) return GNAT.Spitbol.Table_VString.Table_Entry;
end GPR_Tools.Gprslaves.DB.JSON;
|
skordal/databases | Ada | 3,655 | adb | -- Databases - A simple database library for Ada applications
-- (c) Kristian Klomsten Skordal 2019 <[email protected]>
-- Report bugs and issues on <https://github.com/skordal/databases/issues>
-- vim:ts=3:sw=3:et:si:sta
with Databases;
with Databases.Sqlite;
with Ada.Numerics.Discrete_Random;
with Ada.Text_IO;
procedure Testapp is
use type Databases.Statement_Execution_Status;
Database : Databases.Database_Access := null;
package Sql is
Create_Table : constant String :=
"CREATE TABLE test" &
"(" &
" id INTEGER PRIMARY KEY," &
" item VARYING CHARACTER (127)," &
" count INTEGER" &
");";
Insert_Data : constant String :=
"INSERT INTO test VALUES (:id, :name, :count);";
Select_Data : constant String :=
"SELECT * FROM test;";
end Sql;
package Random_Number_Generators is new Ada.Numerics.Discrete_Random (Result_Subtype => Natural);
RNG : Random_Number_Generators.Generator;
begin
Database := Databases.Sqlite.Open ("test.db", Create => True);
-- Create database tables:
declare
Statement : Databases.Prepared_Statement_Access := Database.Prepare (Sql.Create_Table);
Status : constant Databases.Statement_Execution_Status := Statement.Execute;
begin
if Status /= Databases.Success then
Ada.Text_IO.Put_Line ("Error: failed to create database tables!");
end if;
Databases.Free (Statement);
end;
-- Insert database values:
declare
Insert_Statement : Databases.Prepared_Statement_Access := Database.Prepare (Sql.Insert_Data);
Status : Databases.Statement_Execution_Status;
begin
for Counter in 1..10 loop
Insert_Statement.Clear;
Insert_Statement.Bind (1, Databases.Sql_Integer (Counter));
Insert_Statement.Bind (2, "Item number " & Integer'Image (Counter));
Insert_Statement.Bind (3, Databases.Sql_Integer (Random_Number_Generators.Random (RNG) mod 1000));
Status := Insert_Statement.Execute;
if Status /= Databases.Success then
Ada.Text_IO.Put_Line ("Warning: failed to insert item number " & Integer'Image (Counter)
& " into the database");
end if;
Insert_Statement.Reset;
end loop;
Databases.Free (Insert_Statement);
end;
-- Print database values:
declare
Select_Statement : Databases.Prepared_Statement_Access := Database.Prepare (Sql.Select_Data);
Result : Databases.Statement_Result_Access := Select_Statement.Execute;
begin
Ada.Text_IO.Put_Line ("Got " & Integer'Image (Result.Get_Returned_Row_Count) & " results");
if Result.Get_Returned_Row_Count > 0 then
for I in 1 .. Result.Get_Returned_Row_Count loop
Ada.Text_IO.Put_Line ("ID" & Databases.Sql_Integer'Image (Result.Get_Row (I).Get_Column (1).Get_Value));
Ada.Text_IO.Put_Line (" Item name: " & Result.Get_Row (I).Get_Column (2).Get_Value);
Ada.Text_IO.Put_Line (" Item count: " & Databases.Sql_Integer'Image (Result.Get_Row (I).Get_Column (3).Get_Value));
end loop;
end if;
Databases.Free (Result);
Databases.Free (Select_Statement);
end;
Database.Close;
Databases.Free (Database);
exception
when Databases.File_Error =>
Ada.Text_IO.Put_Line ("Error: Could not open the test database file!");
when Databases.IO_Error =>
Ada.Text_IO.Put_Line ("Error: An I/O error occurred!");
when Databases.Unspecified_Error =>
Ada.Text_IO.Put_Line ("Error: An unspecified error occurred!");
end Testapp;
|
onox/orka | Ada | 6,430 | adb | -- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2020 onox <[email protected]>
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
with GL.Buffers;
with GL.Context;
with GL.Rasterization;
with GL.Toggles;
with GL.Types;
with GL.Viewports;
with Orka.Debug;
with Orka.Loggers;
with Orka.Logging.Default;
package body Orka.Contexts.EGL is
use all type Orka.Logging.Default_Module;
use all type Orka.Logging.Severity;
use Orka.Logging;
procedure Log is new Orka.Logging.Default.Generic_Log (Window_System);
procedure Print_Error
(Error : Standard.EGL.Errors.Error_Code;
Level : Standard.EGL.Debug.Severity;
Command, Message : String)
is
package Debug renames Standard.EGL.Debug;
Severity : constant Orka.Loggers.Severity :=
(case Level is
when Debug.Critical => Loggers.Error,
when Debug.Error => Loggers.Error,
when Debug.Warning => Loggers.Warning,
when Debug.Info => Loggers.Debug);
begin
Log (Severity, Error'Image & " in " & Command & ": " & Trim (Message));
end Print_Error;
procedure Print_Debug
(Display : Standard.EGL.Objects.Displays.Display;
Version : Context_Version;
Flags : Context_Flags) is
begin
Log (Info, "Created EGL context for " & Image (Version));
Log (Info, " platform: " & Display.Platform'Image);
declare
Name : constant String := Display.Device.Name;
begin
Log (Info, " device: " & (if Name /= "" then Name else "unknown"));
end;
Log (Loggers.Debug, " vendor: " & Display.Vendor);
Log (Loggers.Debug, " version: " & Display.Version);
Log (Loggers.Info, " context:");
Log (Loggers.Info, " flags: " & Image (Flags));
Log (Loggers.Info, " version: " & GL.Context.Version_String);
Log (Loggers.Info, " renderer: " & GL.Context.Renderer);
end Print_Debug;
procedure Post_Initialize (Object : in out EGL_Context'Class) is
Flags : constant GL.Context.Context_Flags := GL.Context.Flags;
begin
Object.Version :=
(Major => GL.Context.Major_Version,
Minor => GL.Context.Minor_Version);
pragma Assert (Flags.Forward_Compatible);
Object.Flags.Debug := Flags.Debug;
Object.Flags.Robust := Flags.Robust_Access;
Object.Flags.No_Error := Flags.No_Error;
-- Other information about context can be read back as well with
-- GL.Context.Reset_Notification and GL.Context.Release_Behavior
Orka.Debug.Set_Log_Messages (Enable => Flags.Debug);
GL.Rasterization.Set_Provoking_Vertex (GL.Rasterization.First_Vertex);
GL.Viewports.Set_Clipping (GL.Viewports.Upper_Left, GL.Viewports.Zero_To_One);
-- Enable reversed Z for better depth precision at great distances
-- See https://developer.nvidia.com/content/depth-precision-visualized
-- for a visualization
GL.Buffers.Set_Depth_Function (GL.Types.Greater);
-- Note: When clearing the depth buffer, the value 0.0 instead of 1.0 must be used
-- Enable MSAA, face culling, and seamless cubemaps
GL.Toggles.Enable (GL.Toggles.Multisample);
GL.Toggles.Enable (GL.Toggles.Cull_Face);
GL.Toggles.Enable (GL.Toggles.Texture_Cube_Map_Seamless);
Object.Vertex_Array.Create;
end Post_Initialize;
function Create_Context
(Device : Standard.EGL.Objects.Devices.Device;
Version : Context_Version;
Flags : Context_Flags := (others => False)) return Device_EGL_Context
is
package EGL_Contexts renames Standard.EGL.Objects.Contexts;
package EGL_Displays renames Standard.EGL.Objects.Displays;
begin
Standard.EGL.Debug.Set_Message_Callback (Print_Error'Access);
declare
Display : constant EGL_Displays.Display := EGL_Displays.Create_Display (Device);
begin
return Result : Device_EGL_Context do
Result.Context := EGL_Contexts.Create_Context
(Display,
(Major => Version.Major,
Minor => Version.Minor),
(Debug => Flags.Debug,
Robust => Flags.Robust,
No_Error => Flags.No_Error));
Result.Context.Make_Current;
Post_Initialize (Result);
Print_Debug (Display, Result.Version, Flags);
end return;
end;
end Create_Context;
overriding
function Create_Context
(Version : Context_Version;
Flags : Context_Flags := (others => False)) return Device_EGL_Context
is
package EGL_Devices renames Standard.EGL.Objects.Devices;
Devices : constant EGL_Devices.Device_List := EGL_Devices.Devices;
begin
Log (Loggers.Debug, "EGL devices:");
for Device of Devices loop
declare
Name : constant String := Device.Name;
begin
Log (Loggers.Debug, " - " & (if Name /= "" then Name else "unknown"));
end;
end loop;
return Create_Context (Devices (Devices'First), Version, Flags);
end Create_Context;
overriding
procedure Finalize (Object : in out EGL_Context) is
begin
if Object.Flags.Debug then
Log (Loggers.Debug, "Shutting down EGL");
end if;
Object.Vertex_Array.Delete;
end Finalize;
overriding
procedure Update_State (Object : in out EGL_Context; State : Orka.Rendering.States.State) is
begin
Orka.Rendering.States.Apply_Changes (Object.Previous_State, State);
Object.Previous_State := State;
end Update_State;
overriding
procedure Make_Current (Object : Device_EGL_Context) is
begin
Object.Context.Make_Current;
end Make_Current;
overriding
procedure Make_Not_Current (Object : Device_EGL_Context) is
begin
Object.Context.Make_Not_Current;
end Make_Not_Current;
end Orka.Contexts.EGL;
|
persan/A-gst | Ada | 6,012 | ads | pragma Ada_2005;
pragma Style_Checks (Off);
pragma Warnings (Off);
with Interfaces.C; use Interfaces.C;
with glib;
with glib.Values;
with System;
with System;
-- limited with GStreamer.GST_Low_Level.glib_2_0_glib_gpoll_h;
with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h;
package GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpoll_h is
-- unsupported macro: GST_POLL_FD_INIT { -1, -1 }
-- GStreamer
-- * Copyright (C) 1999 Erik Walthinsen <[email protected]>
-- * Copyright (C) 2004 Wim Taymans <[email protected]>
-- * Copyright (C) 2007 Peter Kjellerstedt <[email protected]>
-- *
-- * gstpoll.h: File descriptor set
-- *
-- * This library is free software; you can redistribute it and/or
-- * modify it under the terms of the GNU Library General Public
-- * License as published by the Free Software Foundation; either
-- * version 2 of the License, or (at your option) any later version.
-- *
-- * This library is distributed in the hope that it will be useful,
-- * but WITHOUT ANY WARRANTY; without even the implied warranty of
-- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- * Library General Public License for more details.
-- *
-- * You should have received a copy of the GNU Library General Public
-- * License along with this library; if not, write to the
-- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- * Boston, MA 02111-1307, USA.
--
--*
-- * GstPoll:
-- *
-- * A set of file/network descriptors.
--
-- skipped empty struct u_GstPoll
-- skipped empty struct GstPoll
--*
-- * GstPollFD:
-- * @fd: a file descriptor
-- *
-- * A file descriptor object.
--
type GstPollFD is record
fd : aliased int; -- gst/gstpoll.h:48
idx : aliased GLIB.gint; -- gst/gstpoll.h:51
end record;
pragma Convention (C_Pass_By_Copy, GstPollFD); -- gst/gstpoll.h:52
-- skipped anonymous struct anon_243
--< private >
--*
-- * GST_POLL_FD_INIT:
-- *
-- * A #GstPollFD must be initialized with this macro, before it can be
-- * used. This macro can used be to initialize a variable, but it cannot
-- * be assigned to a variable. In that case you have to use
-- * gst_poll_fd_init().
-- *
-- * Since: 0.10.18
--
function gst_poll_new (controllable : GLIB.gboolean) return System.Address; -- gst/gstpoll.h:66
pragma Import (C, gst_poll_new, "gst_poll_new");
function gst_poll_new_timer return System.Address; -- gst/gstpoll.h:67
pragma Import (C, gst_poll_new_timer, "gst_poll_new_timer");
procedure gst_poll_free (set : System.Address); -- gst/gstpoll.h:68
pragma Import (C, gst_poll_free, "gst_poll_free");
procedure gst_poll_get_read_gpollfd (set : System.Address; fd : access GStreamer.GST_Low_Level.glib_2_0_glib_gpoll_h.GPollFD); -- gst/gstpoll.h:70
pragma Import (C, gst_poll_get_read_gpollfd, "gst_poll_get_read_gpollfd");
procedure gst_poll_fd_init (fd : access GstPollFD); -- gst/gstpoll.h:72
pragma Import (C, gst_poll_fd_init, "gst_poll_fd_init");
function gst_poll_add_fd (set : System.Address; fd : access GstPollFD) return GLIB.gboolean; -- gst/gstpoll.h:74
pragma Import (C, gst_poll_add_fd, "gst_poll_add_fd");
function gst_poll_remove_fd (set : System.Address; fd : access GstPollFD) return GLIB.gboolean; -- gst/gstpoll.h:75
pragma Import (C, gst_poll_remove_fd, "gst_poll_remove_fd");
function gst_poll_fd_ctl_write
(set : System.Address;
fd : access GstPollFD;
active : GLIB.gboolean) return GLIB.gboolean; -- gst/gstpoll.h:77
pragma Import (C, gst_poll_fd_ctl_write, "gst_poll_fd_ctl_write");
function gst_poll_fd_ctl_read
(set : System.Address;
fd : access GstPollFD;
active : GLIB.gboolean) return GLIB.gboolean; -- gst/gstpoll.h:78
pragma Import (C, gst_poll_fd_ctl_read, "gst_poll_fd_ctl_read");
procedure gst_poll_fd_ignored (set : System.Address; fd : access GstPollFD); -- gst/gstpoll.h:79
pragma Import (C, gst_poll_fd_ignored, "gst_poll_fd_ignored");
function gst_poll_fd_has_closed (set : System.Address; fd : access GstPollFD) return GLIB.gboolean; -- gst/gstpoll.h:81
pragma Import (C, gst_poll_fd_has_closed, "gst_poll_fd_has_closed");
function gst_poll_fd_has_error (set : System.Address; fd : access GstPollFD) return GLIB.gboolean; -- gst/gstpoll.h:82
pragma Import (C, gst_poll_fd_has_error, "gst_poll_fd_has_error");
function gst_poll_fd_can_read (set : System.Address; fd : access GstPollFD) return GLIB.gboolean; -- gst/gstpoll.h:83
pragma Import (C, gst_poll_fd_can_read, "gst_poll_fd_can_read");
function gst_poll_fd_can_write (set : System.Address; fd : access GstPollFD) return GLIB.gboolean; -- gst/gstpoll.h:84
pragma Import (C, gst_poll_fd_can_write, "gst_poll_fd_can_write");
function gst_poll_wait (set : System.Address; timeout : GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h.GstClockTime) return GLIB.gint; -- gst/gstpoll.h:86
pragma Import (C, gst_poll_wait, "gst_poll_wait");
function gst_poll_set_controllable (set : System.Address; controllable : GLIB.gboolean) return GLIB.gboolean; -- gst/gstpoll.h:88
pragma Import (C, gst_poll_set_controllable, "gst_poll_set_controllable");
procedure gst_poll_restart (set : System.Address); -- gst/gstpoll.h:89
pragma Import (C, gst_poll_restart, "gst_poll_restart");
procedure gst_poll_set_flushing (set : System.Address; flushing : GLIB.gboolean); -- gst/gstpoll.h:90
pragma Import (C, gst_poll_set_flushing, "gst_poll_set_flushing");
function gst_poll_write_control (set : System.Address) return GLIB.gboolean; -- gst/gstpoll.h:92
pragma Import (C, gst_poll_write_control, "gst_poll_write_control");
function gst_poll_read_control (set : System.Address) return GLIB.gboolean; -- gst/gstpoll.h:93
pragma Import (C, gst_poll_read_control, "gst_poll_read_control");
end GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpoll_h;
|
reznikmm/matreshka | Ada | 6,840 | adb | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Matreshka.DOM_Documents;
with Matreshka.ODF_String_Constants;
with ODF.DOM.Iterators;
with ODF.DOM.Visitors;
package body Matreshka.ODF_Text.Ruby_Text_Elements is
------------
-- Create --
------------
overriding function Create
(Parameters : not null access Matreshka.DOM_Elements.Element_L2_Parameters)
return Text_Ruby_Text_Element_Node is
begin
return Self : Text_Ruby_Text_Element_Node do
Matreshka.ODF_Text.Constructors.Initialize
(Self'Unchecked_Access,
Parameters.Document,
Matreshka.ODF_String_Constants.Text_Prefix);
end return;
end Create;
----------------
-- Enter_Node --
----------------
overriding procedure Enter_Node
(Self : not null access Text_Ruby_Text_Element_Node;
Visitor : in out XML.DOM.Visitors.Abstract_Visitor'Class;
Control : in out XML.DOM.Visitors.Traverse_Control) is
begin
if Visitor in ODF.DOM.Visitors.Abstract_ODF_Visitor'Class then
ODF.DOM.Visitors.Abstract_ODF_Visitor'Class
(Visitor).Enter_Text_Ruby_Text
(ODF.DOM.Text_Ruby_Text_Elements.ODF_Text_Ruby_Text_Access
(Self),
Control);
else
Matreshka.DOM_Elements.Abstract_Element_Node
(Self.all).Enter_Node (Visitor, Control);
end if;
end Enter_Node;
--------------------
-- Get_Local_Name --
--------------------
overriding function Get_Local_Name
(Self : not null access constant Text_Ruby_Text_Element_Node)
return League.Strings.Universal_String
is
pragma Unreferenced (Self);
begin
return Matreshka.ODF_String_Constants.Ruby_Text_Element;
end Get_Local_Name;
----------------
-- Leave_Node --
----------------
overriding procedure Leave_Node
(Self : not null access Text_Ruby_Text_Element_Node;
Visitor : in out XML.DOM.Visitors.Abstract_Visitor'Class;
Control : in out XML.DOM.Visitors.Traverse_Control) is
begin
if Visitor in ODF.DOM.Visitors.Abstract_ODF_Visitor'Class then
ODF.DOM.Visitors.Abstract_ODF_Visitor'Class
(Visitor).Leave_Text_Ruby_Text
(ODF.DOM.Text_Ruby_Text_Elements.ODF_Text_Ruby_Text_Access
(Self),
Control);
else
Matreshka.DOM_Elements.Abstract_Element_Node
(Self.all).Leave_Node (Visitor, Control);
end if;
end Leave_Node;
----------------
-- Visit_Node --
----------------
overriding procedure Visit_Node
(Self : not null access Text_Ruby_Text_Element_Node;
Iterator : in out XML.DOM.Visitors.Abstract_Iterator'Class;
Visitor : in out XML.DOM.Visitors.Abstract_Visitor'Class;
Control : in out XML.DOM.Visitors.Traverse_Control) is
begin
if Iterator in ODF.DOM.Iterators.Abstract_ODF_Iterator'Class then
ODF.DOM.Iterators.Abstract_ODF_Iterator'Class
(Iterator).Visit_Text_Ruby_Text
(Visitor,
ODF.DOM.Text_Ruby_Text_Elements.ODF_Text_Ruby_Text_Access
(Self),
Control);
else
Matreshka.DOM_Elements.Abstract_Element_Node
(Self.all).Visit_Node (Iterator, Visitor, Control);
end if;
end Visit_Node;
begin
Matreshka.DOM_Documents.Register_Element
(Matreshka.ODF_String_Constants.Text_URI,
Matreshka.ODF_String_Constants.Ruby_Text_Element,
Text_Ruby_Text_Element_Node'Tag);
end Matreshka.ODF_Text.Ruby_Text_Elements;
|
persan/A-gst | Ada | 6,521 | ads | pragma Ada_2005;
pragma Style_Checks (Off);
pragma Warnings (Off);
with Interfaces.C; use Interfaces.C;
with glib;
with glib.Values;
with System;
with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h;
-- limited with GStreamer.GST_Low_Level.glib_2_0_glib_glist_h;
-- with GStreamer.GST_Low_Level.libxml2_libxml_tree_h;
with glib;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstelement_h;
with Interfaces.C_Streams;
package GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstxml_h is
-- unsupported macro: GST_TYPE_XML (gst_xml_get_type ())
-- arg-macro: function GST_XML (obj)
-- return G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_XML, GstXML);
-- arg-macro: function GST_IS_XML (obj)
-- return G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_XML);
-- arg-macro: function GST_XML_CLASS (klass)
-- return G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_XML, GstXMLClass);
-- arg-macro: function GST_IS_XML_CLASS (klass)
-- return G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_XML);
-- arg-macro: function GST_XML_GET_CLASS (obj)
-- return G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_XML, GstXMLClass);
-- GStreamer
-- * Copyright (C) 1999,2000 Erik Walthinsen <[email protected]>
-- * 2000 Wim Taymans <[email protected]>
-- *
-- * gstxml.h: Header for XML save/restore operations of pipelines
-- *
-- * This library is free software; you can redistribute it and/or
-- * modify it under the terms of the GNU Library General Public
-- * License as published by the Free Software Foundation; either
-- * version 2 of the License, or (at your option) any later version.
-- *
-- * This library is distributed in the hope that it will be useful,
-- * but WITHOUT ANY WARRANTY; without even the implied warranty of
-- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- * Library General Public License for more details.
-- *
-- * You should have received a copy of the GNU Library General Public
-- * License along with this library; if not, write to the
-- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- * Boston, MA 02111-1307, USA.
--
type GstXML;
type u_GstXML_u_gst_reserved_array is array (0 .. 3) of System.Address;
--subtype GstXML is u_GstXML; -- gst/gstxml.h:42
type GstXMLClass;
type u_GstXMLClass_u_gst_reserved_array is array (0 .. 3) of System.Address;
--subtype GstXMLClass is u_GstXMLClass; -- gst/gstxml.h:43
--*
-- * GstXML:
-- * @topelements: list of element nodes
-- * @ns: name space
-- *
-- * XML parser object
--
type GstXML is record
object : aliased GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObject; -- gst/gstxml.h:53
topelements : access GStreamer.GST_Low_Level.glib_2_0_glib_glist_h.GList; -- gst/gstxml.h:56
ns : GStreamer.GST_Low_Level.libxml2_libxml_tree_h.xmlNsPtr; -- gst/gstxml.h:58
u_gst_reserved : u_GstXML_u_gst_reserved_array; -- gst/gstxml.h:61
end record;
pragma Convention (C_Pass_By_Copy, GstXML); -- gst/gstxml.h:52
--< public >
--< private >
type GstXMLClass is record
parent_class : aliased GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObjectClass; -- gst/gstxml.h:65
object_loaded : access procedure
(arg1 : access GstXML;
arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObject;
arg3 : GStreamer.GST_Low_Level.libxml2_libxml_tree_h.xmlNodePtr); -- gst/gstxml.h:68
object_saved : access procedure
(arg1 : access GstXML;
arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObject;
arg3 : GStreamer.GST_Low_Level.libxml2_libxml_tree_h.xmlNodePtr); -- gst/gstxml.h:69
u_gst_reserved : u_GstXMLClass_u_gst_reserved_array; -- gst/gstxml.h:71
end record;
pragma Convention (C_Pass_By_Copy, GstXMLClass); -- gst/gstxml.h:64
-- signal callbacks
function gst_xml_get_type return GLIB.GType; -- gst/gstxml.h:74
pragma Import (C, gst_xml_get_type, "gst_xml_get_type");
-- create an XML document out of a pipeline
function gst_xml_write (element : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstelement_h.GstElement) return GStreamer.GST_Low_Level.libxml2_libxml_tree_h.xmlDocPtr; -- gst/gstxml.h:78
pragma Import (C, gst_xml_write, "gst_xml_write");
-- write a formatted representation of a pipeline to an open file
function gst_xml_write_file (element : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstelement_h.GstElement; c_out : Interfaces.C_Streams.FILEs) return GLIB.gint; -- gst/gstxml.h:81
pragma Import (C, gst_xml_write_file, "gst_xml_write_file");
function gst_xml_new return access GstXML; -- gst/gstxml.h:83
pragma Import (C, gst_xml_new, "gst_xml_new");
function gst_xml_parse_doc
(xml : access GstXML;
doc : GStreamer.GST_Low_Level.libxml2_libxml_tree_h.xmlDocPtr;
root : access GLIB.guchar) return GLIB.gboolean; -- gst/gstxml.h:85
pragma Import (C, gst_xml_parse_doc, "gst_xml_parse_doc");
function gst_xml_parse_file
(xml : access GstXML;
fname : access GLIB.guchar;
root : access GLIB.guchar) return GLIB.gboolean; -- gst/gstxml.h:86
pragma Import (C, gst_xml_parse_file, "gst_xml_parse_file");
function gst_xml_parse_memory
(xml : access GstXML;
buffer : access GLIB.guchar;
size : GLIB.guint;
root : access GLIB.gchar) return GLIB.gboolean; -- gst/gstxml.h:87
pragma Import (C, gst_xml_parse_memory, "gst_xml_parse_memory");
function gst_xml_get_element (xml : access GstXML; name : access GLIB.guchar) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstelement_h.GstElement; -- gst/gstxml.h:90
pragma Import (C, gst_xml_get_element, "gst_xml_get_element");
function gst_xml_get_topelements (xml : access GstXML) return access GStreamer.GST_Low_Level.glib_2_0_glib_glist_h.GList; -- gst/gstxml.h:91
pragma Import (C, gst_xml_get_topelements, "gst_xml_get_topelements");
function gst_xml_make_element (cur : GStreamer.GST_Low_Level.libxml2_libxml_tree_h.xmlNodePtr; parent : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObject) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstelement_h.GstElement; -- gst/gstxml.h:93
pragma Import (C, gst_xml_make_element, "gst_xml_make_element");
end GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstxml_h;
|
AdaCore/libadalang | Ada | 22,665 | adb | --
-- Copyright (C) 2014-2022, AdaCore
-- SPDX-License-Identifier: Apache-2.0
--
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Libadalang.Analysis; use Libadalang.Analysis;
with Libadalang.Public_Converters; use Libadalang.Public_Converters;
package body Libadalang.Env_Hooks is
use Support.Text;
Text_IO : constant Text_Type := "ada.text_io";
Wide_Text_IO : constant Text_Type := "ada.wide_text_io";
Wide_Wide_Text_IO : constant Text_Type := "ada.wide_wide_text_io";
Integer_IO : aliased constant Text_Type := "integer_io";
Modular_IO : aliased constant Text_Type := "modular_io";
Float_IO : aliased constant Text_Type := "float_io";
Fixed_IO : aliased constant Text_Type := "fixed_io";
Decimal_IO : aliased constant Text_Type := "decimal_io";
Enumeration_IO : aliased constant Text_Type := "enumeration_io";
Text_IO_Subpackages :
constant array (Positive range <>) of access constant Text_Type
:= (Integer_IO'Access, Modular_IO'Access, Float_IO'Access,
Fixed_IO'Access, Decimal_IO'Access, Enumeration_IO'Access);
-- The content of the following string literal has been generated running
-- GNAT with flag -gnatS, and then post-processed by hand.
Std_Content : constant String :=
"package Standard is" & ASCII.LF &
"pragma Pure(Standard);" & ASCII.LF &
" type Boolean is (False, True);" & ASCII.LF &
" type Integer is range -(2 ** 31) .. +(2 ** 31 - 1);" & ASCII.LF &
" subtype Natural is Integer range 0 .. +(2 ** 31 - 1);" & ASCII.LF &
" subtype Positive is Integer range 1 .. +(2 ** 31 - 1);" & ASCII.LF &
" type Short_Short_Integer is range -(2 ** 7) .. +(2 ** 7 - 1);"
& ASCII.LF &
" type Short_Integer is range -(2 ** 15) .. +(2 ** 15 - 1);"
& ASCII.LF &
" type Long_Integer is range -(2 ** 31) .. +(2 ** 31 - 1);"
& ASCII.LF &
" type Long_Long_Integer is range -(2 ** 63) .. +(2 ** 63 - 1);"
& ASCII.LF &
" type Long_Long_Long_Integer is range -(2 ** 127) .. +(2 ** 127 - 1);"
& ASCII.LF &
" type Short_Float is digits 6" & ASCII.LF &
" range -16#0.FFFF_FF#E+32 .. 16#0.FFFF_FF#E+32;" & ASCII.LF &
" type Float is digits 6" & ASCII.LF &
" range -16#0.FFFF_FF#E+32 .. 16#0.FFFF_FF#E+32;" & ASCII.LF &
" type Long_Float is digits 15" & ASCII.LF &
" range -16#0.FFFF_FFFF_FFFF_F8#E+256 .. 16#0.FFFF_FFFF_FFFF_F8#E+256;"
& ASCII.LF &
" type Long_Long_Float is digits 18" & ASCII.LF &
" range -16#0.FFFF_FFFF_FFFF_FFFF#E+4096 .. " & ASCII.LF &
"16#0.FFFF_FFFF_FFFF_FFFF#E+4096;" & ASCII.LF &
" type Character is ('A');" & ASCII.LF &
" type Wide_Character is ('A');" & ASCII.LF &
" type Wide_Wide_Character is ('A');" & ASCII.LF &
" package ASCII is" & ASCII.LF &
" NUL : constant Character := Character'Val (16#00#);" & ASCII.LF &
" SOH : constant Character := Character'Val (16#01#);" & ASCII.LF &
" STX : constant Character := Character'Val (16#02#);" & ASCII.LF &
" ETX : constant Character := Character'Val (16#03#);" & ASCII.LF &
" EOT : constant Character := Character'Val (16#04#);" & ASCII.LF &
" ENQ : constant Character := Character'Val (16#05#);" & ASCII.LF &
" ACK : constant Character := Character'Val (16#06#);" & ASCII.LF &
" BEL : constant Character := Character'Val (16#07#);" & ASCII.LF &
" BS : constant Character := Character'Val (16#08#);" & ASCII.LF &
" HT : constant Character := Character'Val (16#09#);" & ASCII.LF &
" LF : constant Character := Character'Val (16#0A#);" & ASCII.LF &
" VT : constant Character := Character'Val (16#0B#);" & ASCII.LF &
" FF : constant Character := Character'Val (16#0C#);" & ASCII.LF &
" CR : constant Character := Character'Val (16#0D#);" & ASCII.LF &
" SO : constant Character := Character'Val (16#0E#);" & ASCII.LF &
" SI : constant Character := Character'Val (16#0F#);" & ASCII.LF &
" DLE : constant Character := Character'Val (16#10#);" & ASCII.LF &
" DC1 : constant Character := Character'Val (16#11#);" & ASCII.LF &
" DC2 : constant Character := Character'Val (16#12#);" & ASCII.LF &
" DC3 : constant Character := Character'Val (16#13#);" & ASCII.LF &
" DC4 : constant Character := Character'Val (16#14#);" & ASCII.LF &
" NAK : constant Character := Character'Val (16#15#);" & ASCII.LF &
" SYN : constant Character := Character'Val (16#16#);" & ASCII.LF &
" ETB : constant Character := Character'Val (16#17#);" & ASCII.LF &
" CAN : constant Character := Character'Val (16#18#);" & ASCII.LF &
" EM : constant Character := Character'Val (16#19#);" & ASCII.LF &
" SUB : constant Character := Character'Val (16#1A#);" & ASCII.LF &
" ESC : constant Character := Character'Val (16#1B#);" & ASCII.LF &
" FS : constant Character := Character'Val (16#1C#);" & ASCII.LF &
" GS : constant Character := Character'Val (16#1D#);" & ASCII.LF &
" RS : constant Character := Character'Val (16#1E#);" & ASCII.LF &
" US : constant Character := Character'Val (16#1F#);" & ASCII.LF &
" DEL : constant Character := Character'Val (16#7F#);" & ASCII.LF &
" Exclam : constant Character := '!';" & ASCII.LF &
" Quotation : constant Character := '""';" & ASCII.LF &
" Sharp : constant Character := '#';" & ASCII.LF &
" Dollar : constant Character := '$';" & ASCII.LF &
" Percent : constant Character := '%';" & ASCII.LF &
" Ampersand : constant Character := '&';" & ASCII.LF &
" Colon : constant Character := ':';" & ASCII.LF &
" Semicolon : constant Character := ';';" & ASCII.LF &
" Query : constant Character := '?';" & ASCII.LF &
" At_Sign : constant Character := '@';" & ASCII.LF &
" L_Bracket : constant Character := '[';" & ASCII.LF &
" Back_Slash : constant Character := '\';" & ASCII.LF &
" R_Bracket : constant Character := ']';" & ASCII.LF &
" Circumflex : constant Character := '^';" & ASCII.LF &
" Underline : constant Character := '_';" & ASCII.LF &
" Grave : constant Character := '`';" & ASCII.LF &
" L_Brace : constant Character := '{';" & ASCII.LF &
" Bar : constant Character := '|';" & ASCII.LF &
" R_Brace : constant Character := '}';" & ASCII.LF &
" Tilde : constant Character := '~';" & ASCII.LF &
" LC_A : constant Character := 'a';" & ASCII.LF &
" LC_B : constant Character := 'b';" & ASCII.LF &
" LC_C : constant Character := 'c';" & ASCII.LF &
" LC_D : constant Character := 'd';" & ASCII.LF &
" LC_E : constant Character := 'e';" & ASCII.LF &
" LC_F : constant Character := 'f';" & ASCII.LF &
" LC_G : constant Character := 'g';" & ASCII.LF &
" LC_H : constant Character := 'h';" & ASCII.LF &
" LC_I : constant Character := 'i';" & ASCII.LF &
" LC_J : constant Character := 'j';" & ASCII.LF &
" LC_K : constant Character := 'k';" & ASCII.LF &
" LC_L : constant Character := 'l';" & ASCII.LF &
" LC_M : constant Character := 'm';" & ASCII.LF &
" LC_N : constant Character := 'n';" & ASCII.LF &
" LC_O : constant Character := 'o';" & ASCII.LF &
" LC_P : constant Character := 'p';" & ASCII.LF &
" LC_Q : constant Character := 'q';" & ASCII.LF &
" LC_R : constant Character := 'r';" & ASCII.LF &
" LC_S : constant Character := 's';" & ASCII.LF &
" LC_T : constant Character := 't';" & ASCII.LF &
" LC_U : constant Character := 'u';" & ASCII.LF &
" LC_V : constant Character := 'v';" & ASCII.LF &
" LC_W : constant Character := 'w';" & ASCII.LF &
" LC_X : constant Character := 'x';" & ASCII.LF &
" LC_Y : constant Character := 'y';" & ASCII.LF &
" LC_Z : constant Character := 'z';" & ASCII.LF &
" end ASCII;" & ASCII.LF &
" type String is array (Positive range <>) of Character;" & ASCII.LF &
" pragma Pack (String);" & ASCII.LF &
" type Wide_String is array " & ASCII.LF &
"(Positive range <>) of Wide_Character;" & ASCII.LF &
" type Wide_Wide_String is array " & ASCII.LF &
"(Positive range <>) of Wide_Wide_Character;" & ASCII.LF &
" pragma Pack (Wide_String);" & ASCII.LF &
" type Duration is delta 0.000000001" & ASCII.LF &
" range -((2 ** 63 - 1) * 0.000000001) .." & ASCII.LF &
" +((2 ** 63 - 1) * 0.000000001);" & ASCII.LF &
" for Duration'Small use 0.000000001;" & ASCII.LF &
" type Universal_Int_Type_ is range -1 .. 1;" & ASCII.LF &
" type Universal_Real_Type_ is digits 16;" & ASCII.LF &
" package root_types_ is" & ASCII.LF &
" type root_integer is range -1 .. 1;" & ASCII.LF &
" type root_real is digits 16;" & ASCII.LF & ASCII.LF &
" end root_types_;" & ASCII.LF &
" Constraint_Error : exception;" & ASCII.LF &
" Numeric_Error : exception;" & ASCII.LF &
" Program_Error : exception;" & ASCII.LF &
" Storage_Error : exception;" & ASCII.LF &
" Tasking_Error : exception;" & ASCII.LF &
" Abort_Signal_ : exception;" & ASCII.LF &
"end Standard;" & ASCII.LF;
---------------------
-- Name_To_Symbols --
---------------------
function Name_To_Symbols (Name : Bare_Name) return Symbol_Type_Array is
begin
if Name = null then
raise Property_Error with "fatal parsing error in Name_To_Symbols";
end if;
case Defining_Name_Nodes (Name.Kind) is
when Ada_Base_Id =>
return (1 => Get_Symbol (Name));
when Ada_Dotted_Name =>
return Name_To_Symbols (Name.Dotted_Name_F_Prefix)
& Name_To_Symbols (Name.Dotted_Name_F_Suffix);
when Ada_Defining_Name =>
return Name_To_Symbols (Name.Defining_Name_F_Name);
end case;
end Name_To_Symbols;
---------------
-- To_String --
---------------
function To_String (Name : Symbol_Type_Array) return Text_Type
is
(if Name'Length > 0
then Name (Name'First).all
& (if Name'Length > 1
then "." & To_String (Name (Name'First + 1 .. Name'Last))
else "")
else "");
----------------
-- Fetch_Unit --
----------------
function Fetch_Unit
(Ctx : Internal_Context;
Name : Symbol_Type_Array;
Kind : Analysis_Unit_Kind;
From_Unit : Internal_Unit;
Load_If_Needed : Boolean;
Do_Prepare_Nameres : Boolean := True;
Not_Found_Is_Error : Boolean := False;
Process_Parents : Boolean := True) return Internal_Unit
is
procedure Prepare_Nameres
(Unit : Internal_Unit; PLE_Root_Index : Positive);
-- Prepare semantic analysis for the compilation unit at
-- ``Unit``/``PLE_Root_Index`` and add a reference from ``From_Unit`` to
-- ``Unit``.
procedure Emit_Unit_Requested
(Unit : Internal_Unit;
Not_Found_Is_Error : Boolean);
-- If there is an event handler, invoke its ``Unit_Requested_Callback``
-- event for ``Unit``. ``Not_Found_Is_Error`` is forwarded as-is to the
-- callback.
---------------------
-- Prepare_Nameres --
---------------------
procedure Prepare_Nameres
(Unit : Internal_Unit; PLE_Root_Index : Positive) is
begin
if Unit.Ast_Root /= null then
Populate_Lexical_Env (Wrap_Unit (Unit), PLE_Root_Index);
Reference_Unit (From => From_Unit,
Referenced => Unit);
end if;
end Prepare_Nameres;
-------------------------
-- Emit_Unit_Requested --
-------------------------
procedure Emit_Unit_Requested
(Unit : Internal_Unit;
Not_Found_Is_Error : Boolean) is
begin
-- TODO??? We now handle file not found via
-- ``Unit_Requested_Callback``, but we don't really handle parsing
-- errors directly. Do we need to do something more? Or can we
-- consider that anything can be done in the callback anyway?
if Ctx.Event_Handler /= null then
Ctx.Event_Handler.Unit_Requested_Callback
(Ctx,
To_Text (Get_Filename (Unit)),
From_Unit,
Unit.Ast_Root /= null,
Not_Found_Is_Error);
end if;
end Emit_Unit_Requested;
Unit_Name : constant Text_Type := To_String (Name);
Unit : Internal_Unit;
PLE_Root_Index : Positive;
begin
-- If we must not load missing units and this one is missing, do
-- nothing.
if not Load_If_Needed then
declare
Filename : String_Access;
begin
Get_Unit_Location
(Context => Ctx,
Name => Unit_Name,
Kind => Kind,
Filename => Filename,
PLE_Root_Index => PLE_Root_Index);
if not Has_Unit (Ctx, Filename.all) then
return null;
end if;
end;
end if;
-- If we are not preparing nameres, we can directly return the unit
-- corresponding to the entire name.
if not Do_Prepare_Nameres then
Get_Unit_And_PLE_Root
(Context => Ctx,
Name => Unit_Name,
Kind => Kind,
Unit => Unit,
PLE_Root_Index => PLE_Root_Index);
return Unit;
end if;
-- GNAT kludge: as an "optimization", the generic subpackages in
-- Ada.Text_IO (see Text_IO_Subpackages) are not present in the
-- Ada.Text_IO unit itself, but in private child packages. GNAT
-- magically imports them in Ada.Text_IO's namespace.
--
-- Here, try to import these child units as soon as someone WITHes
-- Ada.Text_IO.
if Kind = Unit_Specification
and then Unit_Name in Text_IO | Wide_Text_IO | Wide_Wide_Text_IO
then
for SP of Text_IO_Subpackages loop
declare
SP_Symbol : constant Symbol_Type :=
Lookup_Symbol (Ctx, SP.all);
SP_FQN : constant Symbol_Type_Array := Name & SP_Symbol;
begin
Get_Unit_And_PLE_Root
(Context => Ctx,
Name => To_String (SP_FQN),
Kind => Kind,
Unit => Unit,
PLE_Root_Index => PLE_Root_Index);
Prepare_Nameres (Unit, PLE_Root_Index);
end;
end loop;
end if;
-- If we should load only the unit that ``Name`` and ``Kind`` designate,
-- return it now and return. Do not forget to emit the "unit requested
-- callback" event.
if not Process_Parents then
Get_Unit_And_PLE_Root
(Context => Ctx,
Name => Unit_Name,
Kind => Kind,
Unit => Unit,
PLE_Root_Index => PLE_Root_Index);
Emit_Unit_Requested (Unit, Not_Found_Is_Error);
Prepare_Nameres (Unit, PLE_Root_Index);
return Unit;
end if;
declare
procedure Step
(Name : Symbol_Type_Array; Index : Positive);
-- Step into each portion of ``Name``, resolving each unit
-- incrementally. This is a recursive procedure, that will resolve
-- the name upwards from ``Name (Index)``.
--
-- This is a recursive procedure rather than a loop so that we can
-- handle package renamings, and modify the currently examined name:
-- For example, given the name ``("Text_IO", "Complex_IO")``, and
-- given ``"Text_IO"`` designates a package renaming to
-- ``Ada.Text_IO``, we will resolve the package renaming, and the
-- first recursive call to ``Step`` will be
--
-- ``Step (("Ada", "Text_IO", "Complex_IO"), 3)`` where we
-- substituted the renaming package to the renamed entity, and
-- incremented the index accordingly.
----------
-- Step --
----------
procedure Step
(Name : Symbol_Type_Array;
Index : Positive)
is
Is_Last : constant Boolean := Index = Name'Last;
-- Whether this call to ``Step`` is the last one, i.e. the one to
-- fetch the unit to return.
Current_Name : constant Text_Type :=
To_String (Name (Name'First .. Index));
I_Kind : constant Analysis_Unit_Kind :=
(if Is_Last then Kind else Unit_Specification);
-- When looking for unit ``A.B``, ``A`` is a specification even if
-- we mean to fetch ``B``'s body, unless ``B`` is a subunit (in
-- that case ``A`` must have a body).
begin
Get_Unit_And_PLE_Root
(Context => Ctx,
Name => Current_Name,
Kind => I_Kind,
Unit => Unit,
PLE_Root_Index => PLE_Root_Index);
-- If we are trying to fetch a dependency of the requested unit,
-- it may be a subunit: if fetching a spec did not work, try
-- fetching a body instead.
if not Is_Last and then Unit.Ast_Root = null then
declare
B : Internal_Unit;
I : Positive;
begin
Get_Unit_And_PLE_Root
(Context => Ctx,
Name => Current_Name,
Kind => Unit_Body,
Unit => B,
PLE_Root_Index => I);
Emit_Unit_Requested
(Unit => B, Not_Found_Is_Error => False);
-- Consider the body for the rest of the processing iff we
-- have found it, otherwise keep the spec unit in ``Unit``.
if B.Ast_Root /= null then
Unit := B;
PLE_Root_Index := I;
end if;
end;
end if;
-- Consider that a missing unit is an error if
-- ``Not_Found_Is_Error`` or if ``Unit`` is not the requested unit
-- (i.e. just another unit in the closure).
Emit_Unit_Requested
(Unit => Unit,
Not_Found_Is_Error => not Is_Last or else Not_Found_Is_Error);
Prepare_Nameres (Unit, PLE_Root_Index);
-- We're on the last portion of the name: return
if Is_Last then
return;
end if;
-- Else, recurse
declare
Internal_Name : Symbol_Type_Array_Access :=
Create_Symbol_Type_Array (Internal_Symbol_Type_Array (Name));
Comp_Unit : constant Compilation_Unit := Wrap_Node
(Ada_Node_P_Compilation_Unit_With_Name
(Unit.Ast_Root, Unit, Internal_Name)).As_Compilation_Unit;
Decl : constant Basic_Decl :=
(if Comp_Unit.Is_Null
then No_Basic_Decl
else Comp_Unit.P_Decl);
begin
if not Decl.Is_Null
and then Decl.Kind in
Libadalang.Common.Ada_Package_Renaming_Decl_Range
then
-- If the declaration is a package renaming, resolve the
-- renamed package..
declare
Target : constant Basic_Decl :=
Decl.As_Package_Renaming_Decl.P_Final_Renamed_Package;
Resolved_Name : Symbol_Type_Array_Access :=
Basic_Decl_P_Fully_Qualified_Name_Array
(Unwrap_Node (Target));
New_Index : constant Positive :=
Resolved_Name.Items'Last + 1;
begin
-- .. and make the next call to step consider the renamed
-- package.
Step
(Name => Symbol_Type_Array (Resolved_Name.Items)
& Name (Index + 1 .. Name'Last),
Index => New_Index);
Free (Resolved_Name);
exception
when Precondition_Failure | Property_Error =>
Free (Resolved_Name);
raise;
end;
else
-- Else, just resolve the next portion of the given name
Step (Name, Index + 1);
end if;
Dec_Ref (Internal_Name);
exception
when Precondition_Failure | Property_Error =>
Free (Internal_Name);
raise;
end;
end Step;
begin
Step (Name, Name'First);
end;
return Unit;
end Fetch_Unit;
--------------------
-- Fetch_Standard --
--------------------
procedure Fetch_Standard (Context : Internal_Context) is
Std : constant Internal_Unit := Get_Unit
(Context => Context,
Filename => "__standard",
Charset => "ascii",
Reparse => True,
Input => (Kind => Bytes_Buffer,
Charset => To_Unbounded_String ("ascii"),
Read_BOM => False,
Bytes => Std_Content'Address,
Bytes_Count => Std_Content'Length),
Rule => Default_Grammar_Rule,
Is_Internal => True);
begin
Populate_Lexical_Env (Std, 1);
end Fetch_Standard;
end Libadalang.Env_Hooks;
|
reznikmm/matreshka | Ada | 3,774 | ads | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Open Document Toolkit --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2014, Vadim Godunko <[email protected]> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with XML.DOM.Attributes;
package ODF.DOM.Presentation_Master_Element_Attributes is
pragma Preelaborate;
type ODF_Presentation_Master_Element_Attribute is limited interface
and XML.DOM.Attributes.DOM_Attribute;
type ODF_Presentation_Master_Element_Attribute_Access is
access all ODF_Presentation_Master_Element_Attribute'Class
with Storage_Size => 0;
end ODF.DOM.Presentation_Master_Element_Attributes;
|
landgraf/nanomsg-ada | Ada | 1,693 | ads | -- The MIT License (MIT)
-- Copyright (c) 2015 Pavel Zhukov <[email protected]>
-- Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:
-- The above copyright notice and this permission notice shall be included in all
-- copies or substantial portions of the Software.
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-- SOFTWARE.
with Aunit; use Aunit;
with Nanomsg.Socket;
with Aunit.Simple_Test_Cases;
package Nanomsg.Test_Message_Send_Receive_Million is
type TC is new Simple_Test_Cases.Test_Case with record
Socket1 : Nanomsg.Socket.Socket_T;
Socket2 : Nanomsg.Socket.Socket_T;
end record;
overriding
procedure Tear_Down (T : in out Tc);
overriding
procedure Run_Test (T : in out TC);
overriding
function Name (T : TC) return Message_String;
end Nanomsg.Test_Message_Send_Receive_Million;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.