text
stringlengths 4
1.04M
|
|---|
------------------------------------------------------------------------------
-- --
-- GNAT LIBRARY COMPONENTS --
-- --
-- A D A . C O N T A I N E R S . F O R M A L _ H A S H E D _ M A P S --
-- --
-- S p e c --
-- --
-- Copyright (C) 2004-2019, Free Software Foundation, Inc. --
-- --
-- This specification is derived from the Ada Reference Manual for use with --
-- GNAT. The copyright notice above, and the license provisions that follow --
-- apply solely to the contents of the part following the private keyword. --
-- --
-- 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/>. --
------------------------------------------------------------------------------
-- This spec is derived from package Ada.Containers.Bounded_Hashed_Maps in the
-- Ada 2012 RM. The modifications are meant to facilitate formal proofs by
-- making it easier to express properties, and by making the specification of
-- this unit compatible with SPARK 2014. Note that the API of this unit may be
-- subject to incompatible changes as SPARK 2014 evolves.
-- The modifications are:
-- A parameter for the container is added to every function reading the
-- contents of a container: Key, Element, Next, Query_Element, Has_Element,
-- Iterate, Equivalent_Keys. This change is motivated by the need to have
-- cursors which are valid on different containers (typically a container C
-- and its previous version C'Old) for expressing properties, which is not
-- possible if cursors encapsulate an access to the underlying container.
-- Iteration over maps is done using the Iterable aspect, which is SPARK
-- compatible. "For of" iteration ranges over keys instead of elements.
with Ada.Containers.Functional_Vectors;
with Ada.Containers.Functional_Maps;
private with Ada.Containers.Hash_Tables;
generic
type Key_Type is private;
type Element_Type is private;
with function Hash (Key : Key_Type) return Hash_Type;
with function Equivalent_Keys
(Left : Key_Type;
Right : Key_Type) return Boolean is "=";
package Ada.Containers.Formal_Hashed_Maps with
SPARK_Mode
is
pragma Annotate (CodePeer, Skip_Analysis);
type Map (Capacity : Count_Type; Modulus : Hash_Type) is private with
Iterable => (First => First,
Next => Next,
Has_Element => Has_Element,
Element => Key),
Default_Initial_Condition => Is_Empty (Map);
pragma Preelaborable_Initialization (Map);
Empty_Map : constant Map;
type Cursor is record
Node : Count_Type;
end record;
No_Element : constant Cursor := (Node => 0);
function Length (Container : Map) return Count_Type with
Global => null,
Post => Length'Result <= Container.Capacity;
pragma Unevaluated_Use_Of_Old (Allow);
package Formal_Model with Ghost is
subtype Positive_Count_Type is Count_Type range 1 .. Count_Type'Last;
package M is new Ada.Containers.Functional_Maps
(Element_Type => Element_Type,
Key_Type => Key_Type,
Equivalent_Keys => Equivalent_Keys);
function "="
(Left : M.Map;
Right : M.Map) return Boolean renames M."=";
function "<="
(Left : M.Map;
Right : M.Map) return Boolean renames M."<=";
package K is new Ada.Containers.Functional_Vectors
(Element_Type => Key_Type,
Index_Type => Positive_Count_Type);
function "="
(Left : K.Sequence;
Right : K.Sequence) return Boolean renames K."=";
function "<"
(Left : K.Sequence;
Right : K.Sequence) return Boolean renames K."<";
function "<="
(Left : K.Sequence;
Right : K.Sequence) return Boolean renames K."<=";
function Find (Container : K.Sequence; Key : Key_Type) return Count_Type
-- Search for Key in Container
with
Global => null,
Post =>
(if Find'Result > 0 then
Find'Result <= K.Length (Container)
and Equivalent_Keys (Key, K.Get (Container, Find'Result)));
function K_Keys_Included
(Left : K.Sequence;
Right : K.Sequence) return Boolean
-- Return True if Right contains all the keys of Left
with
Global => null,
Post =>
K_Keys_Included'Result =
(for all I in 1 .. K.Length (Left) =>
Find (Right, K.Get (Left, I)) > 0
and then K.Get (Right, Find (Right, K.Get (Left, I))) =
K.Get (Left, I));
package P is new Ada.Containers.Functional_Maps
(Key_Type => Cursor,
Element_Type => Positive_Count_Type,
Equivalent_Keys => "=",
Enable_Handling_Of_Equivalence => False);
function "="
(Left : P.Map;
Right : P.Map) return Boolean renames P."=";
function "<="
(Left : P.Map;
Right : P.Map) return Boolean renames P."<=";
function Mapping_Preserved
(K_Left : K.Sequence;
K_Right : K.Sequence;
P_Left : P.Map;
P_Right : P.Map) return Boolean
with
Global => null,
Post =>
(if Mapping_Preserved'Result then
-- Right contains all the cursors of Left
P.Keys_Included (P_Left, P_Right)
-- Right contains all the keys of Left
and K_Keys_Included (K_Left, K_Right)
-- Mappings from cursors to elements induced by K_Left, P_Left
-- and K_Right, P_Right are the same.
and (for all C of P_Left =>
K.Get (K_Left, P.Get (P_Left, C)) =
K.Get (K_Right, P.Get (P_Right, C))));
function Model (Container : Map) return M.Map with
-- The high-level model of a map is a map from keys to elements. Neither
-- cursors nor order of elements are represented in this model. Keys are
-- modeled up to equivalence.
Ghost,
Global => null;
function Keys (Container : Map) return K.Sequence with
-- The Keys sequence represents the underlying list structure of maps
-- that is used for iteration. It stores the actual values of keys in
-- the map. It does not model cursors nor elements.
Ghost,
Global => null,
Post =>
K.Length (Keys'Result) = Length (Container)
-- It only contains keys contained in Model
and (for all Key of Keys'Result =>
M.Has_Key (Model (Container), Key))
-- It contains all the keys contained in Model
and (for all Key of Model (Container) =>
(Find (Keys'Result, Key) > 0
and then Equivalent_Keys
(K.Get (Keys'Result, Find (Keys'Result, Key)),
Key)))
-- It has no duplicate
and (for all I in 1 .. Length (Container) =>
Find (Keys'Result, K.Get (Keys'Result, I)) = I)
and (for all I in 1 .. Length (Container) =>
(for all J in 1 .. Length (Container) =>
(if Equivalent_Keys
(K.Get (Keys'Result, I), K.Get (Keys'Result, J))
then
I = J)));
pragma Annotate (GNATprove, Iterable_For_Proof, "Model", Keys);
function Positions (Container : Map) return P.Map with
-- The Positions map is used to model cursors. It only contains valid
-- cursors and maps them to their position in the container.
Ghost,
Global => null,
Post =>
not P.Has_Key (Positions'Result, No_Element)
-- Positions of cursors are smaller than the container's length
and then
(for all I of Positions'Result =>
P.Get (Positions'Result, I) in 1 .. Length (Container)
-- No two cursors have the same position. Note that we do not
-- state that there is a cursor in the map for each position, as
-- it is rarely needed.
and then
(for all J of Positions'Result =>
(if P.Get (Positions'Result, I) = P.Get (Positions'Result, J)
then I = J)));
procedure Lift_Abstraction_Level (Container : Map) with
-- Lift_Abstraction_Level is a ghost procedure that does nothing but
-- assume that we can access the same elements by iterating over
-- positions or cursors.
-- This information is not generally useful except when switching from
-- a low-level, cursor-aware view of a container, to a high-level,
-- position-based view.
Ghost,
Global => null,
Post =>
(for all Key of Keys (Container) =>
(for some I of Positions (Container) =>
K.Get (Keys (Container), P.Get (Positions (Container), I)) =
Key));
function Contains
(C : M.Map;
K : Key_Type) return Boolean renames M.Has_Key;
-- To improve readability of contracts, we rename the function used to
-- search for a key in the model to Contains.
function Element
(C : M.Map;
K : Key_Type) return Element_Type renames M.Get;
-- To improve readability of contracts, we rename the function used to
-- access an element in the model to Element.
end Formal_Model;
use Formal_Model;
function "=" (Left, Right : Map) return Boolean with
Global => null,
Post => "="'Result = (Model (Left) = Model (Right));
function Capacity (Container : Map) return Count_Type with
Global => null,
Post => Capacity'Result = Container.Capacity;
procedure Reserve_Capacity
(Container : in out Map;
Capacity : Count_Type)
with
Global => null,
Pre => Capacity <= Container.Capacity,
Post =>
Model (Container) = Model (Container)'Old
and Length (Container)'Old = Length (Container)
-- Actual keys are preserved
and K_Keys_Included (Keys (Container), Keys (Container)'Old)
and K_Keys_Included (Keys (Container)'Old, Keys (Container));
function Is_Empty (Container : Map) return Boolean with
Global => null,
Post => Is_Empty'Result = (Length (Container) = 0);
procedure Clear (Container : in out Map) with
Global => null,
Post => Length (Container) = 0 and M.Is_Empty (Model (Container));
procedure Assign (Target : in out Map; Source : Map) with
Global => null,
Pre => Target.Capacity >= Length (Source),
Post =>
Model (Target) = Model (Source)
and Length (Source) = Length (Target)
-- Actual keys are preserved
and K_Keys_Included (Keys (Target), Keys (Source))
and K_Keys_Included (Keys (Source), Keys (Target));
function Copy
(Source : Map;
Capacity : Count_Type := 0) return Map
with
Global => null,
Pre => Capacity = 0 or else Capacity >= Source.Capacity,
Post =>
Model (Copy'Result) = Model (Source)
and Keys (Copy'Result) = Keys (Source)
and Positions (Copy'Result) = Positions (Source)
and (if Capacity = 0 then
Copy'Result.Capacity = Source.Capacity
else
Copy'Result.Capacity = Capacity);
-- Copy returns a container stricty equal to Source. It must have the same
-- cursors associated with each element. Therefore:
-- - capacity=0 means use Source.Capacity as capacity of target
-- - the modulus cannot be changed.
function Key (Container : Map; Position : Cursor) return Key_Type with
Global => null,
Pre => Has_Element (Container, Position),
Post =>
Key'Result =
K.Get (Keys (Container), P.Get (Positions (Container), Position));
pragma Annotate (GNATprove, Inline_For_Proof, Key);
function Element
(Container : Map;
Position : Cursor) return Element_Type
with
Global => null,
Pre => Has_Element (Container, Position),
Post =>
Element'Result = Element (Model (Container), Key (Container, Position));
pragma Annotate (GNATprove, Inline_For_Proof, Element);
procedure Replace_Element
(Container : in out Map;
Position : Cursor;
New_Item : Element_Type)
with
Global => null,
Pre => Has_Element (Container, Position),
Post =>
-- Order of keys and cursors is preserved
Keys (Container) = Keys (Container)'Old
and Positions (Container) = Positions (Container)'Old
-- New_Item is now associated with the key at position Position in
-- Container.
and Element (Container, Position) = New_Item
-- Elements associated with other keys are preserved
and M.Same_Keys (Model (Container), Model (Container)'Old)
and M.Elements_Equal_Except
(Model (Container),
Model (Container)'Old,
Key (Container, Position));
procedure Move (Target : in out Map; Source : in out Map) with
Global => null,
Pre => Target.Capacity >= Length (Source),
Post =>
Model (Target) = Model (Source)'Old
and Length (Source)'Old = Length (Target)
and Length (Source) = 0
-- Actual keys are preserved
and K_Keys_Included (Keys (Target), Keys (Source)'Old)
and K_Keys_Included (Keys (Source)'Old, Keys (Target));
procedure Insert
(Container : in out Map;
Key : Key_Type;
New_Item : Element_Type;
Position : out Cursor;
Inserted : out Boolean)
with
Global => null,
Pre =>
Length (Container) < Container.Capacity or Contains (Container, Key),
Post =>
Contains (Container, Key)
and Has_Element (Container, Position)
and Equivalent_Keys
(Formal_Hashed_Maps.Key (Container, Position), Key),
Contract_Cases =>
-- If Key is already in Container, it is not modified and Inserted is
-- set to False.
(Contains (Container, Key) =>
not Inserted
and Model (Container) = Model (Container)'Old
and Keys (Container) = Keys (Container)'Old
and Positions (Container) = Positions (Container)'Old,
-- Otherwise, Key is inserted in Container and Inserted is set to True
others =>
Inserted
and Length (Container) = Length (Container)'Old + 1
-- Key now maps to New_Item
and Formal_Hashed_Maps.Key (Container, Position) = Key
and Element (Model (Container), Key) = New_Item
-- Other keys are preserved
and Model (Container)'Old <= Model (Container)
and M.Keys_Included_Except
(Model (Container),
Model (Container)'Old,
Key)
-- Mapping from cursors to keys is preserved
and Mapping_Preserved
(K_Left => Keys (Container)'Old,
K_Right => Keys (Container),
P_Left => Positions (Container)'Old,
P_Right => Positions (Container))
and P.Keys_Included_Except
(Positions (Container),
Positions (Container)'Old,
Position));
procedure Insert
(Container : in out Map;
Key : Key_Type;
New_Item : Element_Type)
with
Global => null,
Pre =>
Length (Container) < Container.Capacity
and then (not Contains (Container, Key)),
Post =>
Length (Container) = Length (Container)'Old + 1
and Contains (Container, Key)
-- Key now maps to New_Item
and Formal_Hashed_Maps.Key (Container, Find (Container, Key)) = Key
and Element (Model (Container), Key) = New_Item
-- Other keys are preserved
and Model (Container)'Old <= Model (Container)
and M.Keys_Included_Except
(Model (Container),
Model (Container)'Old,
Key)
-- Mapping from cursors to keys is preserved
and Mapping_Preserved
(K_Left => Keys (Container)'Old,
K_Right => Keys (Container),
P_Left => Positions (Container)'Old,
P_Right => Positions (Container))
and P.Keys_Included_Except
(Positions (Container),
Positions (Container)'Old,
Find (Container, Key));
procedure Include
(Container : in out Map;
Key : Key_Type;
New_Item : Element_Type)
with
Global => null,
Pre =>
Length (Container) < Container.Capacity or Contains (Container, Key),
Post =>
Contains (Container, Key) and Element (Container, Key) = New_Item,
Contract_Cases =>
-- If Key is already in Container, Key is mapped to New_Item
(Contains (Container, Key) =>
-- Cursors are preserved
Positions (Container) = Positions (Container)'Old
-- The key equivalent to Key in Container is replaced by Key
and K.Get
(Keys (Container),
P.Get (Positions (Container), Find (Container, Key))) = Key
and K.Equal_Except
(Keys (Container)'Old,
Keys (Container),
P.Get (Positions (Container), Find (Container, Key)))
-- Elements associated with other keys are preserved
and M.Same_Keys (Model (Container), Model (Container)'Old)
and M.Elements_Equal_Except
(Model (Container),
Model (Container)'Old,
Key),
-- Otherwise, Key is inserted in Container
others =>
Length (Container) = Length (Container)'Old + 1
-- Other keys are preserved
and Model (Container)'Old <= Model (Container)
and M.Keys_Included_Except
(Model (Container),
Model (Container)'Old,
Key)
-- Key is inserted in Container
and K.Get
(Keys (Container),
P.Get (Positions (Container), Find (Container, Key))) = Key
-- Mapping from cursors to keys is preserved
and Mapping_Preserved
(K_Left => Keys (Container)'Old,
K_Right => Keys (Container),
P_Left => Positions (Container)'Old,
P_Right => Positions (Container))
and P.Keys_Included_Except
(Positions (Container),
Positions (Container)'Old,
Find (Container, Key)));
procedure Replace
(Container : in out Map;
Key : Key_Type;
New_Item : Element_Type)
with
Global => null,
Pre => Contains (Container, Key),
Post =>
-- Cursors are preserved
Positions (Container) = Positions (Container)'Old
-- The key equivalent to Key in Container is replaced by Key
and K.Get
(Keys (Container),
P.Get (Positions (Container), Find (Container, Key))) = Key
and K.Equal_Except
(Keys (Container)'Old,
Keys (Container),
P.Get (Positions (Container), Find (Container, Key)))
-- New_Item is now associated with the Key in Container
and Element (Model (Container), Key) = New_Item
-- Elements associated with other keys are preserved
and M.Same_Keys (Model (Container), Model (Container)'Old)
and M.Elements_Equal_Except
(Model (Container),
Model (Container)'Old,
Key);
procedure Exclude (Container : in out Map; Key : Key_Type) with
Global => null,
Post => not Contains (Container, Key),
Contract_Cases =>
-- If Key is not in Container, nothing is changed
(not Contains (Container, Key) =>
Model (Container) = Model (Container)'Old
and Keys (Container) = Keys (Container)'Old
and Positions (Container) = Positions (Container)'Old,
-- Otherwise, Key is removed from Container
others =>
Length (Container) = Length (Container)'Old - 1
-- Other keys are preserved
and Model (Container) <= Model (Container)'Old
and M.Keys_Included_Except
(Model (Container)'Old,
Model (Container),
Key)
-- Mapping from cursors to keys is preserved
and Mapping_Preserved
(K_Left => Keys (Container),
K_Right => Keys (Container)'Old,
P_Left => Positions (Container),
P_Right => Positions (Container)'Old)
and P.Keys_Included_Except
(Positions (Container)'Old,
Positions (Container),
Find (Container, Key)'Old));
procedure Delete (Container : in out Map; Key : Key_Type) with
Global => null,
Pre => Contains (Container, Key),
Post =>
Length (Container) = Length (Container)'Old - 1
-- Key is no longer in Container
and not Contains (Container, Key)
-- Other keys are preserved
and Model (Container) <= Model (Container)'Old
and M.Keys_Included_Except
(Model (Container)'Old,
Model (Container),
Key)
-- Mapping from cursors to keys is preserved
and Mapping_Preserved
(K_Left => Keys (Container),
K_Right => Keys (Container)'Old,
P_Left => Positions (Container),
P_Right => Positions (Container)'Old)
and P.Keys_Included_Except
(Positions (Container)'Old,
Positions (Container),
Find (Container, Key)'Old);
procedure Delete (Container : in out Map; Position : in out Cursor) with
Global => null,
Pre => Has_Element (Container, Position),
Post =>
Position = No_Element
and Length (Container) = Length (Container)'Old - 1
-- The key at position Position is no longer in Container
and not Contains (Container, Key (Container, Position)'Old)
and not P.Has_Key (Positions (Container), Position'Old)
-- Other keys are preserved
and Model (Container) <= Model (Container)'Old
and M.Keys_Included_Except
(Model (Container)'Old,
Model (Container),
Key (Container, Position)'Old)
-- Mapping from cursors to keys is preserved
and Mapping_Preserved
(K_Left => Keys (Container),
K_Right => Keys (Container)'Old,
P_Left => Positions (Container),
P_Right => Positions (Container)'Old)
and P.Keys_Included_Except
(Positions (Container)'Old,
Positions (Container),
Position'Old);
function First (Container : Map) return Cursor with
Global => null,
Contract_Cases =>
(Length (Container) = 0 =>
First'Result = No_Element,
others =>
Has_Element (Container, First'Result)
and P.Get (Positions (Container), First'Result) = 1);
function Next (Container : Map; Position : Cursor) return Cursor with
Global => null,
Pre =>
Has_Element (Container, Position) or else Position = No_Element,
Contract_Cases =>
(Position = No_Element
or else P.Get (Positions (Container), Position) = Length (Container)
=>
Next'Result = No_Element,
others =>
Has_Element (Container, Next'Result)
and then P.Get (Positions (Container), Next'Result) =
P.Get (Positions (Container), Position) + 1);
procedure Next (Container : Map; Position : in out Cursor) with
Global => null,
Pre =>
Has_Element (Container, Position) or else Position = No_Element,
Contract_Cases =>
(Position = No_Element
or else P.Get (Positions (Container), Position) = Length (Container)
=>
Position = No_Element,
others =>
Has_Element (Container, Position)
and then P.Get (Positions (Container), Position) =
P.Get (Positions (Container), Position'Old) + 1);
function Find (Container : Map; Key : Key_Type) return Cursor with
Global => null,
Contract_Cases =>
-- If Key is not contained in Container, Find returns No_Element
(not Contains (Model (Container), Key) =>
Find'Result = No_Element,
-- Otherwise, Find returns a valid cursor in Container
others =>
P.Has_Key (Positions (Container), Find'Result)
and P.Get (Positions (Container), Find'Result) =
Find (Keys (Container), Key)
-- The key designated by the result of Find is Key
and Equivalent_Keys
(Formal_Hashed_Maps.Key (Container, Find'Result), Key));
function Contains (Container : Map; Key : Key_Type) return Boolean with
Global => null,
Post => Contains'Result = Contains (Model (Container), Key);
pragma Annotate (GNATprove, Inline_For_Proof, Contains);
function Element (Container : Map; Key : Key_Type) return Element_Type with
Global => null,
Pre => Contains (Container, Key),
Post => Element'Result = Element (Model (Container), Key);
pragma Annotate (GNATprove, Inline_For_Proof, Element);
function Has_Element (Container : Map; Position : Cursor) return Boolean
with
Global => null,
Post =>
Has_Element'Result = P.Has_Key (Positions (Container), Position);
pragma Annotate (GNATprove, Inline_For_Proof, Has_Element);
function Default_Modulus (Capacity : Count_Type) return Hash_Type with
Global => null;
private
pragma SPARK_Mode (Off);
pragma Inline (Length);
pragma Inline (Is_Empty);
pragma Inline (Clear);
pragma Inline (Key);
pragma Inline (Element);
pragma Inline (Contains);
pragma Inline (Capacity);
pragma Inline (Has_Element);
pragma Inline (Equivalent_Keys);
pragma Inline (Next);
type Node_Type is record
Key : Key_Type;
Element : Element_Type;
Next : Count_Type;
Has_Element : Boolean := False;
end record;
package HT_Types is new
Ada.Containers.Hash_Tables.Generic_Bounded_Hash_Table_Types (Node_Type);
type Map (Capacity : Count_Type; Modulus : Hash_Type) is
new HT_Types.Hash_Table_Type (Capacity, Modulus) with null record;
Empty_Map : constant Map := (Capacity => 0, Modulus => 0, others => <>);
end Ada.Containers.Formal_Hashed_Maps;
|
with Ada.Text_IO;
with Ada.Command_Line;
with Templates_Parser;
with CLIC.TTY;
with Filesystem;
with Commands;
with Ada.Characters.Handling;
with Globals;
package body Blueprint is
package IO renames Ada.Text_IO;
package TT renames CLIC.TTY;
package FS renames Filesystem;
function Get_Blueprint_Folder return String is
Executable_Location : constant String := FS.Get_Executable_Path;
Root : constant String :=
Containing_Directory (Containing_Directory (Executable_Location));
Blueprint_Folder : constant String :=
Compose (Root, Globals.Blueprint_Folder_Name);
begin
return Blueprint_Folder;
end Get_Blueprint_Folder;
procedure Parse_Content (Source_File : String; Target : String) is
Processed_Content : constant String :=
Templates_Parser.Parse (Source_File, Commands.Translations);
File_Handle : IO.File_Type;
begin
IO.Create (File_Handle, IO.Out_File, Target);
IO.Put (File_Handle, Processed_Content);
IO.Close (File_Handle);
end Parse_Content;
procedure Process_File
(Target : String; Search_Item : Directory_Entry_Type; Todo : Action) is
Source_File : constant String :=
Full_Name (Directory_Entry => Search_Item);
Extension : constant String :=
Ada.Characters.Handling.To_Upper (
Ada.Directories.Extension (Source_File));
begin
IO.Put_Line (TT.Emph ("Create") & " " & Target);
if Exists (Target) then
IO.Put_Line
(TT.Error ("A file allready exists at ") & " " &
TT.Bold (Target) & " " & TT.Warn ("Ignored"));
else
if Todo = Write then
Copy_File (Source_File, Target);
end if;
end if;
end Process_File;
procedure Iterate (Blueprint_Folder : String;
Path : String; Todo : Action) is
Filter : constant Filter_Type :=
(
Ordinary_File => True,
Special_File => False,
Directory => True
);
procedure Item (Search_Item : Directory_Entry_Type);
procedure Item (Search_Item : Directory_Entry_Type) is
Name : constant String :=
Simple_Name (Directory_Entry => Search_Item);
Processed_Name : constant String :=
Templates_Parser.Translate (Name, Commands.Translations);
Blueprint_Folder : constant String :=
Full_Name (Directory_Entry => Search_Item);
Target : constant String := Compose (Path, Processed_Name);
begin
if Filesystem.Is_Valid_File (Name) then
case Todo is
when Write =>
if Kind (Directory_Entry => Search_Item) = Directory then
IO.Put_Line (TT.Emph ("Create") & " " & Target);
if Exists (Target) then
if Kind (Directory_Entry => Search_Item) = Ordinary_File
then
IO.Put_Line
(TT.Error ("A file allready exists at ") & " " &
TT.Bold (Target) & " " & TT.Warn ("Ignored"));
else
Iterate (Blueprint_Folder, Target, Todo);
end if;
else
Create_Directory (Target);
Iterate (Blueprint_Folder, Target, Todo);
end if;
else
Process_File (Target, Search_Item, Todo);
end if;
when Delete =>
if Kind (Directory_Entry => Search_Item) = Directory then
if Exists (Target) then
Iterate (Blueprint_Folder, Target, Todo);
if FS.Count_Files (Target) = 0 then
IO.Put_Line (TT.Emph ("Delete") & " " & Target);
Delete_Tree (Target);
end if;
end if;
elsif Kind (Directory_Entry => Search_Item) = Ordinary_File then
IO.Put_Line (TT.Emph ("Delete") & " " & Target);
Delete_File (Target);
end if;
when DryRun =>
if Kind (Directory_Entry => Search_Item) = Directory then
IO.Put_Line (TT.Emph ("Create") & " " & Target);
if Exists (Target) then
if Kind (Directory_Entry => Search_Item) = Ordinary_File
then
IO.Put_Line
(TT.Error ("A file allready exists at ") & " " &
TT.Bold (Target) & " " & TT.Warn ("Ignored"));
else
Iterate (Blueprint_Folder, Target, Todo);
end if;
else
Iterate (Blueprint_Folder, Target, Todo);
end if;
else
Process_File (Target, Search_Item, Todo);
end if;
end case;
end if;
end Item;
begin
Search
(Directory => Blueprint_Folder, Pattern => "", Filter => Filter,
Process => Item'Access);
end Iterate;
end Blueprint; |
------------------------------------------------------------------------------
-- --
-- Copyright (C) 2017, AdaCore --
-- --
-- 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. --
-- 3. Neither the name of the copyright holder 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 STM32.DMA.Interrupts; use STM32.DMA.Interrupts;
package STM32.I2C.DMA is
subtype Parent is I2C_Port;
type I2C_Port_DMA is limited new Parent with private;
procedure Set_TX_DMA_Handler (This : in out I2C_Port_DMA;
DMA : DMA_Interrupt_Controller_Access);
procedure Set_RX_DMA_Handler (This : in out I2C_Port_DMA;
DMA : DMA_Interrupt_Controller_Access);
procedure Set_Polling_Threshold (This : in out I2C_Port_DMA;
Threshold : Natural);
-- Bellow a certain amount of data, polling is faster and more efficient
-- than DMA.
private
type I2C_Port_DMA is limited new Parent with record
TX_DMA : DMA_Interrupt_Controller_Access := null;
RX_DMA : DMA_Interrupt_Controller_Access := null;
Threshold : Natural := 5;
end record;
overriding
procedure Data_Send
(This : in out I2C_Port_DMA;
Data : HAL.I2C.I2C_Data;
Timeout : Natural;
Status : out HAL.I2C.I2C_Status);
overriding
procedure Data_Receive
(This : in out I2C_Port_DMA;
Data : out HAL.I2C.I2C_Data;
Timeout : Natural;
Status : out HAL.I2C.I2C_Status);
end STM32.I2C.DMA;
|
------------------------------------------------------------------------------
-- --
-- GNAT LIBRARY COMPONENTS --
-- --
-- A D A . S T R I N G S . W I D E _ B O U N D E D . W I D E _ H A S H --
-- --
-- B o d y --
-- --
-- Copyright (C) 2004-2009, 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/>. --
-- --
-- This unit was originally developed by Matthew J Heaney. --
------------------------------------------------------------------------------
with System.String_Hash;
function Ada.Strings.Wide_Bounded.Wide_Hash
(Key : Bounded.Bounded_Wide_String)
return Containers.Hash_Type
is
use Ada.Containers;
function Hash is new System.String_Hash.Hash
(Wide_Character, Wide_String, Hash_Type);
begin
return Hash (Bounded.To_Wide_String (Key));
end Ada.Strings.Wide_Bounded.Wide_Hash;
|
-----------------------------------------------------------------------
-- util-properties-tests -- Tests for properties
-- Copyright (C) 2009, 2010, 2011, 2014, 2017, 2018, 2020, 2021 Stephane Carrez
-- Written by Stephane Carrez (Stephane.Carrez@gmail.com)
--
-- 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.Test_Caller;
with Ada.Text_IO;
with Util.Properties;
with Util.Properties.Basic;
package body Util.Properties.Tests is
use Ada.Text_IO;
use type Ada.Containers.Count_Type;
use Util.Properties.Basic;
-- Test
-- Properties.Set
-- Properties.Exists
-- Properties.Get
procedure Test_Property (T : in out Test) is
Props : Properties.Manager;
begin
T.Assert (Exists (Props, "test") = False,
"Invalid properties");
T.Assert (Exists (Props, +("test")) = False,
"Invalid properties");
T.Assert (Props.Is_Empty, "Property manager should be empty");
Props.Set ("test", "toto");
T.Assert (Exists (Props, "test"),
"Property was not inserted");
declare
V : constant String := Props.Get ("test");
begin
T.Assert (V = "toto",
"Property was not set correctly");
end;
declare
V : constant String := Props.Get (+("test"));
begin
T.Assert (V = "toto",
"Property was not set correctly");
end;
declare
V : constant Unbounded_String := Props.Get (+("test"));
begin
T.Assert (V = "toto",
"Property was not set correctly");
end;
end Test_Property;
-- Test basic properties
-- Get
-- Set
procedure Test_Integer_Property (T : in out Test) is
Props : Properties.Manager;
V : Integer := 23;
begin
Integer_Property.Set (Props, "test-integer", V);
T.Assert (Props.Exists ("test-integer"), "Invalid properties");
V := Integer_Property.Get (Props, "test-integer");
T.Assert (V = 23, "Property was not inserted");
Integer_Property.Set (Props, "test-integer", 24);
V := Integer_Property.Get (Props, "test-integer");
T.Assert (V = 24, "Property was not inserted");
V := Integer_Property.Get (Props, "unknown", 25);
T.Assert (V = 25, "Default value must be returned for a Get");
end Test_Integer_Property;
-- Test loading of property files
procedure Test_Load_Property (T : in out Test) is
Props : Properties.Manager;
F : File_Type;
begin
Open (F, In_File, "regtests/test.properties");
Load_Properties (Props, F);
Close (F);
declare
Names : Util.Strings.Vectors.Vector;
begin
Props.Get_Names (Names);
T.Assert (Names.Length > 30,
"Loading the test properties returned too few properties");
T.Assert (To_String (Props.Get ("root.dir")) = ".",
"Invalid property 'root.dir'");
T.Assert (To_String (Props.Get ("console.lib")) = "${dist.lib.dir}/console.jar",
"Invalid property 'console.lib'");
end;
exception
when Ada.Text_IO.Name_Error =>
Ada.Text_IO.Put_Line ("Cannot find test file: regtests/test.properties");
raise;
end Test_Load_Property;
-- ------------------------------
-- Test loading of property files
-- ------------------------------
procedure Test_Load_Strip_Property (T : in out Test) is
Props : Properties.Manager;
F : File_Type;
begin
-- Load, filter and strip properties
Open (F, In_File, "regtests/test.properties");
Load_Properties (Props, F, "tomcat.", True);
Close (F);
declare
Names : Util.Strings.Vectors.Vector;
begin
Props.Get_Names (Names);
T.Assert (Names.Length > 3,
"Loading the test properties returned too few properties");
T.Assert (To_String (Props.Get ("version")) = "0.6",
"Invalid property 'root.dir'");
end;
exception
when Ada.Text_IO.Name_Error =>
Ada.Text_IO.Put_Line ("Cannot find test file: regtests/test.properties");
raise;
end Test_Load_Strip_Property;
-- ------------------------------
-- Test copy of properties
-- ------------------------------
procedure Test_Copy_Property (T : in out Test) is
Props : Properties.Manager;
begin
Props.Set ("prefix.one", "1");
Props.Set ("prefix.two", "2");
Props.Set ("prefix", "Not copied");
Props.Set ("prefix.", "Copied");
declare
Copy : Properties.Manager;
begin
Copy.Copy (From => Props);
T.Assert (Copy.Exists ("prefix.one"), "Property one not found");
T.Assert (Copy.Exists ("prefix.two"), "Property two not found");
T.Assert (Copy.Exists ("prefix"), "Property '' does not exist.");
T.Assert (Copy.Exists ("prefix."), "Property '' does not exist.");
end;
declare
Copy : Properties.Manager;
begin
Copy.Copy (From => Props,
Prefix => "prefix.",
Strip => True);
T.Assert (Copy.Exists ("one"), "Property one not found");
T.Assert (Copy.Exists ("two"), "Property two not found");
T.Assert (Copy.Exists (""), "Property '' does not exist.");
end;
end Test_Copy_Property;
procedure Test_Set_Preserve_Original (T : in out Test) is
Props1 : Properties.Manager;
begin
Props1.Set ("a", "b");
Props1.Set ("c", "d");
declare
Props2 : Properties.Manager;
begin
Props2 := Props1;
T.Assert (Props2.Exists ("a"), "Property a not found in props2 after assignment");
T.Assert (Props2.Exists ("c"), "Property b not found in props2 after assignment");
Util.Tests.Assert_Equals (T, "b", String '(Props2.Get ("a")), "Invalid property a");
Props1.Set ("a", "d");
Util.Tests.Assert_Equals (T, "d", String '(Props1.Get ("a")),
"Wrong property a in props1");
Util.Tests.Assert_Equals (T, "b", String '(Props2.Get ("a")),
"Wrong property a in props2");
Props2 := Props1;
Util.Tests.Assert_Equals (T, "d", String '(Props2.Get ("a")),
"Wrong property a in props2");
Props2.Set ("e", "f");
Props2.Set ("c", "g");
Props1 := Props2;
-- Release Props2 but the property manager is internally shared so the Props1 is
-- not changed.
end;
T.Assert (Props1.Exists ("e"), "Property e not found in props1 after assignment");
T.Assert (Props1.Exists ("c"), "Property c not found in props1 after assignment");
Util.Tests.Assert_Equals (T, "g", String '(Props1.Get ("c")),
"Wrong property c in props1");
end Test_Set_Preserve_Original;
procedure Test_Remove_Preserve_Original (T : in out Test) is
Props1 : Properties.Manager;
begin
Props1.Set ("a", "b");
Props1.Set ("c", "d");
declare
Props2 : Properties.Manager;
begin
Props2 := Props1;
T.Assert (Props2.Exists ("a"), "Property a not found in props2 after assignment");
T.Assert (Props2.Exists ("c"), "Property b not found in props2 after assignment");
Props1.Remove ("a");
T.Assert (not Props1.Exists ("a"), "Property a was not removed from props1");
T.Assert (Props2.Exists ("a"), "Property a was removed from props2");
Props1 := Props2;
-- Release Props2 but the property manager is internally shared so the Props1 is
-- not changed.
end;
Util.Tests.Assert_Equals (T, "b", String '(Props1.Get ("a")),
"Wrong property a in props1");
end Test_Remove_Preserve_Original;
procedure Test_Missing_Property (T : in out Test) is
Props : Properties.Manager;
V : Unbounded_String;
begin
for Pass in 1 .. 2 loop
T.Assert (Util.Beans.Objects.Is_Null (Props.Get_Value ("missing")),
"The Get_Value operation must return a null object");
begin
V := Props.Get ("missing");
T.Fail ("Exception NO_PROPERTY was not raised");
exception
when NO_PROPERTY =>
null;
end;
begin
V := Props.Get (+("missing"));
T.Fail ("Exception NO_PROPERTY was not raised");
exception
when NO_PROPERTY =>
null;
end;
T.Assert (Ada.Strings.Unbounded.Length (V) = 0, "Variable get's corrupted");
-- Check exception on Get returning a String.
begin
declare
S : constant String := Props.Get ("missing");
pragma Unreferenced (S);
begin
T.Fail ("Exception NO_PROPERTY was not raised");
end;
exception
when NO_PROPERTY =>
null;
end;
-- Check exception on Get returning a String.
begin
declare
S : constant String := Props.Get (+("missing"));
pragma Unreferenced (S);
begin
T.Fail ("Exception NO_PROPERTY was not raised");
end;
exception
when NO_PROPERTY =>
null;
end;
Props.Set ("a", "b");
T.Assert (Util.Beans.Objects.Is_Null (Props.Get_Value ("missing")),
"The Get_Value operation must return a null object");
begin
V := Props.Get ("missing");
T.Fail ("Exception NO_PROPERTY was not raised");
exception
when NO_PROPERTY =>
null;
end;
Props.Set ("c", "d");
end loop;
end Test_Missing_Property;
procedure Test_Load_Ini_Property (T : in out Test) is
Props : Properties.Manager;
F : File_Type;
begin
Open (F, In_File, "regtests/files/my.cnf");
Load_Properties (Props, F);
Close (F);
declare
V : Util.Properties.Value;
P : Properties.Manager;
begin
V := Props.Get_Value ("mysqld");
T.Assert (Util.Properties.Is_Manager (V),
"Value 'mysqld' must be a property manager");
P := Util.Properties.To_Manager (V);
T.Assert (P.Exists ("user"),
"The [mysqld] property manager should contain a 'user' property");
V := Props.Get_Value ("mysqld_safe");
T.Assert (Util.Properties.Is_Manager (V),
"Value 'mysqld_safe' must be a property manager");
P := Util.Properties.To_Manager (V);
T.Assert (P.Exists ("socket"),
"The [mysqld] property manager should contain a 'socket' property");
end;
declare
P : Properties.Manager;
begin
P := Props.Get ("mysqld");
T.Assert (P.Exists ("user"),
"The [mysqld] property manager should contain a 'user' property");
P := Props.Get ("mysqld_safe");
T.Assert (P.Exists ("socket"),
"The [mysqld] property manager should contain a 'socket' property");
end;
declare
P : Properties.Manager with Unreferenced;
begin
P := Props.Get ("bad");
T.Fail ("No exception raised for Get()");
exception
when NO_PROPERTY =>
null;
end;
exception
when Ada.Text_IO.Name_Error =>
Ada.Text_IO.Put_Line ("Cannot find test file: regtests/files/my.cnf");
raise;
end Test_Load_Ini_Property;
procedure Test_Save_Properties (T : in out Test) is
Path : constant String := Util.Tests.Get_Test_Path ("save-props.properties");
begin
declare
Props : Properties.Manager;
F : File_Type;
begin
Open (F, In_File, "regtests/files/my.cnf");
Load_Properties (Props, F);
Close (F);
Props.Set ("New-Property", "Some-Value");
Props.Remove ("mysqld");
T.Assert (not Props.Exists ("mysqld"), "mysqld property was not removed");
Props.Save_Properties (Path);
end;
declare
Props : Properties.Manager;
V : Util.Properties.Value;
P : Properties.Manager;
begin
Props.Load_Properties (Path => Path);
T.Assert (not Props.Exists ("mysqld"), "mysqld property was not removed (2)");
T.Assert (Props.Exists ("New-Property"), "Invalid Save_Properties");
V := Props.Get_Value ("mysqld_safe");
T.Assert (Util.Properties.Is_Manager (V),
"Value 'mysqld_safe' must be a property manager");
P := Util.Properties.To_Manager (V);
T.Assert (P.Exists ("socket"),
"The [mysqld] property manager should contain a 'socket' property");
end;
declare
V : Util.Properties.Value;
P : Properties.Manager with Unreferenced;
begin
P := Util.Properties.To_Manager (V);
T.Fail ("No exception raised by To_Manager");
exception
when Util.Beans.Objects.Conversion_Error =>
null;
end;
end Test_Save_Properties;
procedure Test_Remove_Property (T : in out Test) is
Props : Properties.Manager;
begin
begin
Props.Remove ("missing");
T.Fail ("Remove should raise exception");
exception
when NO_PROPERTY =>
null;
end;
begin
Props.Remove (+("missing"));
T.Fail ("Remove should raise exception");
exception
when NO_PROPERTY =>
null;
end;
Props.Set ("a", "b");
T.Assert (Props.Exists ("a"), "Property not inserted");
Props.Remove ("a");
T.Assert (not Props.Exists ("a"), "Property not removed");
Props.Set ("a", +("b"));
T.Assert (Props.Exists ("a"), "Property not inserted");
Props.Remove (+("a"));
T.Assert (not Props.Exists ("a"), "Property not removed");
end Test_Remove_Property;
package Caller is new Util.Test_Caller (Test, "Properties.Main");
procedure Add_Tests (Suite : in Util.Tests.Access_Test_Suite) is
begin
Caller.Add_Test (Suite, "Test Util.Properties.Set",
Test_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Get",
Test_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Exists",
Test_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Remove",
Test_Remove_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Get (NO_PROPERTY)",
Test_Missing_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Discrete.Get",
Test_Integer_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Discrete.Set",
Test_Integer_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Load_Properties",
Test_Load_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Load_Properties (INI)",
Test_Load_Ini_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Load_Strip_Properties",
Test_Load_Strip_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Copy",
Test_Copy_Property'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Set+Assign",
Test_Set_Preserve_Original'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Set+Assign+Remove",
Test_Remove_Preserve_Original'Access);
Caller.Add_Test (Suite, "Test Util.Properties.Save_Properties",
Test_Save_Properties'Access);
end Add_Tests;
end Util.Properties.Tests;
|
--
-- This file is part of the coreboot project.
--
-- Copyright (C) 2016 secunet Security Networks AG
--
-- 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; version 2 of the License.
--
-- 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.
--
with Interfaces.C;
package body HW.Time.Timer
with Refined_State => (Timer_State => null,
Abstract_Time => null)
is
procedure Timer_Monotonic_Get (MT : out Interfaces.C.long);
pragma Import (C, Timer_Monotonic_Get, "timer_monotonic_get");
function Raw_Value_Min return T
with
SPARK_Mode => Off
is
Microseconds : Interfaces.C.long;
begin
Timer_Monotonic_Get (Microseconds);
return T (Microseconds);
end Raw_Value_Min;
function Raw_Value_Max return T
is
begin
return Raw_Value_Min + 1;
end Raw_Value_Max;
function Hz return T
is
begin
return 1_000_000;
end Hz;
end HW.Time.Timer;
|
with
any_Math.any_Algebra;
package float_Math.Algebra is new float_Math.any_Algebra;
pragma Pure (float_Math.Algebra);
|
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="15">
<syndb class_id="0" tracking_level="0" version="0">
<userIPLatency>-1</userIPLatency>
<userIPName></userIPName>
<cdfg class_id="1" tracking_level="1" version="0" object_id="_0">
<name>Mat2AXIvideo</name>
<ret_bitwidth>0</ret_bitwidth>
<ports class_id="2" tracking_level="0" version="0">
<count>10</count>
<item_version>0</item_version>
<item class_id="3" tracking_level="1" version="0" object_id="_1">
<Value class_id="4" tracking_level="0" version="0">
<Obj class_id="5" tracking_level="0" version="0">
<type>1</type>
<id>1</id>
<name>img_data_stream_0_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo class_id="6" tracking_level="0" version="0">
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>img.data_stream[0].V</originalName>
<rtlName></rtlName>
<coreName>FIFO</coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<direction>0</direction>
<if_type>3</if_type>
<array_size>0</array_size>
<bit_vecs class_id="7" tracking_level="0" version="0">
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_2">
<Value>
<Obj>
<type>1</type>
<id>2</id>
<name>img_data_stream_1_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>img.data_stream[1].V</originalName>
<rtlName></rtlName>
<coreName>FIFO</coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<direction>0</direction>
<if_type>3</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_3">
<Value>
<Obj>
<type>1</type>
<id>3</id>
<name>img_data_stream_2_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>img.data_stream[2].V</originalName>
<rtlName></rtlName>
<coreName>FIFO</coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<direction>0</direction>
<if_type>3</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_4">
<Value>
<Obj>
<type>1</type>
<id>4</id>
<name>AXI_video_strm_V_data_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>AXI_video_strm.V.data.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>32</bitwidth>
</Value>
<direction>1</direction>
<if_type>0</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_5">
<Value>
<Obj>
<type>1</type>
<id>5</id>
<name>AXI_video_strm_V_keep_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>AXI_video_strm.V.keep.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>4</bitwidth>
</Value>
<direction>1</direction>
<if_type>0</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_6">
<Value>
<Obj>
<type>1</type>
<id>6</id>
<name>AXI_video_strm_V_strb_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>AXI_video_strm.V.strb.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>4</bitwidth>
</Value>
<direction>1</direction>
<if_type>0</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_7">
<Value>
<Obj>
<type>1</type>
<id>7</id>
<name>AXI_video_strm_V_user_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>AXI_video_strm.V.user.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<direction>1</direction>
<if_type>0</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_8">
<Value>
<Obj>
<type>1</type>
<id>8</id>
<name>AXI_video_strm_V_last_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>AXI_video_strm.V.last.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<direction>1</direction>
<if_type>0</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_9">
<Value>
<Obj>
<type>1</type>
<id>9</id>
<name>AXI_video_strm_V_id_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>AXI_video_strm.V.id.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<direction>1</direction>
<if_type>0</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
<item class_id_reference="3" object_id="_10">
<Value>
<Obj>
<type>1</type>
<id>10</id>
<name>AXI_video_strm_V_dest_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>AXI_video_strm.V.dest.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<direction>1</direction>
<if_type>0</if_type>
<array_size>0</array_size>
<bit_vecs>
<count>0</count>
<item_version>0</item_version>
</bit_vecs>
</item>
</ports>
<nodes class_id="8" tracking_level="0" version="0">
<count>23</count>
<item_version>0</item_version>
<item class_id="9" tracking_level="1" version="0" object_id="_11">
<Value>
<Obj>
<type>0</type>
<id>11</id>
<name>tmp_user_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>tmp.user.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<oprand_edges>
<count>1</count>
<item_version>0</item_version>
<item>58</item>
</oprand_edges>
<opcode>alloca</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>1</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_12">
<Value>
<Obj>
<type>0</type>
<id>16</id>
<name></name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>60</item>
<item>61</item>
</oprand_edges>
<opcode>store</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.76</m_delay>
<m_topoIndex>2</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_13">
<Value>
<Obj>
<type>0</type>
<id>17</id>
<name></name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>125</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item class_id="11" tracking_level="0" version="0">
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second class_id="12" tracking_level="0" version="0">
<count>1</count>
<item_version>0</item_version>
<item class_id="13" tracking_level="0" version="0">
<first class_id="14" tracking_level="0" version="0">
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>125</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>1</count>
<item_version>0</item_version>
<item>62</item>
</oprand_edges>
<opcode>br</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.76</m_delay>
<m_topoIndex>3</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_14">
<Value>
<Obj>
<type>0</type>
<id>19</id>
<name>t_V</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>i.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<oprand_edges>
<count>4</count>
<item_version>0</item_version>
<item>63</item>
<item>64</item>
<item>66</item>
<item>67</item>
</oprand_edges>
<opcode>phi</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>4</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_15">
<Value>
<Obj>
<type>0</type>
<id>20</id>
<name>exitcond1</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>125</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>125</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>68</item>
<item>70</item>
</oprand_edges>
<opcode>icmp</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.55</m_delay>
<m_topoIndex>5</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_16">
<Value>
<Obj>
<type>0</type>
<id>22</id>
<name>i_V</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>125</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>125</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName>i.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>71</item>
<item>73</item>
</oprand_edges>
<opcode>add</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.91</m_delay>
<m_topoIndex>6</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_17">
<Value>
<Obj>
<type>0</type>
<id>23</id>
<name></name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>125</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>125</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>3</count>
<item_version>0</item_version>
<item>74</item>
<item>75</item>
<item>76</item>
</oprand_edges>
<opcode>br</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>7</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_18">
<Value>
<Obj>
<type>0</type>
<id>27</id>
<name></name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>126</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>126</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>1</count>
<item_version>0</item_version>
<item>77</item>
</oprand_edges>
<opcode>br</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.76</m_delay>
<m_topoIndex>8</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_19">
<Value>
<Obj>
<type>0</type>
<id>29</id>
<name>t_V_1</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName>j.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<oprand_edges>
<count>4</count>
<item_version>0</item_version>
<item>78</item>
<item>79</item>
<item>80</item>
<item>81</item>
</oprand_edges>
<opcode>phi</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>10</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_20">
<Value>
<Obj>
<type>0</type>
<id>30</id>
<name>exitcond</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>126</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>126</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>82</item>
<item>83</item>
</oprand_edges>
<opcode>icmp</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.55</m_delay>
<m_topoIndex>11</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_21">
<Value>
<Obj>
<type>0</type>
<id>32</id>
<name>j_V</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>126</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>126</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName>j.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>84</item>
<item>85</item>
</oprand_edges>
<opcode>add</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.91</m_delay>
<m_topoIndex>12</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_22">
<Value>
<Obj>
<type>0</type>
<id>33</id>
<name></name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>126</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>126</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>3</count>
<item_version>0</item_version>
<item>86</item>
<item>87</item>
<item>88</item>
</oprand_edges>
<opcode>br</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>13</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_23">
<Value>
<Obj>
<type>0</type>
<id>35</id>
<name>tmp_user_V_load</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>146</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>146</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>89</item>
<item>287</item>
</oprand_edges>
<opcode>load</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>15</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_24">
<Value>
<Obj>
<type>0</type>
<id>39</id>
<name>axi_last_V</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>135</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>135</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName>axi.last.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>90</item>
<item>92</item>
</oprand_edges>
<opcode>icmp</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.55</m_delay>
<m_topoIndex>14</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_25">
<Value>
<Obj>
<type>0</type>
<id>42</id>
<name>tmp_29</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>679</lineNumber>
<contextFuncName>read</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>3</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</first>
<second>operator&gt;&gt;</second>
</first>
<second>711</second>
</item>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</first>
<second>read</second>
</first>
<second>679</second>
</item>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>140</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName>tmp</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>94</item>
<item>95</item>
</oprand_edges>
<opcode>read</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>2.62</m_delay>
<m_topoIndex>16</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_26">
<Value>
<Obj>
<type>0</type>
<id>43</id>
<name>tmp_30</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>679</lineNumber>
<contextFuncName>read</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>3</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</first>
<second>operator&gt;&gt;</second>
</first>
<second>711</second>
</item>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</first>
<second>read</second>
</first>
<second>679</second>
</item>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>140</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName>tmp</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>96</item>
<item>97</item>
</oprand_edges>
<opcode>read</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>2.62</m_delay>
<m_topoIndex>17</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_27">
<Value>
<Obj>
<type>0</type>
<id>44</id>
<name>tmp_28</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>679</lineNumber>
<contextFuncName>read</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>3</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</first>
<second>operator&gt;&gt;</second>
</first>
<second>711</second>
</item>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_core.h</first>
<second>read</second>
</first>
<second>679</second>
</item>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>140</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName>tmp</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<oprand_edges>
<count>2</count>
<item_version>0</item_version>
<item>98</item>
<item>99</item>
</oprand_edges>
<opcode>read</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>2.62</m_delay>
<m_topoIndex>18</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_28">
<Value>
<Obj>
<type>0</type>
<id>46</id>
<name>tmp_data_V</name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_axi_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>78</lineNumber>
<contextFuncName>AXISetBitFields&lt;32, unsigned char&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>2</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_axi_io.h</first>
<second>AXISetBitFields&lt;32, unsigned char&gt;</second>
</first>
<second>78</second>
</item>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>143</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName>tmp.data.V</originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>32</bitwidth>
</Value>
<oprand_edges>
<count>5</count>
<item_version>0</item_version>
<item>101</item>
<item>103</item>
<item>104</item>
<item>105</item>
<item>106</item>
</oprand_edges>
<opcode>bitconcatenate</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>19</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_29">
<Value>
<Obj>
<type>0</type>
<id>47</id>
<name></name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>146</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>146</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>15</count>
<item_version>0</item_version>
<item>108</item>
<item>109</item>
<item>110</item>
<item>111</item>
<item>112</item>
<item>113</item>
<item>114</item>
<item>115</item>
<item>116</item>
<item>118</item>
<item>120</item>
<item>121</item>
<item>122</item>
<item>124</item>
<item>125</item>
</oprand_edges>
<opcode>write</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>20</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_30">
<Value>
<Obj>
<type>0</type>
<id>49</id>
<name></name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>4</count>
<item_version>0</item_version>
<item>127</item>
<item>128</item>
<item>286</item>
<item>288</item>
</oprand_edges>
<opcode>store</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>1.76</m_delay>
<m_topoIndex>21</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_31">
<Value>
<Obj>
<type>0</type>
<id>50</id>
<name></name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>126</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>126</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>1</count>
<item_version>0</item_version>
<item>129</item>
</oprand_edges>
<opcode>br</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>22</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_32">
<Value>
<Obj>
<type>0</type>
<id>53</id>
<name></name>
<fileName>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</fileName>
<fileDirectory>/home/eli/git/others/HLx_Examples/Vision/video_edge</fileDirectory>
<lineNumber>125</lineNumber>
<contextFuncName>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</contextFuncName>
<inlineStackInfo>
<count>1</count>
<item_version>0</item_version>
<item>
<first>/home/eli/git/others/HLx_Examples/Vision/video_edge</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>/tools/Xilinx/Vivado/2018.3/common/technology/autopilot/hls/hls_video_io.h</first>
<second>Mat2AXIvideo&lt;32, 220, 220, 4096&gt;</second>
</first>
<second>125</second>
</item>
</second>
</item>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>1</count>
<item_version>0</item_version>
<item>130</item>
</oprand_edges>
<opcode>br</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>23</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
<item class_id_reference="9" object_id="_33">
<Value>
<Obj>
<type>0</type>
<id>55</id>
<name></name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>0</bitwidth>
</Value>
<oprand_edges>
<count>0</count>
<item_version>0</item_version>
</oprand_edges>
<opcode>ret</opcode>
<m_Display>0</m_Display>
<m_isOnCriticalPath>0</m_isOnCriticalPath>
<m_isLCDNode>0</m_isLCDNode>
<m_isStartOfPath>0</m_isStartOfPath>
<m_delay>0.00</m_delay>
<m_topoIndex>9</m_topoIndex>
<m_clusterGroupNumber>-1</m_clusterGroupNumber>
</item>
</nodes>
<consts class_id="15" tracking_level="0" version="0">
<count>11</count>
<item_version>0</item_version>
<item class_id="16" tracking_level="1" version="0" object_id="_34">
<Value>
<Obj>
<type>2</type>
<id>57</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>32</bitwidth>
</Value>
<const_type>0</const_type>
<content>1</content>
</item>
<item class_id_reference="16" object_id="_35">
<Value>
<Obj>
<type>2</type>
<id>59</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<const_type>0</const_type>
<content>1</content>
</item>
<item class_id_reference="16" object_id="_36">
<Value>
<Obj>
<type>2</type>
<id>65</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<const_type>0</const_type>
<content>0</content>
</item>
<item class_id_reference="16" object_id="_37">
<Value>
<Obj>
<type>2</type>
<id>69</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<const_type>0</const_type>
<content>220</content>
</item>
<item class_id_reference="16" object_id="_38">
<Value>
<Obj>
<type>2</type>
<id>72</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<const_type>0</const_type>
<content>1</content>
</item>
<item class_id_reference="16" object_id="_39">
<Value>
<Obj>
<type>2</type>
<id>91</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<const_type>0</const_type>
<content>219</content>
</item>
<item class_id_reference="16" object_id="_40">
<Value>
<Obj>
<type>2</type>
<id>102</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>8</bitwidth>
</Value>
<const_type>0</const_type>
<content>255</content>
</item>
<item class_id_reference="16" object_id="_41">
<Value>
<Obj>
<type>2</type>
<id>117</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>4</bitwidth>
</Value>
<const_type>0</const_type>
<content>15</content>
</item>
<item class_id_reference="16" object_id="_42">
<Value>
<Obj>
<type>2</type>
<id>119</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>4</bitwidth>
</Value>
<const_type>4</const_type>
<content>0</content>
</item>
<item class_id_reference="16" object_id="_43">
<Value>
<Obj>
<type>2</type>
<id>123</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<const_type>4</const_type>
<content>0</content>
</item>
<item class_id_reference="16" object_id="_44">
<Value>
<Obj>
<type>2</type>
<id>126</id>
<name>empty</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<bitwidth>1</bitwidth>
</Value>
<const_type>0</const_type>
<content>0</content>
</item>
</consts>
<blocks class_id="17" tracking_level="0" version="0">
<count>7</count>
<item_version>0</item_version>
<item class_id="18" tracking_level="1" version="0" object_id="_45">
<Obj>
<type>3</type>
<id>18</id>
<name>.preheader.preheader</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<node_objs>
<count>3</count>
<item_version>0</item_version>
<item>11</item>
<item>16</item>
<item>17</item>
</node_objs>
</item>
<item class_id_reference="18" object_id="_46">
<Obj>
<type>3</type>
<id>24</id>
<name>.preheader</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<node_objs>
<count>4</count>
<item_version>0</item_version>
<item>19</item>
<item>20</item>
<item>22</item>
<item>23</item>
</node_objs>
</item>
<item class_id_reference="18" object_id="_47">
<Obj>
<type>3</type>
<id>28</id>
<name></name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<node_objs>
<count>1</count>
<item_version>0</item_version>
<item>27</item>
</node_objs>
</item>
<item class_id_reference="18" object_id="_48">
<Obj>
<type>3</type>
<id>34</id>
<name></name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<node_objs>
<count>4</count>
<item_version>0</item_version>
<item>29</item>
<item>30</item>
<item>32</item>
<item>33</item>
</node_objs>
</item>
<item class_id_reference="18" object_id="_49">
<Obj>
<type>3</type>
<id>51</id>
<name>operator>>.exit</name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<node_objs>
<count>9</count>
<item_version>0</item_version>
<item>35</item>
<item>39</item>
<item>42</item>
<item>43</item>
<item>44</item>
<item>46</item>
<item>47</item>
<item>49</item>
<item>50</item>
</node_objs>
</item>
<item class_id_reference="18" object_id="_50">
<Obj>
<type>3</type>
<id>54</id>
<name></name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<node_objs>
<count>1</count>
<item_version>0</item_version>
<item>53</item>
</node_objs>
</item>
<item class_id_reference="18" object_id="_51">
<Obj>
<type>3</type>
<id>56</id>
<name></name>
<fileName></fileName>
<fileDirectory></fileDirectory>
<lineNumber>0</lineNumber>
<contextFuncName></contextFuncName>
<inlineStackInfo>
<count>0</count>
<item_version>0</item_version>
</inlineStackInfo>
<originalName></originalName>
<rtlName></rtlName>
<coreName></coreName>
</Obj>
<node_objs>
<count>1</count>
<item_version>0</item_version>
<item>55</item>
</node_objs>
</item>
</blocks>
<edges class_id="19" tracking_level="0" version="0">
<count>66</count>
<item_version>0</item_version>
<item class_id="20" tracking_level="1" version="0" object_id="_52">
<id>58</id>
<edge_type>1</edge_type>
<source_obj>57</source_obj>
<sink_obj>11</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_53">
<id>60</id>
<edge_type>1</edge_type>
<source_obj>59</source_obj>
<sink_obj>16</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_54">
<id>61</id>
<edge_type>1</edge_type>
<source_obj>11</source_obj>
<sink_obj>16</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_55">
<id>62</id>
<edge_type>2</edge_type>
<source_obj>24</source_obj>
<sink_obj>17</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_56">
<id>63</id>
<edge_type>1</edge_type>
<source_obj>22</source_obj>
<sink_obj>19</sink_obj>
<is_back_edge>1</is_back_edge>
</item>
<item class_id_reference="20" object_id="_57">
<id>64</id>
<edge_type>2</edge_type>
<source_obj>54</source_obj>
<sink_obj>19</sink_obj>
<is_back_edge>1</is_back_edge>
</item>
<item class_id_reference="20" object_id="_58">
<id>66</id>
<edge_type>1</edge_type>
<source_obj>65</source_obj>
<sink_obj>19</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_59">
<id>67</id>
<edge_type>2</edge_type>
<source_obj>18</source_obj>
<sink_obj>19</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_60">
<id>68</id>
<edge_type>1</edge_type>
<source_obj>19</source_obj>
<sink_obj>20</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_61">
<id>70</id>
<edge_type>1</edge_type>
<source_obj>69</source_obj>
<sink_obj>20</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_62">
<id>71</id>
<edge_type>1</edge_type>
<source_obj>19</source_obj>
<sink_obj>22</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_63">
<id>73</id>
<edge_type>1</edge_type>
<source_obj>72</source_obj>
<sink_obj>22</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_64">
<id>74</id>
<edge_type>1</edge_type>
<source_obj>20</source_obj>
<sink_obj>23</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_65">
<id>75</id>
<edge_type>2</edge_type>
<source_obj>28</source_obj>
<sink_obj>23</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_66">
<id>76</id>
<edge_type>2</edge_type>
<source_obj>56</source_obj>
<sink_obj>23</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_67">
<id>77</id>
<edge_type>2</edge_type>
<source_obj>34</source_obj>
<sink_obj>27</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_68">
<id>78</id>
<edge_type>1</edge_type>
<source_obj>65</source_obj>
<sink_obj>29</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_69">
<id>79</id>
<edge_type>2</edge_type>
<source_obj>28</source_obj>
<sink_obj>29</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_70">
<id>80</id>
<edge_type>1</edge_type>
<source_obj>32</source_obj>
<sink_obj>29</sink_obj>
<is_back_edge>1</is_back_edge>
</item>
<item class_id_reference="20" object_id="_71">
<id>81</id>
<edge_type>2</edge_type>
<source_obj>51</source_obj>
<sink_obj>29</sink_obj>
<is_back_edge>1</is_back_edge>
</item>
<item class_id_reference="20" object_id="_72">
<id>82</id>
<edge_type>1</edge_type>
<source_obj>29</source_obj>
<sink_obj>30</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_73">
<id>83</id>
<edge_type>1</edge_type>
<source_obj>69</source_obj>
<sink_obj>30</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_74">
<id>84</id>
<edge_type>1</edge_type>
<source_obj>29</source_obj>
<sink_obj>32</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_75">
<id>85</id>
<edge_type>1</edge_type>
<source_obj>72</source_obj>
<sink_obj>32</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_76">
<id>86</id>
<edge_type>1</edge_type>
<source_obj>30</source_obj>
<sink_obj>33</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_77">
<id>87</id>
<edge_type>2</edge_type>
<source_obj>51</source_obj>
<sink_obj>33</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_78">
<id>88</id>
<edge_type>2</edge_type>
<source_obj>54</source_obj>
<sink_obj>33</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_79">
<id>89</id>
<edge_type>1</edge_type>
<source_obj>11</source_obj>
<sink_obj>35</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_80">
<id>90</id>
<edge_type>1</edge_type>
<source_obj>29</source_obj>
<sink_obj>39</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_81">
<id>92</id>
<edge_type>1</edge_type>
<source_obj>91</source_obj>
<sink_obj>39</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_82">
<id>95</id>
<edge_type>1</edge_type>
<source_obj>1</source_obj>
<sink_obj>42</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_83">
<id>97</id>
<edge_type>1</edge_type>
<source_obj>2</source_obj>
<sink_obj>43</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_84">
<id>99</id>
<edge_type>1</edge_type>
<source_obj>3</source_obj>
<sink_obj>44</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_85">
<id>103</id>
<edge_type>1</edge_type>
<source_obj>102</source_obj>
<sink_obj>46</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_86">
<id>104</id>
<edge_type>1</edge_type>
<source_obj>44</source_obj>
<sink_obj>46</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_87">
<id>105</id>
<edge_type>1</edge_type>
<source_obj>43</source_obj>
<sink_obj>46</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_88">
<id>106</id>
<edge_type>1</edge_type>
<source_obj>42</source_obj>
<sink_obj>46</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_89">
<id>109</id>
<edge_type>1</edge_type>
<source_obj>4</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_90">
<id>110</id>
<edge_type>1</edge_type>
<source_obj>5</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_91">
<id>111</id>
<edge_type>1</edge_type>
<source_obj>6</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_92">
<id>112</id>
<edge_type>1</edge_type>
<source_obj>7</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_93">
<id>113</id>
<edge_type>1</edge_type>
<source_obj>8</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_94">
<id>114</id>
<edge_type>1</edge_type>
<source_obj>9</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_95">
<id>115</id>
<edge_type>1</edge_type>
<source_obj>10</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_96">
<id>116</id>
<edge_type>1</edge_type>
<source_obj>46</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_97">
<id>118</id>
<edge_type>1</edge_type>
<source_obj>117</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_98">
<id>120</id>
<edge_type>1</edge_type>
<source_obj>119</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_99">
<id>121</id>
<edge_type>1</edge_type>
<source_obj>35</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_100">
<id>122</id>
<edge_type>1</edge_type>
<source_obj>39</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_101">
<id>124</id>
<edge_type>1</edge_type>
<source_obj>123</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_102">
<id>125</id>
<edge_type>1</edge_type>
<source_obj>123</source_obj>
<sink_obj>47</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_103">
<id>127</id>
<edge_type>1</edge_type>
<source_obj>126</source_obj>
<sink_obj>49</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_104">
<id>128</id>
<edge_type>1</edge_type>
<source_obj>11</source_obj>
<sink_obj>49</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_105">
<id>129</id>
<edge_type>2</edge_type>
<source_obj>34</source_obj>
<sink_obj>50</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_106">
<id>130</id>
<edge_type>2</edge_type>
<source_obj>24</source_obj>
<sink_obj>53</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_107">
<id>278</id>
<edge_type>2</edge_type>
<source_obj>18</source_obj>
<sink_obj>24</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_108">
<id>279</id>
<edge_type>2</edge_type>
<source_obj>24</source_obj>
<sink_obj>56</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_109">
<id>280</id>
<edge_type>2</edge_type>
<source_obj>24</source_obj>
<sink_obj>28</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_110">
<id>281</id>
<edge_type>2</edge_type>
<source_obj>28</source_obj>
<sink_obj>34</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_111">
<id>282</id>
<edge_type>2</edge_type>
<source_obj>34</source_obj>
<sink_obj>54</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_112">
<id>283</id>
<edge_type>2</edge_type>
<source_obj>34</source_obj>
<sink_obj>51</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_113">
<id>284</id>
<edge_type>2</edge_type>
<source_obj>51</source_obj>
<sink_obj>34</sink_obj>
<is_back_edge>1</is_back_edge>
</item>
<item class_id_reference="20" object_id="_114">
<id>285</id>
<edge_type>2</edge_type>
<source_obj>54</source_obj>
<sink_obj>24</sink_obj>
<is_back_edge>1</is_back_edge>
</item>
<item class_id_reference="20" object_id="_115">
<id>286</id>
<edge_type>4</edge_type>
<source_obj>35</source_obj>
<sink_obj>49</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_116">
<id>287</id>
<edge_type>4</edge_type>
<source_obj>16</source_obj>
<sink_obj>35</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
<item class_id_reference="20" object_id="_117">
<id>288</id>
<edge_type>4</edge_type>
<source_obj>16</source_obj>
<sink_obj>49</sink_obj>
<is_back_edge>0</is_back_edge>
</item>
</edges>
</cdfg>
<cdfg_regions class_id="21" tracking_level="0" version="0">
<count>7</count>
<item_version>0</item_version>
<item class_id="22" tracking_level="1" version="0" object_id="_118">
<mId>1</mId>
<mTag>Mat2AXIvideo</mTag>
<mType>0</mType>
<sub_regions>
<count>3</count>
<item_version>0</item_version>
<item>2</item>
<item>3</item>
<item>7</item>
</sub_regions>
<basic_blocks>
<count>0</count>
<item_version>0</item_version>
</basic_blocks>
<mII>-1</mII>
<mDepth>-1</mDepth>
<mMinTripCount>-1</mMinTripCount>
<mMaxTripCount>-1</mMaxTripCount>
<mMinLatency>49281</mMinLatency>
<mMaxLatency>49281</mMaxLatency>
<mIsDfPipe>0</mIsDfPipe>
<mDfPipe class_id="-1"></mDfPipe>
</item>
<item class_id_reference="22" object_id="_119">
<mId>2</mId>
<mTag>Entry</mTag>
<mType>0</mType>
<sub_regions>
<count>0</count>
<item_version>0</item_version>
</sub_regions>
<basic_blocks>
<count>1</count>
<item_version>0</item_version>
<item>18</item>
</basic_blocks>
<mII>-1</mII>
<mDepth>-1</mDepth>
<mMinTripCount>-1</mMinTripCount>
<mMaxTripCount>-1</mMaxTripCount>
<mMinLatency>0</mMinLatency>
<mMaxLatency>0</mMaxLatency>
<mIsDfPipe>0</mIsDfPipe>
<mDfPipe class_id="-1"></mDfPipe>
</item>
<item class_id_reference="22" object_id="_120">
<mId>3</mId>
<mTag>loop_height</mTag>
<mType>1</mType>
<sub_regions>
<count>3</count>
<item_version>0</item_version>
<item>4</item>
<item>5</item>
<item>6</item>
</sub_regions>
<basic_blocks>
<count>0</count>
<item_version>0</item_version>
</basic_blocks>
<mII>-1</mII>
<mDepth>-1</mDepth>
<mMinTripCount>220</mMinTripCount>
<mMaxTripCount>220</mMaxTripCount>
<mMinLatency>49280</mMinLatency>
<mMaxLatency>49280</mMaxLatency>
<mIsDfPipe>0</mIsDfPipe>
<mDfPipe class_id="-1"></mDfPipe>
</item>
<item class_id_reference="22" object_id="_121">
<mId>4</mId>
<mTag>Region 1</mTag>
<mType>0</mType>
<sub_regions>
<count>0</count>
<item_version>0</item_version>
</sub_regions>
<basic_blocks>
<count>2</count>
<item_version>0</item_version>
<item>24</item>
<item>28</item>
</basic_blocks>
<mII>-1</mII>
<mDepth>-1</mDepth>
<mMinTripCount>-1</mMinTripCount>
<mMaxTripCount>-1</mMaxTripCount>
<mMinLatency>0</mMinLatency>
<mMaxLatency>0</mMaxLatency>
<mIsDfPipe>0</mIsDfPipe>
<mDfPipe class_id="-1"></mDfPipe>
</item>
<item class_id_reference="22" object_id="_122">
<mId>5</mId>
<mTag>loop_width</mTag>
<mType>1</mType>
<sub_regions>
<count>0</count>
<item_version>0</item_version>
</sub_regions>
<basic_blocks>
<count>2</count>
<item_version>0</item_version>
<item>34</item>
<item>51</item>
</basic_blocks>
<mII>1</mII>
<mDepth>3</mDepth>
<mMinTripCount>220</mMinTripCount>
<mMaxTripCount>220</mMaxTripCount>
<mMinLatency>221</mMinLatency>
<mMaxLatency>221</mMaxLatency>
<mIsDfPipe>0</mIsDfPipe>
<mDfPipe class_id="-1"></mDfPipe>
</item>
<item class_id_reference="22" object_id="_123">
<mId>6</mId>
<mTag>Region 2</mTag>
<mType>0</mType>
<sub_regions>
<count>0</count>
<item_version>0</item_version>
</sub_regions>
<basic_blocks>
<count>1</count>
<item_version>0</item_version>
<item>54</item>
</basic_blocks>
<mII>-1</mII>
<mDepth>-1</mDepth>
<mMinTripCount>-1</mMinTripCount>
<mMaxTripCount>-1</mMaxTripCount>
<mMinLatency>0</mMinLatency>
<mMaxLatency>0</mMaxLatency>
<mIsDfPipe>0</mIsDfPipe>
<mDfPipe class_id="-1"></mDfPipe>
</item>
<item class_id_reference="22" object_id="_124">
<mId>7</mId>
<mTag>Return</mTag>
<mType>0</mType>
<sub_regions>
<count>0</count>
<item_version>0</item_version>
</sub_regions>
<basic_blocks>
<count>1</count>
<item_version>0</item_version>
<item>56</item>
</basic_blocks>
<mII>-1</mII>
<mDepth>-1</mDepth>
<mMinTripCount>-1</mMinTripCount>
<mMaxTripCount>-1</mMaxTripCount>
<mMinLatency>0</mMinLatency>
<mMaxLatency>0</mMaxLatency>
<mIsDfPipe>0</mIsDfPipe>
<mDfPipe class_id="-1"></mDfPipe>
</item>
</cdfg_regions>
<fsm class_id="24" tracking_level="1" version="0" object_id="_125">
<states class_id="25" tracking_level="0" version="0">
<count>6</count>
<item_version>0</item_version>
<item class_id="26" tracking_level="1" version="0" object_id="_126">
<id>1</id>
<operations class_id="27" tracking_level="0" version="0">
<count>7</count>
<item_version>0</item_version>
<item class_id="28" tracking_level="1" version="0" object_id="_127">
<id>11</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_128">
<id>12</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_129">
<id>13</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_130">
<id>14</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_131">
<id>15</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_132">
<id>16</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_133">
<id>17</id>
<stage>1</stage>
<latency>1</latency>
</item>
</operations>
</item>
<item class_id_reference="26" object_id="_134">
<id>2</id>
<operations>
<count>9</count>
<item_version>0</item_version>
<item class_id_reference="28" object_id="_135">
<id>19</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_136">
<id>20</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_137">
<id>21</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_138">
<id>22</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_139">
<id>23</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_140">
<id>25</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_141">
<id>26</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_142">
<id>27</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_143">
<id>55</id>
<stage>1</stage>
<latency>1</latency>
</item>
</operations>
</item>
<item class_id_reference="26" object_id="_144">
<id>3</id>
<operations>
<count>6</count>
<item_version>0</item_version>
<item class_id_reference="28" object_id="_145">
<id>29</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_146">
<id>30</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_147">
<id>31</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_148">
<id>32</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_149">
<id>33</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_150">
<id>39</id>
<stage>1</stage>
<latency>1</latency>
</item>
</operations>
</item>
<item class_id_reference="26" object_id="_151">
<id>4</id>
<operations>
<count>10</count>
<item_version>0</item_version>
<item class_id_reference="28" object_id="_152">
<id>35</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_153">
<id>40</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_154">
<id>41</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_155">
<id>42</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_156">
<id>43</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_157">
<id>44</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_158">
<id>45</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_159">
<id>46</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_160">
<id>47</id>
<stage>2</stage>
<latency>2</latency>
</item>
<item class_id_reference="28" object_id="_161">
<id>49</id>
<stage>1</stage>
<latency>1</latency>
</item>
</operations>
</item>
<item class_id_reference="26" object_id="_162">
<id>5</id>
<operations>
<count>6</count>
<item_version>0</item_version>
<item class_id_reference="28" object_id="_163">
<id>36</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_164">
<id>37</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_165">
<id>38</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_166">
<id>47</id>
<stage>1</stage>
<latency>2</latency>
</item>
<item class_id_reference="28" object_id="_167">
<id>48</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_168">
<id>50</id>
<stage>1</stage>
<latency>1</latency>
</item>
</operations>
</item>
<item class_id_reference="26" object_id="_169">
<id>6</id>
<operations>
<count>2</count>
<item_version>0</item_version>
<item class_id_reference="28" object_id="_170">
<id>52</id>
<stage>1</stage>
<latency>1</latency>
</item>
<item class_id_reference="28" object_id="_171">
<id>53</id>
<stage>1</stage>
<latency>1</latency>
</item>
</operations>
</item>
</states>
<transitions class_id="29" tracking_level="0" version="0">
<count>7</count>
<item_version>0</item_version>
<item class_id="30" tracking_level="1" version="0" object_id="_172">
<inState>1</inState>
<outState>2</outState>
<condition class_id="31" tracking_level="0" version="0">
<id>-1</id>
<sop class_id="32" tracking_level="0" version="0">
<count>1</count>
<item_version>0</item_version>
<item class_id="33" tracking_level="0" version="0">
<count>0</count>
<item_version>0</item_version>
</item>
</sop>
</condition>
</item>
<item class_id_reference="30" object_id="_173">
<inState>2</inState>
<outState>3</outState>
<condition>
<id>-1</id>
<sop>
<count>1</count>
<item_version>0</item_version>
<item>
<count>1</count>
<item_version>0</item_version>
<item class_id="34" tracking_level="0" version="0">
<first class_id="35" tracking_level="0" version="0">
<first>20</first>
<second>0</second>
</first>
<second>1</second>
</item>
</item>
</sop>
</condition>
</item>
<item class_id_reference="30" object_id="_174">
<inState>6</inState>
<outState>2</outState>
<condition>
<id>-1</id>
<sop>
<count>1</count>
<item_version>0</item_version>
<item>
<count>0</count>
<item_version>0</item_version>
</item>
</sop>
</condition>
</item>
<item class_id_reference="30" object_id="_175">
<inState>4</inState>
<outState>5</outState>
<condition>
<id>-1</id>
<sop>
<count>1</count>
<item_version>0</item_version>
<item>
<count>0</count>
<item_version>0</item_version>
</item>
</sop>
</condition>
</item>
<item class_id_reference="30" object_id="_176">
<inState>5</inState>
<outState>3</outState>
<condition>
<id>-1</id>
<sop>
<count>1</count>
<item_version>0</item_version>
<item>
<count>0</count>
<item_version>0</item_version>
</item>
</sop>
</condition>
</item>
<item class_id_reference="30" object_id="_177">
<inState>3</inState>
<outState>6</outState>
<condition>
<id>-1</id>
<sop>
<count>1</count>
<item_version>0</item_version>
<item>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>30</first>
<second>0</second>
</first>
<second>0</second>
</item>
</item>
</sop>
</condition>
</item>
<item class_id_reference="30" object_id="_178">
<inState>3</inState>
<outState>4</outState>
<condition>
<id>-1</id>
<sop>
<count>1</count>
<item_version>0</item_version>
<item>
<count>1</count>
<item_version>0</item_version>
<item>
<first>
<first>30</first>
<second>0</second>
</first>
<second>1</second>
</item>
</item>
</sop>
</condition>
</item>
</transitions>
</fsm>
<res class_id="-1"></res>
<node_label_latency class_id="37" tracking_level="0" version="0">
<count>23</count>
<item_version>0</item_version>
<item class_id="38" tracking_level="0" version="0">
<first>11</first>
<second class_id="39" tracking_level="0" version="0">
<first>0</first>
<second>0</second>
</second>
</item>
<item>
<first>16</first>
<second>
<first>0</first>
<second>0</second>
</second>
</item>
<item>
<first>17</first>
<second>
<first>0</first>
<second>0</second>
</second>
</item>
<item>
<first>19</first>
<second>
<first>1</first>
<second>0</second>
</second>
</item>
<item>
<first>20</first>
<second>
<first>1</first>
<second>0</second>
</second>
</item>
<item>
<first>22</first>
<second>
<first>1</first>
<second>0</second>
</second>
</item>
<item>
<first>23</first>
<second>
<first>1</first>
<second>0</second>
</second>
</item>
<item>
<first>27</first>
<second>
<first>1</first>
<second>0</second>
</second>
</item>
<item>
<first>29</first>
<second>
<first>2</first>
<second>0</second>
</second>
</item>
<item>
<first>30</first>
<second>
<first>2</first>
<second>0</second>
</second>
</item>
<item>
<first>32</first>
<second>
<first>2</first>
<second>0</second>
</second>
</item>
<item>
<first>33</first>
<second>
<first>2</first>
<second>0</second>
</second>
</item>
<item>
<first>35</first>
<second>
<first>3</first>
<second>0</second>
</second>
</item>
<item>
<first>39</first>
<second>
<first>2</first>
<second>0</second>
</second>
</item>
<item>
<first>42</first>
<second>
<first>3</first>
<second>0</second>
</second>
</item>
<item>
<first>43</first>
<second>
<first>3</first>
<second>0</second>
</second>
</item>
<item>
<first>44</first>
<second>
<first>3</first>
<second>0</second>
</second>
</item>
<item>
<first>46</first>
<second>
<first>3</first>
<second>0</second>
</second>
</item>
<item>
<first>47</first>
<second>
<first>3</first>
<second>1</second>
</second>
</item>
<item>
<first>49</first>
<second>
<first>3</first>
<second>0</second>
</second>
</item>
<item>
<first>50</first>
<second>
<first>4</first>
<second>0</second>
</second>
</item>
<item>
<first>53</first>
<second>
<first>5</first>
<second>0</second>
</second>
</item>
<item>
<first>55</first>
<second>
<first>1</first>
<second>0</second>
</second>
</item>
</node_label_latency>
<bblk_ent_exit class_id="40" tracking_level="0" version="0">
<count>7</count>
<item_version>0</item_version>
<item class_id="41" tracking_level="0" version="0">
<first>18</first>
<second class_id="42" tracking_level="0" version="0">
<first>0</first>
<second>0</second>
</second>
</item>
<item>
<first>24</first>
<second>
<first>1</first>
<second>1</second>
</second>
</item>
<item>
<first>28</first>
<second>
<first>1</first>
<second>1</second>
</second>
</item>
<item>
<first>34</first>
<second>
<first>2</first>
<second>2</second>
</second>
</item>
<item>
<first>51</first>
<second>
<first>2</first>
<second>4</second>
</second>
</item>
<item>
<first>54</first>
<second>
<first>3</first>
<second>3</second>
</second>
</item>
<item>
<first>56</first>
<second>
<first>1</first>
<second>1</second>
</second>
</item>
</bblk_ent_exit>
<regions class_id="43" tracking_level="0" version="0">
<count>2</count>
<item_version>0</item_version>
<item class_id="44" tracking_level="1" version="0" object_id="_179">
<region_name>loop_width</region_name>
<basic_blocks>
<count>2</count>
<item_version>0</item_version>
<item>34</item>
<item>51</item>
</basic_blocks>
<nodes>
<count>0</count>
<item_version>0</item_version>
</nodes>
<anchor_node>-1</anchor_node>
<region_type>8</region_type>
<interval>1</interval>
<pipe_depth>3</pipe_depth>
</item>
<item class_id_reference="44" object_id="_180">
<region_name>hls_label_2</region_name>
<basic_blocks>
<count>1</count>
<item_version>0</item_version>
<item>51</item>
</basic_blocks>
<nodes>
<count>6</count>
<item_version>0</item_version>
<item>40</item>
<item>41</item>
<item>42</item>
<item>43</item>
<item>44</item>
<item>45</item>
</nodes>
<anchor_node>40</anchor_node>
<region_type>1</region_type>
<interval>0</interval>
<pipe_depth>0</pipe_depth>
</item>
</regions>
<dp_fu_nodes class_id="45" tracking_level="0" version="0">
<count>16</count>
<item_version>0</item_version>
<item class_id="46" tracking_level="0" version="0">
<first>122</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>11</item>
</second>
</item>
<item>
<first>126</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>42</item>
</second>
</item>
<item>
<first>132</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>43</item>
</second>
</item>
<item>
<first>138</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>44</item>
</second>
</item>
<item>
<first>144</first>
<second>
<count>2</count>
<item_version>0</item_version>
<item>47</item>
<item>47</item>
</second>
</item>
<item>
<first>177</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>19</item>
</second>
</item>
<item>
<first>188</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>29</item>
</second>
</item>
<item>
<first>195</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>16</item>
</second>
</item>
<item>
<first>200</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>20</item>
</second>
</item>
<item>
<first>206</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>22</item>
</second>
</item>
<item>
<first>212</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>30</item>
</second>
</item>
<item>
<first>218</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>32</item>
</second>
</item>
<item>
<first>224</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>39</item>
</second>
</item>
<item>
<first>230</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>35</item>
</second>
</item>
<item>
<first>234</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>46</item>
</second>
</item>
<item>
<first>247</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>49</item>
</second>
</item>
</dp_fu_nodes>
<dp_fu_nodes_expression class_id="48" tracking_level="0" version="0">
<count>9</count>
<item_version>0</item_version>
<item class_id="49" tracking_level="0" version="0">
<first>axi_last_V_fu_224</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>39</item>
</second>
</item>
<item>
<first>exitcond1_fu_200</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>20</item>
</second>
</item>
<item>
<first>exitcond_fu_212</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>30</item>
</second>
</item>
<item>
<first>i_V_fu_206</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>22</item>
</second>
</item>
<item>
<first>j_V_fu_218</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>32</item>
</second>
</item>
<item>
<first>t_V_1_phi_fu_188</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>29</item>
</second>
</item>
<item>
<first>t_V_phi_fu_177</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>19</item>
</second>
</item>
<item>
<first>tmp_data_V_fu_234</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>46</item>
</second>
</item>
<item>
<first>tmp_user_V_fu_122</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>11</item>
</second>
</item>
</dp_fu_nodes_expression>
<dp_fu_nodes_module>
<count>0</count>
<item_version>0</item_version>
</dp_fu_nodes_module>
<dp_fu_nodes_io>
<count>7</count>
<item_version>0</item_version>
<item>
<first>StgValue_12_store_fu_195</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>16</item>
</second>
</item>
<item>
<first>StgValue_38_store_fu_247</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>49</item>
</second>
</item>
<item>
<first>grp_write_fu_144</first>
<second>
<count>2</count>
<item_version>0</item_version>
<item>47</item>
<item>47</item>
</second>
</item>
<item>
<first>tmp_28_read_fu_138</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>44</item>
</second>
</item>
<item>
<first>tmp_29_read_fu_126</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>42</item>
</second>
</item>
<item>
<first>tmp_30_read_fu_132</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>43</item>
</second>
</item>
<item>
<first>tmp_user_V_load_load_fu_230</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>35</item>
</second>
</item>
</dp_fu_nodes_io>
<return_ports>
<count>0</count>
<item_version>0</item_version>
</return_ports>
<dp_mem_port_nodes class_id="50" tracking_level="0" version="0">
<count>0</count>
<item_version>0</item_version>
</dp_mem_port_nodes>
<dp_reg_nodes>
<count>10</count>
<item_version>0</item_version>
<item>
<first>173</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>19</item>
</second>
</item>
<item>
<first>184</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>29</item>
</second>
</item>
<item>
<first>252</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>11</item>
</second>
</item>
<item>
<first>259</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>20</item>
</second>
</item>
<item>
<first>263</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>22</item>
</second>
</item>
<item>
<first>268</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>30</item>
</second>
</item>
<item>
<first>272</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>32</item>
</second>
</item>
<item>
<first>277</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>39</item>
</second>
</item>
<item>
<first>282</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>35</item>
</second>
</item>
<item>
<first>287</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>46</item>
</second>
</item>
</dp_reg_nodes>
<dp_regname_nodes>
<count>10</count>
<item_version>0</item_version>
<item>
<first>axi_last_V_reg_277</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>39</item>
</second>
</item>
<item>
<first>exitcond1_reg_259</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>20</item>
</second>
</item>
<item>
<first>exitcond_reg_268</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>30</item>
</second>
</item>
<item>
<first>i_V_reg_263</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>22</item>
</second>
</item>
<item>
<first>j_V_reg_272</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>32</item>
</second>
</item>
<item>
<first>t_V_1_reg_184</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>29</item>
</second>
</item>
<item>
<first>t_V_reg_173</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>19</item>
</second>
</item>
<item>
<first>tmp_data_V_reg_287</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>46</item>
</second>
</item>
<item>
<first>tmp_user_V_load_reg_282</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>35</item>
</second>
</item>
<item>
<first>tmp_user_V_reg_252</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>11</item>
</second>
</item>
</dp_regname_nodes>
<dp_reg_phi>
<count>2</count>
<item_version>0</item_version>
<item>
<first>173</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>19</item>
</second>
</item>
<item>
<first>184</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>29</item>
</second>
</item>
</dp_reg_phi>
<dp_regname_phi>
<count>2</count>
<item_version>0</item_version>
<item>
<first>t_V_1_reg_184</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>29</item>
</second>
</item>
<item>
<first>t_V_reg_173</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>19</item>
</second>
</item>
</dp_regname_phi>
<dp_port_io_nodes class_id="51" tracking_level="0" version="0">
<count>10</count>
<item_version>0</item_version>
<item class_id="52" tracking_level="0" version="0">
<first>AXI_video_strm_V_data_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>write</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>47</item>
</second>
</item>
</second>
</item>
<item>
<first>AXI_video_strm_V_dest_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>write</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>47</item>
</second>
</item>
</second>
</item>
<item>
<first>AXI_video_strm_V_id_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>write</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>47</item>
</second>
</item>
</second>
</item>
<item>
<first>AXI_video_strm_V_keep_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>write</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>47</item>
</second>
</item>
</second>
</item>
<item>
<first>AXI_video_strm_V_last_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>write</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>47</item>
</second>
</item>
</second>
</item>
<item>
<first>AXI_video_strm_V_strb_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>write</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>47</item>
</second>
</item>
</second>
</item>
<item>
<first>AXI_video_strm_V_user_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>write</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>47</item>
</second>
</item>
</second>
</item>
<item>
<first>img_data_stream_0_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>read</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>42</item>
</second>
</item>
</second>
</item>
<item>
<first>img_data_stream_1_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>read</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>43</item>
</second>
</item>
</second>
</item>
<item>
<first>img_data_stream_2_V</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>
<first>read</first>
<second>
<count>1</count>
<item_version>0</item_version>
<item>44</item>
</second>
</item>
</second>
</item>
</dp_port_io_nodes>
<port2core class_id="53" tracking_level="0" version="0">
<count>3</count>
<item_version>0</item_version>
<item class_id="54" tracking_level="0" version="0">
<first>1</first>
<second>FIFO</second>
</item>
<item>
<first>2</first>
<second>FIFO</second>
</item>
<item>
<first>3</first>
<second>FIFO</second>
</item>
</port2core>
<node2core>
<count>0</count>
<item_version>0</item_version>
</node2core>
</syndb>
</boost_serialization>
|
with Ada.Strings.Unbounded;
use Ada.Strings.Unbounded;
package P_StructuralTypes is
subtype T_Key is String (1..8);
type T_Bit is mod 2
with Size => 1;
type T_BinaryUnit is array (Positive range <>) of T_Bit
with Default_Component_Value => 0;
pragma Pack (T_BinaryUnit);
subtype T_BinaryBlock is T_BinaryUnit (1..64);
subtype T_Byte is T_BinaryUnit (1..8);
subtype T_BinaryExpandedBlock is T_BinaryUnit (1..48);
subtype T_BinaryHalfBlock is T_BinaryUnit (1..32);
subtype T_BinaryKey is T_BinaryUnit (1..64);
subtype T_BinaryFormattedKey is T_BinaryUnit (1..56);
subtype T_BinaryHalfFormattedKey is T_BinaryUnit (1..28);
subtype T_BinarySubKey is T_BinaryUnit (1..48);
type T_BinaryContainer is array (Positive range <>) of T_BinaryBlock;
pragma Pack (T_BinaryContainer);
type T_BinarySubKeyArray is array (1..16) of T_BinarySubKey;
pragma Pack (T_BinarySubKeyArray);
-----------------------------------------------------------------------------
-------------------------------- ACCESS -------------------------------------
-----------------------------------------------------------------------------
type BinaryContainer_Access is access T_BinaryContainer;
type BinarySubKeyArray_Access is access T_BinarySubKeyArray;
type Key_Access is access T_Key;
-----------------------------------------------------------------------------
----------------------------- FUNCTIONS -------------------------------------
-----------------------------------------------------------------------------
function O_plus (b1 : in T_BinaryUnit ; b2 : in T_BinaryUnit) return T_BinaryUnit;
function TextBlock_To_Binary (Block : String) return T_BinaryBlock;
function Byte_To_CharacterCode (Byte : in T_Byte) return Integer;
function Integer_To_Binary (Number : Integer;
NbBits : Integer) return T_BinaryUnit;
procedure Replace_Block (Ptr_BinaryContainer : in BinaryContainer_Access;
Index : in Integer;
BinaryBlock : in T_BinaryBlock);
procedure Left_Shift (Unit : in out T_BinaryUnit;
Iteration : in Positive);
function Left (Block : T_BinaryUnit) return T_BinaryUnit;
function Right (Block : T_BinaryUnit) return T_BinaryUnit;
procedure Put_BinaryUnit (Unit : T_BinaryUnit);
end P_StructuralTypes;
|
with STM32_SVD; use STM32_SVD;
with STM32_SVD.NVIC; use STM32_SVD.NVIC;
with STM32_SVD.SCB; use STM32_SVD.SCB;
with STM32_SVD.PWR; use STM32_SVD.PWR;
with STM32_SVD.EXTI; use STM32_SVD.EXTI;
with STM32_SVD.RCC; use STM32_SVD.RCC;
with STM32_SVD.RTC; use STM32_SVD.RTC;
package body STM32GD.RTC is
Days_Per_Month : constant array (0 .. 12) of Natural := (
0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
procedure Unlock is
begin
RTC_Periph.WPR.KEY := 16#CA#;
RTC_Periph.WPR.KEY := 16#53#;
end Unlock;
procedure Lock is
begin
RTC_Periph.WPR.KEY := 16#FF#;
end Lock;
procedure Read (Date_Time : out Date_Time_Type) is
begin
Date_Time.Day := Natural(RTC_Periph.DR.DU) + Natural(RTC_Periph.DR.DT) * 10;
Date_Time.Month := Natural(RTC_Periph.DR.MU) + Natural(RTC_Periph.DR.MT) * 10;
Date_Time.Year := Natural(RTC_Periph.DR.YU) + Natural(RTC_Periph.DR.YT) * 10;
Date_Time.Hour := Natural(RTC_Periph.TR.HU) + Natural(RTC_Periph.TR.HT) * 10;
Date_Time.Minute := Natural(RTC_Periph.TR.MNU) + Natural(RTC_Periph.TR.MNT) * 10;
Date_Time.Second := Natural(RTC_Periph.TR.SU) + Natural(RTC_Periph.TR.ST) * 10;
end Read;
procedure Print (Date_Time : Date_Time_Type) is
begin
-- Put (Integer'Image (Date_Time.Year));
-- Put (Integer'Image (Date_Time.Month));
-- Put (Integer'Image (Date_Time.Day));
-- Put (Integer'Image (Date_Time.Hour));
-- Put (Integer'Image (Date_Time.Minute));
-- Put_Line (Integer'Image (Date_Time.Second));
null;
end Print;
procedure Add_Seconds (Date_Time : in out Date_Time_Type ;
Second_Delta : Second_Delta_Type) is
Total_Seconds : Natural;
begin
Total_Seconds :=
Date_Time.Second +
Date_Time.Minute * 60 +
Date_Time.Hour * 60 * 60 + Second_Delta;
Date_Time.Second := Total_Seconds mod 60;
Date_Time.Minute := Total_Seconds mod (60 * 60) / 60;
Date_Time.Hour := Total_Seconds / 3600;
if Total_Seconds / (60 * 60) > Hour_Type'Last then
Total_Seconds := Total_Seconds - Hour_Type'Last * (60 * 60);
end if;
Date_Time.Hour := Total_Seconds / (60 * 60);
end Add_Seconds;
procedure Add_Minutes (Date_Time : in out Date_Time_Type ;
Minute_Delta : Minute_Delta_Type) is
Total_Minutes : Natural;
begin
Total_Minutes := Date_Time.Minute + Date_Time.Hour * 60 + Minute_Delta;
Date_Time.Minute := Total_Minutes mod 60;
if Total_Minutes / 60 > Hour_Type'Last then
Total_Minutes := Total_Minutes - Hour_Type'Last * 60;
end if;
Date_Time.Hour := Total_Minutes / 60;
end Add_Minutes;
procedure Set_Alarm (Date_Time : Date_Time_Type) is
begin
Unlock;
RTC_Periph.CR.ALRAIE := 0;
RTC_Periph.ISR.ALRAF := 0;
RTC_Periph.CR.ALRAE := 0;
while RTC_Periph.ISR.ALRAWF = 0 loop
null;
end loop;
RTC_Periph.ALRMAR := (
MSK1 => 0,
ST => UInt3 (Date_Time.Second / 10),
SU => UInt4 (Date_Time.Second mod 10),
MSK2 => 0,
MNT => UInt3 (Date_Time.Minute / 10),
MNU => UInt4 (Date_Time.Minute mod 10),
MSK3 => 0,
PM => 0,
HT => UInt2 (Date_Time.Hour / 10),
HU => UInt4 (Date_Time.Hour mod 10),
MSK4 => 1, WDSEL => 0, DT => 0, DU => 0);
RTC_Periph.CR.ALRAE := 1;
RTC_Periph.CR.ALRAIE := 1;
Lock;
EXTI_Periph.EMR.MR.Arr (17) := 1;
EXTI_Periph.RTSR.TR.Arr (17) := 1;
end Set_Alarm;
procedure Clear_Alarm is
ICPR : UInt32;
begin
ICPR := NVIC_Periph.ICPR;
ICPR := ICPR or 2 ** 3;
NVIC_Periph.ICPR := ICPR;
EXTI_Periph.PR.PR.Arr (17) := 1;
Unlock;
RTC_Periph.ISR.ALRAF := 0;
RTC_Periph.CR.ALRAE := 0;
RTC_Periph.CR.ALRAIE := 0;
Lock;
end Clear_Alarm;
procedure Init is
use STM32GD.Clock;
begin
RCC_Periph.APB1ENR.PWREN := 1;
PWR_Periph.CR.DBP := 1;
case Clock is
when LSE => RCC_Periph.BDCR.RTCSEL := 2#01#;
pragma Compile_Time_Error (Clock = LSE and not Clock_Tree.LSE_Enabled, "LSE not enabled for RTC");
when LSI => RCC_Periph.BDCR.RTCSEL := 2#10#;
pragma Compile_Time_Error (Clock = LSI and not Clock_Tree.LSI_Enabled, "LSE not enabled for RTC");
when others =>
pragma Compile_Time_Error (Clock /= LSI and Clock /= LSE, "RTC clock needs to be LSI or LSE");
end case;
RCC_Periph.BDCR.RTCEN := 1;
end Init;
function To_Seconds (Date_Time : Date_Time_Type) return Natural is
begin
return Date_Time.Second +
Date_Time.Minute * 60 +
Date_Time.Hour * 60 * 60 +
(Date_Time.Day - 1) * 24 * 60 * 60 +
Days_Per_Month (Date_Time.Month - 1) * 24 * 60 * 60 +
Date_Time.Year * 365 * 24 * 60 * 60;
end To_Seconds;
procedure Wait_For_Alarm is
begin
loop
STM32GD.Wait_For_Event;
exit when Alarm_Triggered;
end loop;
Clear_Alarm;
end Wait_For_Alarm;
function Alarm_Triggered return Boolean is
begin
return RTC_Periph.ISR.ALRAF = 1;
end Alarm_Triggered;
end STM32GD.RTC;
|
-- Copyright 2005-2020 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/>.
procedure P is
type Index is (One, Two, Three);
type Table is array (Integer range 1 .. 3) of Integer;
type ETable is array (Index) of Integer;
type RTable is array (Index range Two .. Three) of Integer;
type UTable is array (Positive range <>) of Integer;
type PTable is array (Index) of Boolean;
pragma Pack (PTable);
function Get_UTable (I : Integer) return UTable is
begin
return Utable'(1 => I, 2 => 2, 3 => 3);
end Get_UTable;
One_Two_Three : Table := (1, 2, 3);
E_One_Two_Three : ETable := (1, 2, 3);
R_Two_Three : RTable := (2, 3);
U_One_Two_Three : UTable := Get_UTable (1);
P_One_Two_Three : PTable := (False, True, True);
Few_Reps : UTable := (1, 2, 3, 3, 3, 3, 3, 4, 5);
Many_Reps : UTable := (1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5);
Empty : array (1 .. 0) of Integer := (others => 0);
begin
One_Two_Three (1) := 4; -- START
E_One_Two_Three (One) := 4;
R_Two_Three (Two) := 4;
U_One_Two_Three (U_One_Two_Three'First) := 4;
P_One_Two_Three (One) := True;
Few_Reps (Few_Reps'First) := 2;
Many_Reps (Many_Reps'First) := 2;
Empty := (others => 1);
end P;
|
------------------------------------------------------------------------------
-- --
-- Copyright (C) 2016, AdaCore --
-- --
-- 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. --
-- 3. Neither the name of the copyright holder 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 NRF51_SVD.RTC; use NRF51_SVD.RTC;
package body nRF51.RTC is
-----------
-- Start --
-----------
procedure Start (This : Real_Time_Counter) is
begin
This.Periph.TASKS_START := 1;
end Start;
----------
-- Stop --
----------
procedure Stop (This : Real_Time_Counter) is
begin
This.Periph.TASKS_STOP := 1;
end Stop;
-----------
-- Clear --
-----------
procedure Clear (This : Real_Time_Counter) is
begin
This.Periph.TASKS_CLEAR := 1;
end Clear;
-------------------
-- Set_Prescaler --
-------------------
procedure Set_Prescaler
(This : Real_Time_Counter;
Prescaler : UInt12)
is
begin
This.Periph.PRESCALER.PRESCALER := Prescaler;
end Set_Prescaler;
-------------
-- Counter --
-------------
function Counter (This : Real_Time_Counter) return UInt24 is
begin
return This.Periph.COUNTER.COUNTER;
end Counter;
-----------------
-- Set_Compare --
-----------------
procedure Set_Compare
(This : Real_Time_Counter;
Compare : Compare_Channel;
Value : UInt24)
is
begin
This.Periph.CC (Integer (Compare)).COMPARE := Value;
end Set_Compare;
-----------
-- Event --
-----------
function Event
(This : Real_Time_Counter;
Evt : RTC_Events)
return Event_Type
is
begin
case Evt is
when Tick_Event =>
return Event_Type (This.Periph.EVENTS_TICK'Address);
when Overflow_Event =>
return Event_Type (This.Periph.EVENTS_OVRFLW'Address);
when Compare_0_Event =>
return Event_Type (This.Periph.EVENTS_COMPARE (0)'Address);
when Compare_1_Event =>
return Event_Type (This.Periph.EVENTS_COMPARE (1)'Address);
when Compare_2_Event =>
return Event_Type (This.Periph.EVENTS_COMPARE (2)'Address);
when Compare_3_Event =>
return Event_Type (This.Periph.EVENTS_COMPARE (3)'Address);
end case;
end Event;
------------------
-- Enable_Event --
------------------
procedure Enable_Event
(This : Real_Time_Counter;
Evt : RTC_Events)
is
begin
case Evt is
when Tick_Event =>
This.Periph.EVTEN.TICK := Enabled;
when Overflow_Event =>
This.Periph.EVTEN.OVRFLW := Enabled;
when Compare_0_Event =>
This.Periph.EVTEN.COMPARE.Arr (0) := Enabled;
when Compare_1_Event =>
This.Periph.EVTEN.COMPARE.Arr (1) := Enabled;
when Compare_2_Event =>
This.Periph.EVTEN.COMPARE.Arr (2) := Enabled;
when Compare_3_Event =>
This.Periph.EVTEN.COMPARE.Arr (3) := Enabled;
end case;
end Enable_Event;
-------------------
-- Disable_Event --
-------------------
procedure Disable_Event
(This : Real_Time_Counter;
Evt : RTC_Events)
is
begin
case Evt is
when Tick_Event =>
This.Periph.EVTEN.TICK := Disabled;
when Overflow_Event =>
This.Periph.EVTEN.OVRFLW := Disabled;
when Compare_0_Event =>
This.Periph.EVTEN.COMPARE.Arr (0) := Disabled;
when Compare_1_Event =>
This.Periph.EVTEN.COMPARE.Arr (1) := Disabled;
when Compare_2_Event =>
This.Periph.EVTEN.COMPARE.Arr (2) := Disabled;
when Compare_3_Event =>
This.Periph.EVTEN.COMPARE.Arr (3) := Disabled;
end case;
end Disable_Event;
end nRF51.RTC;
|
with Ada.Text_IO;
with Ada.Streams;
with GNAT.Sockets;
package body Emulator_8080.Vram_Sender is
Address : GNAT.Sockets.Sock_Addr_Type;
procedure Initialize(Port : in Natural; Ip_Address : in String) is
begin
Address := GNAT.Sockets.Sock_Addr_Type'(Family => GNAT.Sockets.Family_Inet,
Addr => GNAT.Sockets.Inet_Addr(Ip_Address),
Port => GNAT.Sockets.Port_Type(Port));
GNAT.Sockets.Create_Socket(Socket => Sender_Socket,
Family => GNAT.Sockets.Family_Inet,
Mode => GNAT.Sockets.Socket_Datagram);
end Initialize;
procedure Close is
begin
GNAT.Sockets.Close_Socket(Sender_Socket);
end Close;
procedure Send_Vram(Vram : in Emulator_8080.Processor.Vram_Type) is
use Ada.Streams;
Data : Ada.Streams.Stream_Element_Array(1 .. Vram'Length);
Counter : Ada.Streams.Stream_Element_Offset := Data'First;
Last : Ada.Streams.Stream_Element_Offset;
begin
for I in Vram'Range loop
Data(Counter) := Ada.Streams.Stream_Element(Vram(I));
Counter := Counter + 1;
end loop;
Gnat.Sockets.Send_Socket (Sender_Socket, Data, Last, Address);
end;
end Emulator_8080.Vram_Sender;
|
------------------------------------------------------------------------------
-- --
-- GNAT LIBRARY COMPONENTS --
-- --
-- ADA.CONTAINERS.INDEFINITE_MULTIWAY_TREES --
-- --
-- S p e c --
-- --
-- Copyright (C) 2004-2019, Free Software Foundation, Inc. --
-- --
-- This specification is derived from the Ada Reference Manual for use with --
-- GNAT. The copyright notice above, and the license provisions that follow --
-- apply solely to the contents of the part following the private keyword. --
-- --
-- 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/>. --
-- --
-- This unit was originally developed by Matthew J Heaney. --
------------------------------------------------------------------------------
with Ada.Iterator_Interfaces;
with Ada.Containers.Helpers;
private with Ada.Finalization;
private with Ada.Streams;
generic
type Element_Type (<>) is private;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Indefinite_Multiway_Trees is
pragma Annotate (CodePeer, Skip_Analysis);
pragma Preelaborate;
pragma Remote_Types;
type Tree is tagged private
with Constant_Indexing => Constant_Reference,
Variable_Indexing => Reference,
Default_Iterator => Iterate,
Iterator_Element => Element_Type;
pragma Preelaborable_Initialization (Tree);
type Cursor is private;
pragma Preelaborable_Initialization (Cursor);
Empty_Tree : constant Tree;
No_Element : constant Cursor;
function Has_Element (Position : Cursor) return Boolean;
package Tree_Iterator_Interfaces is new
Ada.Iterator_Interfaces (Cursor, Has_Element);
function Equal_Subtree
(Left_Position : Cursor;
Right_Position : Cursor) return Boolean;
function "=" (Left, Right : Tree) return Boolean;
function Is_Empty (Container : Tree) return Boolean;
function Node_Count (Container : Tree) return Count_Type;
function Subtree_Node_Count (Position : Cursor) return Count_Type;
function Depth (Position : Cursor) return Count_Type;
function Is_Root (Position : Cursor) return Boolean;
function Is_Leaf (Position : Cursor) return Boolean;
function Root (Container : Tree) return Cursor;
procedure Clear (Container : in out Tree);
function Element (Position : Cursor) return Element_Type;
procedure Replace_Element
(Container : in out Tree;
Position : Cursor;
New_Item : Element_Type);
procedure Query_Element
(Position : Cursor;
Process : not null access procedure (Element : Element_Type));
procedure Update_Element
(Container : in out Tree;
Position : Cursor;
Process : not null access procedure (Element : in out Element_Type));
type Constant_Reference_Type
(Element : not null access constant Element_Type) is private
with Implicit_Dereference => Element;
type Reference_Type
(Element : not null access Element_Type) is private
with Implicit_Dereference => Element;
function Constant_Reference
(Container : aliased Tree;
Position : Cursor) return Constant_Reference_Type;
pragma Inline (Constant_Reference);
function Reference
(Container : aliased in out Tree;
Position : Cursor) return Reference_Type;
pragma Inline (Reference);
procedure Assign (Target : in out Tree; Source : Tree);
function Copy (Source : Tree) return Tree;
procedure Move (Target : in out Tree; Source : in out Tree);
procedure Delete_Leaf
(Container : in out Tree;
Position : in out Cursor);
procedure Delete_Subtree
(Container : in out Tree;
Position : in out Cursor);
procedure Swap
(Container : in out Tree;
I, J : Cursor);
function Find
(Container : Tree;
Item : Element_Type) return Cursor;
-- This version of the AI:
-- 10-06-02 AI05-0136-1/07
-- declares Find_In_Subtree this way:
--
-- function Find_In_Subtree
-- (Container : Tree;
-- Item : Element_Type;
-- Position : Cursor) return Cursor;
--
-- It seems that the Container parameter is there by mistake, but we need
-- an official ruling from the ARG. ???
function Find_In_Subtree
(Position : Cursor;
Item : Element_Type) return Cursor;
-- This version of the AI:
-- 10-06-02 AI05-0136-1/07
-- declares Ancestor_Find this way:
--
-- function Ancestor_Find
-- (Container : Tree;
-- Item : Element_Type;
-- Position : Cursor) return Cursor;
--
-- It seems that the Container parameter is there by mistake, but we need
-- an official ruling from the ARG. ???
function Ancestor_Find
(Position : Cursor;
Item : Element_Type) return Cursor;
function Contains
(Container : Tree;
Item : Element_Type) return Boolean;
procedure Iterate
(Container : Tree;
Process : not null access procedure (Position : Cursor));
procedure Iterate_Subtree
(Position : Cursor;
Process : not null access procedure (Position : Cursor));
function Iterate (Container : Tree)
return Tree_Iterator_Interfaces.Forward_Iterator'Class;
function Iterate_Subtree (Position : Cursor)
return Tree_Iterator_Interfaces.Forward_Iterator'Class;
function Iterate_Children
(Container : Tree;
Parent : Cursor)
return Tree_Iterator_Interfaces.Reversible_Iterator'Class;
function Child_Count (Parent : Cursor) return Count_Type;
function Child_Depth (Parent, Child : Cursor) return Count_Type;
procedure Insert_Child
(Container : in out Tree;
Parent : Cursor;
Before : Cursor;
New_Item : Element_Type;
Count : Count_Type := 1);
procedure Insert_Child
(Container : in out Tree;
Parent : Cursor;
Before : Cursor;
New_Item : Element_Type;
Position : out Cursor;
Count : Count_Type := 1);
procedure Prepend_Child
(Container : in out Tree;
Parent : Cursor;
New_Item : Element_Type;
Count : Count_Type := 1);
procedure Append_Child
(Container : in out Tree;
Parent : Cursor;
New_Item : Element_Type;
Count : Count_Type := 1);
procedure Delete_Children
(Container : in out Tree;
Parent : Cursor);
procedure Copy_Subtree
(Target : in out Tree;
Parent : Cursor;
Before : Cursor;
Source : Cursor);
procedure Splice_Subtree
(Target : in out Tree;
Parent : Cursor;
Before : Cursor;
Source : in out Tree;
Position : in out Cursor);
procedure Splice_Subtree
(Container : in out Tree;
Parent : Cursor;
Before : Cursor;
Position : Cursor);
procedure Splice_Children
(Target : in out Tree;
Target_Parent : Cursor;
Before : Cursor;
Source : in out Tree;
Source_Parent : Cursor);
procedure Splice_Children
(Container : in out Tree;
Target_Parent : Cursor;
Before : Cursor;
Source_Parent : Cursor);
function Parent (Position : Cursor) return Cursor;
function First_Child (Parent : Cursor) return Cursor;
function First_Child_Element (Parent : Cursor) return Element_Type;
function Last_Child (Parent : Cursor) return Cursor;
function Last_Child_Element (Parent : Cursor) return Element_Type;
function Next_Sibling (Position : Cursor) return Cursor;
function Previous_Sibling (Position : Cursor) return Cursor;
procedure Next_Sibling (Position : in out Cursor);
procedure Previous_Sibling (Position : in out Cursor);
-- This version of the AI:
-- 10-06-02 AI05-0136-1/07
-- declares Iterate_Children this way:
--
-- procedure Iterate_Children
-- (Container : Tree;
-- Parent : Cursor;
-- Process : not null access procedure (Position : Cursor));
--
-- It seems that the Container parameter is there by mistake, but we need
-- an official ruling from the ARG. ???
procedure Iterate_Children
(Parent : Cursor;
Process : not null access procedure (Position : Cursor));
procedure Reverse_Iterate_Children
(Parent : Cursor;
Process : not null access procedure (Position : Cursor));
private
use Ada.Containers.Helpers;
package Implementation is new Generic_Implementation;
use Implementation;
type Tree_Node_Type;
type Tree_Node_Access is access all Tree_Node_Type;
type Children_Type is record
First : Tree_Node_Access;
Last : Tree_Node_Access;
end record;
type Element_Access is access all Element_Type;
type Tree_Node_Type is record
Parent : Tree_Node_Access;
Prev : Tree_Node_Access;
Next : Tree_Node_Access;
Children : Children_Type;
Element : Element_Access;
end record;
use Ada.Finalization;
-- The Count component of type Tree represents the number of nodes that
-- have been (dynamically) allocated. It does not include the root node
-- itself. As implementors, we decide to cache this value, so that the
-- selector function Node_Count can execute in O(1) time, in order to be
-- consistent with the behavior of the Length selector function for other
-- standard container library units. This does mean, however, that the
-- two-container forms for Splice_XXX (that move subtrees across tree
-- containers) will execute in O(n) time, because we must count the number
-- of nodes in the subtree(s) that get moved. (We resolve the tension
-- between Node_Count and Splice_XXX in favor of Node_Count, under the
-- assumption that Node_Count is the more common operation).
type Tree is new Controlled with record
Root : aliased Tree_Node_Type;
TC : aliased Tamper_Counts;
Count : Count_Type := 0;
end record;
overriding procedure Adjust (Container : in out Tree);
overriding procedure Finalize (Container : in out Tree) renames Clear;
use Ada.Streams;
procedure Write
(Stream : not null access Root_Stream_Type'Class;
Container : Tree);
for Tree'Write use Write;
procedure Read
(Stream : not null access Root_Stream_Type'Class;
Container : out Tree);
for Tree'Read use Read;
type Tree_Access is access all Tree;
for Tree_Access'Storage_Size use 0;
type Cursor is record
Container : Tree_Access;
Node : Tree_Node_Access;
end record;
procedure Write
(Stream : not null access Root_Stream_Type'Class;
Position : Cursor);
for Cursor'Write use Write;
procedure Read
(Stream : not null access Root_Stream_Type'Class;
Position : out Cursor);
for Cursor'Read use Read;
subtype Reference_Control_Type is Implementation.Reference_Control_Type;
-- It is necessary to rename this here, so that the compiler can find it
type Constant_Reference_Type
(Element : not null access constant Element_Type) is
record
Control : Reference_Control_Type :=
raise Program_Error with "uninitialized reference";
-- The RM says, "The default initialization of an object of
-- type Constant_Reference_Type or Reference_Type propagates
-- Program_Error."
end record;
procedure Read
(Stream : not null access Root_Stream_Type'Class;
Item : out Constant_Reference_Type);
for Constant_Reference_Type'Read use Read;
procedure Write
(Stream : not null access Root_Stream_Type'Class;
Item : Constant_Reference_Type);
for Constant_Reference_Type'Write use Write;
type Reference_Type
(Element : not null access Element_Type) is
record
Control : Reference_Control_Type :=
raise Program_Error with "uninitialized reference";
-- The RM says, "The default initialization of an object of
-- type Constant_Reference_Type or Reference_Type propagates
-- Program_Error."
end record;
procedure Read
(Stream : not null access Root_Stream_Type'Class;
Item : out Reference_Type);
for Reference_Type'Read use Read;
procedure Write
(Stream : not null access Root_Stream_Type'Class;
Item : Reference_Type);
for Reference_Type'Write use Write;
-- Three operations are used to optimize in the expansion of "for ... of"
-- loops: the Next(Cursor) procedure in the visible part, and the following
-- Pseudo_Reference and Get_Element_Access functions. See Exp_Ch5 for
-- details.
function Pseudo_Reference
(Container : aliased Tree'Class) return Reference_Control_Type;
pragma Inline (Pseudo_Reference);
-- Creates an object of type Reference_Control_Type pointing to the
-- container, and increments the Lock. Finalization of this object will
-- decrement the Lock.
function Get_Element_Access
(Position : Cursor) return not null Element_Access;
-- Returns a pointer to the element designated by Position.
Empty_Tree : constant Tree := (Controlled with others => <>);
No_Element : constant Cursor := (others => <>);
end Ada.Containers.Indefinite_Multiway_Trees;
|
------------------------------------------------------------------------------
-- G E L A A S I S --
-- ASIS implementation for Gela project, a portable Ada compiler --
-- http://gela.ada-ru.org --
-- - - - - - - - - - - - - - - - --
-- Read copyright and license at the end of this file --
------------------------------------------------------------------------------
-- $Revision: 209 $ $Date: 2013-11-30 21:03:24 +0200 (Сб., 30 нояб. 2013) $
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Maps;
with Ada.Strings.Fixed;
with Ada.Strings.Unbounded;
with Macros;
with UAFlex.Tokens;
with Automatons;
with Automatons.Output;
with Automatons.Minimize;
with Regular_Expressions.Create;
package body UAFlex is
procedure Error (Msg, Text : String := "") is
begin
Put_Line (Standard_Error, Msg & Text);
end Error;
procedure Run
(Input_File : String;
Pkg_Name : String;
Output_Dir : String)
is
use Ada.Strings;
use Regular_Expressions;
package U renames Ada.Strings.Unbounded;
use type U.Unbounded_String;
Max_Starts : constant := 30;
Top : array (1 .. Max_Starts) of Expression;
Top_Set : array (1 .. Max_Starts) of Boolean := (others => False);
Exclusive : array (1 .. Max_Starts) of Boolean := (others => False);
Start : Automatons.Output.Start_Names (1 .. Max_Starts);
Last_Start : Positive := 1;
procedure New_Rule (Index : Natural; Name : String; Expr : Expression) is
Token : Positive;
Rule : Expression;
begin
Tokens.Get_Token (Name, Token);
Rule := New_Rule (Expr, Token);
if Top_Set (Index) then
Top (Index) := New_Alternative (Top (Index), Rule);
else
Top (Index) := Rule;
Top_Set (Index) := True;
end if;
end New_Rule;
procedure New_Rule (Prefix : String; Name : String; Expr : Expression) is
Comma : constant Maps.Character_Set := Maps.To_Set (',');
Word_From : Positive := Prefix'First;
Word_To : Natural;
Found : Boolean := False;
begin
loop
Fixed.Find_Token (Source => Prefix (Word_From .. Prefix'Last),
Set => Comma,
Test => Outside,
First => Word_From,
Last => Word_To);
exit when Word_To = 0;
Found := False;
for I in 1 .. Last_Start loop
if Start (I) = Prefix (Word_From .. Word_To)
then
Found := True;
New_Rule (I, Name, Expr);
end if;
end loop;
if not Found then
Error ("Not a state: ", Prefix (Word_From .. Word_To));
end if;
Word_From := Word_To + 1;
Found := True;
end loop;
if not Found then -- no prefix <...> exists
for I in 1 .. Last_Start loop
if not Exclusive (I) then
New_Rule (I, Name, Expr);
end if;
end loop;
end if;
end New_Rule;
procedure New_Macro (Name : String; Expr : Expression) is
begin
Macros.Add (Name, Expr);
end New_Macro;
type Sections is (Macro_Section, Rule_Section);
Input : File_Type;
Line : String (1 .. 4000);
Last : Natural;
Section : Sections := Macro_Section;
Spaces : constant Maps.Character_Set := Maps.To_Set (' ' & ASCII.HT);
Word_From : Positive;
Word_To : Natural;
Rule_From : Positive;
Rule_To : Natural;
Pref_From : Positive;
Pref_To : Natural;
Expr : Expression;
DFA : Automatons.DFA;
begin
Open (Input, In_File, Input_File);
while not End_Of_File (Input) loop
Get_Line (Input, Line, Last);
if Last = 0 then
null;
elsif Last < 2 then
Error ("Bad line:", Line (1 .. Last));
return;
elsif Line (1 .. Last) = "%%" then
Section := Sections'Succ (Section);
elsif Line (1 .. 2) = "--" then
null;
elsif Section = Macro_Section and Line (1) = '%'
and (Line (2) = 's' or Line (2) = 'x') then
Fixed.Find_Token (Source => Line (3 .. Last),
Set => Spaces,
Test => Outside,
First => Word_From,
Last => Word_To);
if Word_To = 0 then
Error ("Bad line: ", Line (1 .. Last));
return;
end if;
Last_Start := Last_Start + 1;
Start (Last_Start) :=
U.To_Unbounded_String (Line (Word_From .. Word_To));
Exclusive (Last_Start) := Line (2) = 'x';
else
Fixed.Find_Token (Source => Line (1 .. Last),
Set => Spaces,
Test => Outside,
First => Word_From,
Last => Word_To);
if Word_To = 0 or Word_To = Last then
Error ("Bad line:", Line (1 .. Last));
return;
end if;
if Line (Word_From) = '<'
and Line (Word_To) = '>'
and Section = Rule_Section
then
Pref_From := Word_From + 1;
Pref_To := Word_To - 1;
Fixed.Find_Token (Source => Line (Word_To + 1 .. Last),
Set => Spaces,
Test => Outside,
First => Word_From,
Last => Word_To);
if Word_To = 0 or Word_To = Last then
Error ("Bad line:", Line (1 .. Last));
return;
end if;
else
Pref_From := 1;
Pref_To := 0;
end if;
Fixed.Find_Token (Source => Line (Word_To + 1 .. Last),
Set => Spaces,
Test => Outside,
First => Rule_From,
Last => Rule_To);
if Rule_To = 0 then
Error ("Bad line:", Line (1 .. Last));
return;
end if;
begin
Expr := Create (Line (Rule_From .. Last));
exception
when Syntax_Error =>
Error ("Bad rule:", Line (Rule_From .. Last));
end;
if Section = Macro_Section then
New_Macro (Line (Word_From .. Word_To), Expr);
else
New_Rule (Line (Pref_From .. Pref_To),
Line (Word_From .. Word_To),
Expr);
end if;
end if;
end loop;
for I in 1 .. Last_Start loop
if not Top_Set (I) then
Error ("No rule found for state " & U.To_String (Start (I)));
return;
end if;
Add_To_DFA (DFA, Top (I), I);
end loop;
Start (1) := U.To_Unbounded_String ("Default");
Automatons.Minimize (DFA);
Automatons.Output.Generate (DFA, Pkg_Name, Start, Output_Dir);
end Run;
end UAFlex;
------------------------------------------------------------------------------
-- Copyright (c) 2006-2013, Maxim Reznik
-- 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 Maxim Reznik, 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 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.
------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
-- Copyright (C) 2020-2030, per.s.sandberg@bahnhof.se --
-- --
-- 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 ZMQ.Examples is
END_MESSAGE : constant String := "<END>";
end ZMQ.Examples;
|
with Ada.Real_Time;
with ACO.CANopen;
with ACO.Messages;
with ACO.OD;
with ACO.SDO_Sessions;
private with Interfaces;
private with ACO.Log;
private with ACO.Utils.Generic_Alarms;
private with ACO.Configuration;
private with ACO.SDO_Commands;
private with ACO.OD_Types;
package ACO.Protocols.Service_Data is
SDO_S2C_Id : constant ACO.Messages.Function_Code := 16#B#;
SDO_C2S_Id : constant ACO.Messages.Function_Code := 16#C#;
type SDO
(Handler : not null access ACO.CANopen.Handler;
Od : not null access ACO.OD.Object_Dictionary'Class)
is abstract new Protocol with private;
function Tx_CAN_Id
(This : SDO;
Parameter : ACO.SDO_Sessions.SDO_Parameters)
return ACO.Messages.Id_Type is abstract;
function Rx_CAN_Id
(This : SDO;
Parameter : ACO.SDO_Sessions.SDO_Parameters)
return ACO.Messages.Id_Type is abstract;
function Get_Endpoint
(This : SDO;
Rx_CAN_Id : ACO.Messages.Id_Type)
return ACO.SDO_Sessions.Endpoint_Type is abstract;
procedure Result_Callback
(This : in out SDO;
Session : in ACO.SDO_Sessions.SDO_Session;
Result : in ACO.SDO_Sessions.SDO_Result) is abstract;
overriding
function Is_Valid
(This : in out SDO;
Msg : in ACO.Messages.Message)
return Boolean;
procedure Message_Received
(This : in out SDO'Class;
Msg : in ACO.Messages.Message)
with Pre => This.Is_Valid (Msg);
procedure Periodic_Actions
(This : in out SDO;
T_Now : in Ada.Real_Time.Time);
procedure Clear
(This : in out SDO;
Id : in ACO.SDO_Sessions.Valid_Endpoint_Nr);
private
type Error_Type is
(Nothing,
Unknown,
General_Error,
Invalid_Value_For_Parameter,
Toggle_Bit_Not_Altered,
SDO_Protocol_Timed_Out,
Command_Specifier_Not_Valid_Or_Unknown,
Object_Does_Not_Exist_In_The_Object_Dictionary,
Attempt_To_Read_A_Write_Only_Object,
Attempt_To_Write_A_Read_Only_Object,
Failed_To_Transfer_Or_Store_Data,
Failed_To_Transfer_Or_Store_Data_Due_To_Local_Control);
Abort_Code : constant array (Error_Type) of ACO.SDO_Commands.Abort_Code_Type :=
(Nothing => 16#0000_0000#,
Unknown => 16#0000_0000#,
General_Error => 16#0800_0000#,
Invalid_Value_For_Parameter => 16#0609_0030#,
Toggle_Bit_Not_Altered => 16#0503_0000#,
SDO_Protocol_Timed_Out => 16#0504_0000#,
Command_Specifier_Not_Valid_Or_Unknown => 16#0504_0001#,
Object_Does_Not_Exist_In_The_Object_Dictionary => 16#0602_0000#,
Attempt_To_Read_A_Write_Only_Object => 16#0601_0001#,
Attempt_To_Write_A_Read_Only_Object => 16#0601_0002#,
Failed_To_Transfer_Or_Store_Data => 16#0800_0020#,
Failed_To_Transfer_Or_Store_Data_Due_To_Local_Control => 16#0800_0021#);
package Alarms is new ACO.Utils.Generic_Alarms
(Configuration.Max_Nof_Simultaneous_SDO_Sessions);
type Alarm
(SDO_Ref : access SDO'Class := null)
is new Alarms.Alarm_Type with record
Id : ACO.SDO_Sessions.Endpoint_Nr := ACO.SDO_Sessions.No_Endpoint_Id;
end record;
overriding
procedure Signal
(This : access Alarm;
T_Now : in Ada.Real_Time.Time);
type Alarm_Array is array (ACO.SDO_Sessions.Valid_Endpoint_Nr'Range)
of aliased Alarm;
type SDO
(Handler : not null access ACO.CANopen.Handler;
Od : not null access ACO.OD.Object_Dictionary'Class)
--Wrap : not null access SDO_Wrapper_Base'Class)
is abstract new Protocol (Od) with record
Sessions : ACO.SDO_Sessions.Session_Manager;
Timers : Alarms.Alarm_Manager;
Alarms : Alarm_Array :=
(others => (SDO'Access, ACO.SDO_Sessions.No_Endpoint_Id));
end record;
procedure Indicate_Status
(This : in out SDO'Class;
Session : in ACO.SDO_Sessions.SDO_Session;
Status : in ACO.SDO_Sessions.SDO_Status);
procedure Handle_Message
(This : in out SDO;
Msg : in ACO.Messages.Message;
Endpoint : in ACO.SDO_Sessions.Endpoint_Type) is null;
procedure SDO_Log
(This : in out SDO;
Level : in ACO.Log.Log_Level;
Message : in String);
procedure Start_Alarm
(This : in out SDO;
Id : in ACO.SDO_Sessions.Valid_Endpoint_Nr);
procedure Stop_Alarm
(This : in out SDO;
Id : in ACO.SDO_Sessions.Valid_Endpoint_Nr);
procedure Abort_All
(This : in out SDO;
Msg : in ACO.Messages.Message;
Endpoint : in ACO.SDO_Sessions.Endpoint_Type);
procedure Write
(This : in out SDO;
Index : in ACO.OD_Types.Entry_Index;
Data : in ACO.Messages.Data_Array;
Error : out Error_Type);
procedure Send_SDO
(This : in out SDO'Class;
Endpoint : in ACO.SDO_Sessions.Endpoint_Type;
Raw_Data : in ACO.Messages.Msg_Data);
procedure Send_Abort
(This : in out SDO;
Endpoint : in ACO.SDO_Sessions.Endpoint_Type;
Error : in Error_Type;
Index : in ACO.OD_Types.Entry_Index := (0,0));
function Hex_Str
(X : Interfaces.Unsigned_32;
Trim : Boolean := True)
return String;
end ACO.Protocols.Service_Data;
|
-- Copyright 2008-2017 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/>.
package body Pck is
function Ident (P : Parameter) return Parameter is
begin
return P;
end Ident;
procedure Do_Nothing (P : in out Parameter) is
begin
null;
end Do_Nothing;
end Pck;
|
with Ada.Unchecked_Conversion;
with ACO.Utils.Byte_Order;
package body ACO.Generic_Entry_Types is
use ACO.Utils.Byte_Order;
function Swap (X : Byte_Array) return Byte_Array is
(Byte_Array (Swap_Bus (Octets (X))))
with Inline;
function Read (This : Entry_Type) return Item_Type is
(This.Data);
function Read (This : Entry_Type) return Byte_Array is
(Swap (Convert (This.Data)));
function Data_Length (This : Entry_Type) return Natural is
(Item_Type'Size / 8);
procedure Write (This : in out Entry_Type;
Data : in Item_Type)
is
begin
This.Data := Data;
end Write;
procedure Write (This : in out Entry_Type;
Bytes : in Byte_Array)
is
begin
This.Data := Convert (Swap (Bytes));
end Write;
function Create
(Accessability : Access_Mode;
Data : Item_Type) return Entry_Type
is ((Accessability, Data));
function Convert (Data : Item_Type) return Byte_Array
is
Bytes : constant Byte_Array (0 .. Data'Size / 8 - 1);
for Bytes'Address use Data'Address;
pragma Import (Convention => Ada, Entity => Bytes);
begin
return Bytes;
end Convert;
function Convert (Bytes : Byte_Array) return Item_Type is
-- Might get alignment issues?
function To_Item is new Ada.Unchecked_Conversion
(Source => Byte_Array,
Target => Item_Type);
begin
return To_Item (Bytes);
end Convert;
function "=" (L : Entry_Type; R : Item_Type) return Boolean is
(L.Data = R);
function "=" (L : Item_Type; R : Entry_Type) return Boolean is
(L = R.Data);
end ACO.Generic_Entry_Types;
|
package Notch_Example is
-- This hierarchy provides an example of how to write a notch
-- filter using the library fakedsp. The main procedure is
-- Notch_Example.Main, the callback implementing the filter is in
-- Notch_Example.Filters.
end Notch_Example;
|
with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Numerics.Float_Random;
use Ada.Text_IO, Ada.Integer_Text_IO, Ada.Numerics.Float_Random;
procedure exercise7 is
Count_Failed : exception; -- Exception to be raised when counting fails
Gen : Generator; -- Random number generator
protected type Transaction_Manager (N : Positive) is
entry Finished;
function Commit return Boolean;
procedure Signal_Abort;
private
Finished_Gate_Open : Boolean := False;
Aborted : Boolean := False;
Should_Commit : Boolean := True;
end Transaction_Manager;
protected body Transaction_Manager is
entry Finished when Finished_Gate_Open or Finished'Count = N is
begin
------------------------------------------
-- PART 3: Complete the exit protocol here
------------------------------------------
end Finished;
procedure Signal_Abort is
begin
Aborted := True;
end Signal_Abort;
function Commit return Boolean is
begin
return Should_Commit;
end Commit;
end Transaction_Manager;
function Unreliable_Slow_Add (x : Integer) return Integer is
Error_Rate : Constant := 0.15; -- (between 0 and 1)
begin
-------------------------------------------
-- PART 1: Create the transaction work here
-------------------------------------------
end Unreliable_Slow_Add;
task type Transaction_Worker (Initial : Integer; Manager : access Transaction_Manager);
task body Transaction_Worker is
Num : Integer := Initial;
Prev : Integer := Num;
Round_Num : Integer := 0;
begin
Put_Line ("Worker" & Integer'Image(Initial) & " started");
loop
Put_Line ("Worker" & Integer'Image(Initial) & " started round" & Integer'Image(Round_Num));
Round_Num := Round_Num + 1;
---------------------------------------
-- PART 2: Do the transaction work here
---------------------------------------
if Manager.Commit = True then
Put_Line (" Worker" & Integer'Image(Initial) & " comitting" & Integer'Image(Num));
else
Put_Line (" Worker" & Integer'Image(Initial) &
" reverting from" & Integer'Image(Num) &
" to" & Integer'Image(Prev));
-------------------------------------------
-- PART 2: Roll back to previous value here
-------------------------------------------
end if;
Prev := Num;
delay 0.5;
end loop;
end Transaction_Worker;
Manager : aliased Transaction_Manager (3);
Worker_1 : Transaction_Worker (0, Manager'Access);
Worker_2 : Transaction_Worker (1, Manager'Access);
Worker_3 : Transaction_Worker (2, Manager'Access);
begin
Reset(Gen); -- Seed the random number generator
end exercise7;
|
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- ADA.EXCEPTIONS.STREAM_ATTRIBUTES --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2021, 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. --
-- --
-- --
-- --
-- --
-- --
-- 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. --
-- --
------------------------------------------------------------------------------
pragma Warnings (Off);
-- Allow withing of non-Preelaborated units in Ada 2005 mode where this
-- package will be categorized as Preelaborate. See AI-362 for details.
-- It is safe in the context of the run-time to violate the rules.
with System.Exception_Table; use System.Exception_Table;
with System.Storage_Elements; use System.Storage_Elements;
pragma Warnings (On);
separate (Ada.Exceptions)
package body Stream_Attributes is
-------------------
-- EId_To_String --
-------------------
function EId_To_String (X : Exception_Id) return String is
begin
if X = Null_Id then
return "";
else
return Exception_Name (X);
end if;
end EId_To_String;
------------------
-- EO_To_String --
------------------
-- We use the null string to represent the null occurrence, otherwise we
-- output the Untailored_Exception_Information string for the occurrence.
function EO_To_String (X : Exception_Occurrence) return String is
begin
if X.Id = Null_Id then
return "";
else
return Exception_Data.Untailored_Exception_Information (X);
end if;
end EO_To_String;
-------------------
-- String_To_EId --
-------------------
function String_To_EId (S : String) return Exception_Id is
begin
if S = "" then
return Null_Id;
else
return Exception_Id (Internal_Exception (S));
end if;
end String_To_EId;
------------------
-- String_To_EO --
------------------
function String_To_EO (S : String) return Exception_Occurrence is
From : Natural;
To : Integer;
X : aliased Exception_Occurrence;
-- This is the exception occurrence we will create
procedure Bad_EO;
pragma No_Return (Bad_EO);
-- Signal bad exception occurrence string
procedure Next_String;
-- On entry, To points to last character of previous line of the
-- message, terminated by LF. On return, From .. To are set to
-- specify the next string, or From > To if there are no more lines.
procedure Bad_EO is
begin
Raise_Exception
(Program_Error'Identity,
"bad exception occurrence in stream input");
-- The following junk raise of Program_Error is required because
-- this is a No_Return procedure, and unfortunately Raise_Exception
-- can return (this particular call can't, but the back end is not
-- clever enough to know that).
raise Program_Error;
end Bad_EO;
procedure Next_String is
begin
From := To + 2;
if From < S'Last then
To := From + 1;
while To < S'Last - 1 loop
if To >= S'Last then
Bad_EO;
elsif S (To + 1) = ASCII.LF then
exit;
else
To := To + 1;
end if;
end loop;
end if;
end Next_String;
-- Start of processing for String_To_EO
begin
if S = "" then
return Null_Occurrence;
end if;
To := S'First - 2;
Next_String;
if S (From .. From + 6) /= "raised " then
Bad_EO;
end if;
declare
Name_Start : constant Positive := From + 7;
begin
From := Name_Start + 1;
while From < To and then S (From) /= ' ' loop
From := From + 1;
end loop;
X.Id :=
Exception_Id (Internal_Exception (S (Name_Start .. From - 1)));
end;
if From <= To then
if S (From .. From + 2) /= " : " then
Bad_EO;
end if;
X.Msg_Length := To - From - 2;
X.Msg (1 .. X.Msg_Length) := S (From + 3 .. To);
else
X.Msg_Length := 0;
end if;
Next_String;
X.Pid := 0;
if From <= To and then S (From) = 'P' then
if S (From .. From + 3) /= "PID:" then
Bad_EO;
end if;
From := From + 5; -- skip past PID: space
while From <= To loop
X.Pid := X.Pid * 10 +
(Character'Pos (S (From)) - Character'Pos ('0'));
From := From + 1;
end loop;
Next_String;
end if;
X.Num_Tracebacks := 0;
if From <= To then
if S (From .. To) /= "Call stack traceback locations:" then
Bad_EO;
end if;
Next_String;
loop
exit when From > To;
declare
Ch : Character;
C : Integer_Address;
N : Integer_Address;
begin
if S (From) /= '0'
or else S (From + 1) /= 'x'
then
Bad_EO;
else
From := From + 2;
end if;
C := 0;
while From <= To loop
Ch := S (From);
if Ch in '0' .. '9' then
N :=
Character'Pos (S (From)) - Character'Pos ('0');
elsif Ch in 'a' .. 'f' then
N :=
Character'Pos (S (From)) - Character'Pos ('a') + 10;
elsif Ch = ' ' then
From := From + 1;
exit;
else
Bad_EO;
end if;
C := C * 16 + N;
From := From + 1;
end loop;
if X.Num_Tracebacks = Max_Tracebacks then
Bad_EO;
end if;
X.Num_Tracebacks := X.Num_Tracebacks + 1;
X.Tracebacks (X.Num_Tracebacks) :=
TBE.TB_Entry_For (To_Address (C));
end;
end loop;
end if;
-- The occurrence we're crafting is not currently being
-- propagated.
X.Machine_Occurrence := System.Null_Address;
-- If an exception was converted to a string, it must have
-- already been raised, so flag it accordingly and we are done.
X.Exception_Raised := True;
return X;
end String_To_EO;
end Stream_Attributes;
|
pragma License (Unrestricted);
-- implementation unit required by compiler
with System.Packed_Arrays;
package System.Compare_Array_Signed_16 is
pragma Preelaborate;
-- It can not be Pure, subprograms would become __attribute__((const)).
type Integer_16 is range -(2 ** 15) .. 2 ** 15 - 1;
for Integer_16'Size use 16;
for Integer_16'Alignment use 1;
package Ordering is new Packed_Arrays.Ordering (Integer_16);
-- required to compare arrays by compiler (s-casi16.ads)
function Compare_Array_S16 (
Left : Address;
Right : Address;
Left_Len : Natural;
Right_Len : Natural)
return Integer
renames Ordering.Compare;
end System.Compare_Array_Signed_16;
|
-- Task sink
-- Binds PULL socket to tcp://localhost:5558
-- Collects results from workers via that socket
with Ada.Command_Line;
with Ada.Text_IO;
with GNAT.Formatted_String;
with Ada.Calendar;
with ZMQ;
procedure TaskSink2 is
use type Ada.Calendar.Time;
use type GNAT.Formatted_String.Formatted_String;
function Main return Ada.Command_Line.Exit_Status
is
begin
declare
-- Prepare our context and socket
Context : ZMQ.Context_Type := ZMQ.New_Context;
Receiver : constant ZMQ.Socket_Type'Class := Context.New_Socket (ZMQ.ZMQ_PULL);
Controller : constant ZMQ.Socket_Type'Class := Context.New_Socket (ZMQ.ZMQ_PUB);
begin
Receiver.Bind ("tcp://*:5558");
Controller.Bind ("tcp://*:5559");
-- Wait for start of batch
declare
Dummy : String := Receiver.Recv;
begin
null;
end;
declare
-- Start our clock now
Start_Time : constant Ada.Calendar.Time := Ada.Calendar.Clock;
begin
-- Process 100 confirmations
for Task_Nbr in 1 .. 100 loop
declare
Dummy : String := Receiver.Recv;
begin
null;
if Task_Nbr mod 10 = 0 then
Ada.Text_IO.Put (":");
else
Ada.Text_IO.Put (".");
end if;
Ada.Text_IO.Flush;
end;
end loop;
-- Calculate and report duration of batch
Ada.Text_IO.Put_Line ("");
Ada.Text_IO.Put_Line (-(+"Total elapsed time: %d msec" & Integer ((Ada.Calendar.Clock - Start_Time) * 1000.0)));
end;
-- Send kill signal to workers
Controller.Send ("KILL");
Receiver.Close;
Controller.Close;
Context.Term;
end;
return 0;
end Main;
begin
Ada.Command_Line.Set_Exit_Status (Main);
end TaskSink2;
|
-- C35504B.ADA
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
-- CHECK THAT CONSTRAINT_ERROR IS NOT RAISED FOR I'SUCC, I'PRED,
-- I'POS, I'VAL, I'IMAGE, AND I'VALUE FOR INTEGER ARGUMENTS
-- OUTSIDE THE RANGE OF I.
-- DAT 3/30/81
-- SPS 01/13/83
WITH REPORT;
USE REPORT;
PROCEDURE C35504B IS
SUBTYPE I IS INTEGER RANGE 0 .. 0;
BEGIN
TEST ("C35504B", "CONSTRAINT_ERROR IS NOT RAISED FOR"
& " INTEGER SUBTYPE ATTRIBUTES 'SUCC, 'PRED, 'POS, 'VAL,"
& " 'IMAGE, AND 'VALUE WHOSE ARGUMENTS ARE OUTSIDE THE"
& " SUBTYPE");
BEGIN
IF I'SUCC(-1) /= I'PRED(1)
THEN
FAILED ("WRONG ATTRIBUTE VALUE - 1");
END IF;
IF I'SUCC (100) /= 101
THEN
FAILED ("WRONG ATTRIBUTE VALUE - 2");
END IF;
IF I'PRED (100) /= 99
THEN
FAILED ("WRONG ATTRIBUTE VALUE - 3");
END IF;
IF I'POS (-100) /= -100
THEN
FAILED ("WRONG ATTRIBUTE VALUE - 4");
END IF;
IF I'VAL(-100) /= -100
THEN
FAILED ("WRONG ATTRIBUTE VALUE - 5");
END IF;
IF I'IMAGE(1234) /= " 1234"
THEN
FAILED ("WRONG ATTRIBUTE VALUE - 6");
END IF;
IF I'VALUE("999") /= 999
THEN
FAILED ("WRONG ATTRIBUTE VALUE - 7");
END IF;
EXCEPTION
WHEN OTHERS => FAILED ("EXCEPTION RAISED");
END;
RESULT;
END C35504B;
|
-- Copyright 2012-2021 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/>.
package IO is
procedure Put_Line (S : String);
end IO;
|
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- G N A T . A L T I V E C . V E C T O R _ O P E R A T I O N S --
-- --
-- S p e c --
-- --
-- Copyright (C) 2004-2020, 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 unit is the user-level Ada interface to AltiVec operations on vector
-- objects. It is common to both the Soft and the Hard bindings.
with GNAT.Altivec.Vector_Types; use GNAT.Altivec.Vector_Types;
with GNAT.Altivec.Low_Level_Vectors; use GNAT.Altivec.Low_Level_Vectors;
------------------------------------
-- GNAT.Altivec.Vector_Operations --
------------------------------------
------------------------------------
-- GNAT.Altivec.Vector_Operations --
------------------------------------
package GNAT.Altivec.Vector_Operations is
-------------------------------------
-- Different Flavors of Interfaces --
-------------------------------------
-- The vast majority of the user visible functions are just neutral type
-- conversion wrappers around calls to low level primitives. For instance:
-- function vec_sll
-- (A : vector_signed_int;
-- B : vector_unsigned_char) return vector_signed_int is
-- begin
-- return To_VSI (vsl (To_VSI (A), To_VSI (B)));
-- end vec_sll;
-- We actually don't always need an explicit wrapper and can bind directly
-- with a straight Import of the low level routine, or a renaming of such
-- instead.
-- A direct binding is not possible (that is, a wrapper is mandatory) in
-- a number of cases:
-- o When the high-level/low-level types don't match, in which case a
-- straight import would risk wrong code generation or compiler blowups in
-- the Hard binding case. This is the case for 'B' in the example above.
-- o When the high-level/low-level argument lists differ, as is the case
-- for most of the AltiVec predicates, relying on a low-level primitive
-- which expects a control code argument, like:
-- function vec_any_ne
-- (A : vector_signed_int;
-- B : vector_signed_int) return c_int is
-- begin
-- return vcmpequw_p (CR6_LT_REV, To_VSI (A), To_VSI (B));
-- end vec_any_ne;
-- o When the high-level/low-level arguments order don't match, as in:
-- function vec_cmplt
-- (A : vector_unsigned_char;
-- B : vector_unsigned_char) return vector_bool_char is
-- begin
-- return To_VBC (vcmpgtub (To_VSC (B), To_VSC (A)));
-- end vec_cmplt;
-----------------------------
-- Inlining Considerations --
-----------------------------
-- The intent in the hard binding case is to eventually map operations to
-- hardware instructions. Needless to say, intermediate function calls do
-- not fit this purpose, so all user visible subprograms need to be marked
-- Inline_Always. Some of the builtins we eventually bind to expect literal
-- arguments. Wrappers to such builtins are made Convention Intrinsic as
-- well so we don't attempt to compile the bodies on their own.
-- In the soft case, the bulk of the work is performed by the low level
-- routines, and those exported by this unit are short enough for the
-- inlining to make sense and even be beneficial.
-------------------------------------------------------
-- [PIM-4.4 Generic and Specific AltiVec operations] --
-------------------------------------------------------
-------------
-- vec_abs --
-------------
function vec_abs
(A : vector_signed_char) return vector_signed_char;
function vec_abs
(A : vector_signed_short) return vector_signed_short;
function vec_abs
(A : vector_signed_int) return vector_signed_int;
function vec_abs
(A : vector_float) return vector_float;
--------------
-- vec_abss --
--------------
function vec_abss
(A : vector_signed_char) return vector_signed_char;
function vec_abss
(A : vector_signed_short) return vector_signed_short;
function vec_abss
(A : vector_signed_int) return vector_signed_int;
-------------
-- vec_add --
-------------
function vec_add
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_add
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_add
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_add
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_add
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_add
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_add
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_add
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_add
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_add
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_add
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_add
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_add
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_add
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_add
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_add
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_add
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_add
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_add
(A : vector_float;
B : vector_float) return vector_float;
----------------
-- vec_vaddfp --
----------------
function vec_vaddfp
(A : vector_float;
B : vector_float) return vector_float;
-----------------
-- vec_vadduwm --
-----------------
function vec_vadduwm
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_vadduwm
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_vadduwm
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_vadduwm
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vadduwm
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_vadduwm
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
-----------------
-- vec_vadduhm --
-----------------
function vec_vadduhm
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_vadduhm
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_vadduhm
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_vadduhm
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vadduhm
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_vadduhm
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
-----------------
-- vec_vaddubm --
-----------------
function vec_vaddubm
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_vaddubm
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_vaddubm
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_vaddubm
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_vaddubm
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_vaddubm
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
--------------
-- vec_addc --
--------------
function vec_addc
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_adds --
--------------
function vec_adds
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_adds
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_adds
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_adds
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_adds
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_adds
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_adds
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_adds
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_adds
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_adds
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_adds
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_adds
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_adds
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_adds
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_adds
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_adds
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_adds
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_adds
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
-----------------
-- vec_vaddsws --
-----------------
function vec_vaddsws
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_vaddsws
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_vaddsws
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
-----------------
-- vec_vadduws --
-----------------
function vec_vadduws
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vadduws
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_vadduws
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
-----------------
-- vec_vaddshs --
-----------------
function vec_vaddshs
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_vaddshs
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_vaddshs
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
-----------------
-- vec_vadduhs --
-----------------
function vec_vadduhs
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vadduhs
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_vadduhs
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
-----------------
-- vec_vaddsbs --
-----------------
function vec_vaddsbs
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_vaddsbs
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_vaddsbs
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
-----------------
-- vec_vaddubs --
-----------------
function vec_vaddubs
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_vaddubs
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_vaddubs
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
-------------
-- vec_and --
-------------
function vec_and
(A : vector_float;
B : vector_float) return vector_float;
function vec_and
(A : vector_float;
B : vector_bool_int) return vector_float;
function vec_and
(A : vector_bool_int;
B : vector_float) return vector_float;
function vec_and
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_and
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_and
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_and
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_and
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_and
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_and
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_and
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_and
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_and
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_and
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_and
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_and
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_and
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_and
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_and
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_and
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_and
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_and
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_and
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_and
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
--------------
-- vec_andc --
--------------
function vec_andc
(A : vector_float;
B : vector_float) return vector_float;
function vec_andc
(A : vector_float;
B : vector_bool_int) return vector_float;
function vec_andc
(A : vector_bool_int;
B : vector_float) return vector_float;
function vec_andc
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_andc
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_andc
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_andc
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_andc
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_andc
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_andc
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_andc
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_andc
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_andc
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_andc
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_andc
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_andc
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_andc
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_andc
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_andc
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_andc
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_andc
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_andc
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_andc
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_andc
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
-------------
-- vec_avg --
-------------
function vec_avg
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_avg
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_avg
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_avg
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_avg
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_avg
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
----------------
-- vec_vavgsw --
----------------
function vec_vavgsw
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
----------------
-- vec_vavguw --
----------------
function vec_vavguw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
----------------
-- vec_vavgsh --
----------------
function vec_vavgsh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
----------------
-- vec_vavguh --
----------------
function vec_vavguh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
----------------
-- vec_vavgsb --
----------------
function vec_vavgsb
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
----------------
-- vec_vavgub --
----------------
function vec_vavgub
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
--------------
-- vec_ceil --
--------------
function vec_ceil
(A : vector_float) return vector_float;
--------------
-- vec_cmpb --
--------------
function vec_cmpb
(A : vector_float;
B : vector_float) return vector_signed_int;
function vec_cmpeq
(A : vector_signed_char;
B : vector_signed_char) return vector_bool_char;
function vec_cmpeq
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_bool_char;
function vec_cmpeq
(A : vector_signed_short;
B : vector_signed_short) return vector_bool_short;
function vec_cmpeq
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_bool_short;
function vec_cmpeq
(A : vector_signed_int;
B : vector_signed_int) return vector_bool_int;
function vec_cmpeq
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_bool_int;
function vec_cmpeq
(A : vector_float;
B : vector_float) return vector_bool_int;
------------------
-- vec_vcmpeqfp --
------------------
function vec_vcmpeqfp
(A : vector_float;
B : vector_float) return vector_bool_int;
------------------
-- vec_vcmpequw --
------------------
function vec_vcmpequw
(A : vector_signed_int;
B : vector_signed_int) return vector_bool_int;
function vec_vcmpequw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_bool_int;
------------------
-- vec_vcmpequh --
------------------
function vec_vcmpequh
(A : vector_signed_short;
B : vector_signed_short) return vector_bool_short;
function vec_vcmpequh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_bool_short;
------------------
-- vec_vcmpequb --
------------------
function vec_vcmpequb
(A : vector_signed_char;
B : vector_signed_char) return vector_bool_char;
function vec_vcmpequb
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_bool_char;
---------------
-- vec_cmpge --
---------------
function vec_cmpge
(A : vector_float;
B : vector_float) return vector_bool_int;
---------------
-- vec_cmpgt --
---------------
function vec_cmpgt
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_bool_char;
function vec_cmpgt
(A : vector_signed_char;
B : vector_signed_char) return vector_bool_char;
function vec_cmpgt
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_bool_short;
function vec_cmpgt
(A : vector_signed_short;
B : vector_signed_short) return vector_bool_short;
function vec_cmpgt
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_bool_int;
function vec_cmpgt
(A : vector_signed_int;
B : vector_signed_int) return vector_bool_int;
function vec_cmpgt
(A : vector_float;
B : vector_float) return vector_bool_int;
------------------
-- vec_vcmpgtfp --
------------------
function vec_vcmpgtfp
(A : vector_float;
B : vector_float) return vector_bool_int;
------------------
-- vec_vcmpgtsw --
------------------
function vec_vcmpgtsw
(A : vector_signed_int;
B : vector_signed_int) return vector_bool_int;
------------------
-- vec_vcmpgtuw --
------------------
function vec_vcmpgtuw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_bool_int;
------------------
-- vec_vcmpgtsh --
------------------
function vec_vcmpgtsh
(A : vector_signed_short;
B : vector_signed_short) return vector_bool_short;
------------------
-- vec_vcmpgtuh --
------------------
function vec_vcmpgtuh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_bool_short;
------------------
-- vec_vcmpgtsb --
------------------
function vec_vcmpgtsb
(A : vector_signed_char;
B : vector_signed_char) return vector_bool_char;
------------------
-- vec_vcmpgtub --
------------------
function vec_vcmpgtub
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_bool_char;
---------------
-- vec_cmple --
---------------
function vec_cmple
(A : vector_float;
B : vector_float) return vector_bool_int;
---------------
-- vec_cmplt --
---------------
function vec_cmplt
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_bool_char;
function vec_cmplt
(A : vector_signed_char;
B : vector_signed_char) return vector_bool_char;
function vec_cmplt
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_bool_short;
function vec_cmplt
(A : vector_signed_short;
B : vector_signed_short) return vector_bool_short;
function vec_cmplt
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_bool_int;
function vec_cmplt
(A : vector_signed_int;
B : vector_signed_int) return vector_bool_int;
function vec_cmplt
(A : vector_float;
B : vector_float) return vector_bool_int;
---------------
-- vec_vcfsx --
---------------
function vec_vcfsx
(A : vector_signed_int;
B : c_int) return vector_float
renames Low_Level_Vectors.vcfsx;
---------------
-- vec_vcfux --
---------------
function vec_vcfux
(A : vector_unsigned_int;
B : c_int) return vector_float
renames Low_Level_Vectors.vcfux;
----------------
-- vec_vctsxs --
----------------
function vec_vctsxs
(A : vector_float;
B : c_int) return vector_signed_int
renames Low_Level_Vectors.vctsxs;
----------------
-- vec_vctuxs --
----------------
function vec_vctuxs
(A : vector_float;
B : c_int) return vector_unsigned_int
renames Low_Level_Vectors.vctuxs;
-------------
-- vec_dss --
-------------
procedure vec_dss
(A : c_int)
renames Low_Level_Vectors.dss;
----------------
-- vec_dssall --
----------------
procedure vec_dssall
renames Low_Level_Vectors.dssall;
-------------
-- vec_dst --
-------------
procedure vec_dst
(A : const_vector_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_bool_char_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_signed_short_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_bool_short_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_pixel_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_signed_int_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_bool_int_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_vector_float_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_short_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_int_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_unsigned_long_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_long_ptr;
B : c_int;
C : c_int);
procedure vec_dst
(A : const_float_ptr;
B : c_int;
C : c_int);
pragma Inline_Always (vec_dst);
pragma Convention (Intrinsic, vec_dst);
---------------
-- vec_dstst --
---------------
procedure vec_dstst
(A : const_vector_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_bool_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_signed_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_bool_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_pixel_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_signed_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_bool_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_vector_float_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_unsigned_long_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_long_ptr;
B : c_int;
C : c_int);
procedure vec_dstst
(A : const_float_ptr;
B : c_int;
C : c_int);
pragma Inline_Always (vec_dstst);
pragma Convention (Intrinsic, vec_dstst);
----------------
-- vec_dststt --
----------------
procedure vec_dststt
(A : const_vector_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_bool_char_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_signed_short_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_bool_short_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_pixel_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_signed_int_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_bool_int_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_vector_float_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_short_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_int_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_unsigned_long_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_long_ptr;
B : c_int;
C : c_int);
procedure vec_dststt
(A : const_float_ptr;
B : c_int;
C : c_int);
pragma Inline_Always (vec_dststt);
pragma Convention (Intrinsic, vec_dststt);
--------------
-- vec_dstt --
--------------
procedure vec_dstt
(A : const_vector_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_bool_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_signed_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_bool_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_pixel_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_signed_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_bool_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_vector_float_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_unsigned_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_signed_char_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_unsigned_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_short_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_unsigned_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_int_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_unsigned_long_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_long_ptr;
B : c_int;
C : c_int);
procedure vec_dstt
(A : const_float_ptr;
B : c_int;
C : c_int);
pragma Inline_Always (vec_dstt);
pragma Convention (Intrinsic, vec_dstt);
---------------
-- vec_expte --
---------------
function vec_expte
(A : vector_float) return vector_float;
---------------
-- vec_floor --
---------------
function vec_floor
(A : vector_float) return vector_float;
------------
-- vec_ld --
------------
function vec_ld
(A : c_long;
B : const_vector_float_ptr) return vector_float;
function vec_ld
(A : c_long;
B : const_float_ptr) return vector_float;
function vec_ld
(A : c_long;
B : const_vector_bool_int_ptr) return vector_bool_int;
function vec_ld
(A : c_long;
B : const_vector_signed_int_ptr) return vector_signed_int;
function vec_ld
(A : c_long;
B : const_int_ptr) return vector_signed_int;
function vec_ld
(A : c_long;
B : const_long_ptr) return vector_signed_int;
function vec_ld
(A : c_long;
B : const_vector_unsigned_int_ptr) return vector_unsigned_int;
function vec_ld
(A : c_long;
B : const_unsigned_int_ptr) return vector_unsigned_int;
function vec_ld
(A : c_long;
B : const_unsigned_long_ptr) return vector_unsigned_int;
function vec_ld
(A : c_long;
B : const_vector_bool_short_ptr) return vector_bool_short;
function vec_ld
(A : c_long;
B : const_vector_pixel_ptr) return vector_pixel;
function vec_ld
(A : c_long;
B : const_vector_signed_short_ptr) return vector_signed_short;
function vec_ld
(A : c_long;
B : const_short_ptr) return vector_signed_short;
function vec_ld
(A : c_long;
B : const_vector_unsigned_short_ptr) return vector_unsigned_short;
function vec_ld
(A : c_long;
B : const_unsigned_short_ptr) return vector_unsigned_short;
function vec_ld
(A : c_long;
B : const_vector_bool_char_ptr) return vector_bool_char;
function vec_ld
(A : c_long;
B : const_vector_signed_char_ptr) return vector_signed_char;
function vec_ld
(A : c_long;
B : const_signed_char_ptr) return vector_signed_char;
function vec_ld
(A : c_long;
B : const_vector_unsigned_char_ptr) return vector_unsigned_char;
function vec_ld
(A : c_long;
B : const_unsigned_char_ptr) return vector_unsigned_char;
-------------
-- vec_lde --
-------------
function vec_lde
(A : c_long;
B : const_signed_char_ptr) return vector_signed_char;
function vec_lde
(A : c_long;
B : const_unsigned_char_ptr) return vector_unsigned_char;
function vec_lde
(A : c_long;
B : const_short_ptr) return vector_signed_short;
function vec_lde
(A : c_long;
B : const_unsigned_short_ptr) return vector_unsigned_short;
function vec_lde
(A : c_long;
B : const_float_ptr) return vector_float;
function vec_lde
(A : c_long;
B : const_int_ptr) return vector_signed_int;
function vec_lde
(A : c_long;
B : const_unsigned_int_ptr) return vector_unsigned_int;
function vec_lde
(A : c_long;
B : const_long_ptr) return vector_signed_int;
function vec_lde
(A : c_long;
B : const_unsigned_long_ptr) return vector_unsigned_int;
---------------
-- vec_lvewx --
---------------
function vec_lvewx
(A : c_long;
B : float_ptr) return vector_float;
function vec_lvewx
(A : c_long;
B : int_ptr) return vector_signed_int;
function vec_lvewx
(A : c_long;
B : unsigned_int_ptr) return vector_unsigned_int;
function vec_lvewx
(A : c_long;
B : long_ptr) return vector_signed_int;
function vec_lvewx
(A : c_long;
B : unsigned_long_ptr) return vector_unsigned_int;
---------------
-- vec_lvehx --
---------------
function vec_lvehx
(A : c_long;
B : short_ptr) return vector_signed_short;
function vec_lvehx
(A : c_long;
B : unsigned_short_ptr) return vector_unsigned_short;
---------------
-- vec_lvebx --
---------------
function vec_lvebx
(A : c_long;
B : signed_char_ptr) return vector_signed_char;
function vec_lvebx
(A : c_long;
B : unsigned_char_ptr) return vector_unsigned_char;
-------------
-- vec_ldl --
-------------
function vec_ldl
(A : c_long;
B : const_vector_float_ptr) return vector_float;
function vec_ldl
(A : c_long;
B : const_float_ptr) return vector_float;
function vec_ldl
(A : c_long;
B : const_vector_bool_int_ptr) return vector_bool_int;
function vec_ldl
(A : c_long;
B : const_vector_signed_int_ptr) return vector_signed_int;
function vec_ldl
(A : c_long;
B : const_int_ptr) return vector_signed_int;
function vec_ldl
(A : c_long;
B : const_long_ptr) return vector_signed_int;
function vec_ldl
(A : c_long;
B : const_vector_unsigned_int_ptr) return vector_unsigned_int;
function vec_ldl
(A : c_long;
B : const_unsigned_int_ptr) return vector_unsigned_int;
function vec_ldl
(A : c_long;
B : const_unsigned_long_ptr) return vector_unsigned_int;
function vec_ldl
(A : c_long;
B : const_vector_bool_short_ptr) return vector_bool_short;
function vec_ldl
(A : c_long;
B : const_vector_pixel_ptr) return vector_pixel;
function vec_ldl
(A : c_long;
B : const_vector_signed_short_ptr) return vector_signed_short;
function vec_ldl
(A : c_long;
B : const_short_ptr) return vector_signed_short;
function vec_ldl
(A : c_long;
B : const_vector_unsigned_short_ptr) return vector_unsigned_short;
function vec_ldl
(A : c_long;
B : const_unsigned_short_ptr) return vector_unsigned_short;
function vec_ldl
(A : c_long;
B : const_vector_bool_char_ptr) return vector_bool_char;
function vec_ldl
(A : c_long;
B : const_vector_signed_char_ptr) return vector_signed_char;
function vec_ldl
(A : c_long;
B : const_signed_char_ptr) return vector_signed_char;
function vec_ldl
(A : c_long;
B : const_vector_unsigned_char_ptr) return vector_unsigned_char;
function vec_ldl
(A : c_long;
B : const_unsigned_char_ptr) return vector_unsigned_char;
--------------
-- vec_loge --
--------------
function vec_loge
(A : vector_float) return vector_float;
--------------
-- vec_lvsl --
--------------
function vec_lvsl
(A : c_long;
B : constv_unsigned_char_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_signed_char_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_unsigned_short_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_short_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_unsigned_int_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_int_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_unsigned_long_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_long_ptr) return vector_unsigned_char;
function vec_lvsl
(A : c_long;
B : constv_float_ptr) return vector_unsigned_char;
--------------
-- vec_lvsr --
--------------
function vec_lvsr
(A : c_long;
B : constv_unsigned_char_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_signed_char_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_unsigned_short_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_short_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_unsigned_int_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_int_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_unsigned_long_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_long_ptr) return vector_unsigned_char;
function vec_lvsr
(A : c_long;
B : constv_float_ptr) return vector_unsigned_char;
--------------
-- vec_madd --
--------------
function vec_madd
(A : vector_float;
B : vector_float;
C : vector_float) return vector_float;
---------------
-- vec_madds --
---------------
function vec_madds
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short;
-------------
-- vec_max --
-------------
function vec_max
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_max
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_max
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_max
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_max
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_max
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_max
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_max
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_max
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_max
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_max
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_max
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_max
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_max
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_max
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_max
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_max
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_max
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_max
(A : vector_float;
B : vector_float) return vector_float;
----------------
-- vec_vmaxfp --
----------------
function vec_vmaxfp
(A : vector_float;
B : vector_float) return vector_float;
----------------
-- vec_vmaxsw --
----------------
function vec_vmaxsw
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_vmaxsw
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_vmaxsw
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
----------------
-- vec_vmaxuw --
----------------
function vec_vmaxuw
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vmaxuw
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_vmaxuw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
----------------
-- vec_vmaxsh --
----------------
function vec_vmaxsh
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_vmaxsh
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_vmaxsh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
----------------
-- vec_vmaxuh --
----------------
function vec_vmaxuh
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vmaxuh
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_vmaxuh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
----------------
-- vec_vmaxsb --
----------------
function vec_vmaxsb
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_vmaxsb
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_vmaxsb
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
----------------
-- vec_vmaxub --
----------------
function vec_vmaxub
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_vmaxub
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_vmaxub
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
----------------
-- vec_mergeh --
----------------
function vec_mergeh
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_mergeh
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_mergeh
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_mergeh
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_mergeh
(A : vector_pixel;
B : vector_pixel) return vector_pixel;
function vec_mergeh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_mergeh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_mergeh
(A : vector_float;
B : vector_float) return vector_float;
function vec_mergeh
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_mergeh
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_mergeh
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
----------------
-- vec_vmrghw --
----------------
function vec_vmrghw
(A : vector_float;
B : vector_float) return vector_float;
function vec_vmrghw
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_vmrghw
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_vmrghw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
----------------
-- vec_vmrghh --
----------------
function vec_vmrghh
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_vmrghh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_vmrghh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vmrghh
(A : vector_pixel;
B : vector_pixel) return vector_pixel;
----------------
-- vec_vmrghb --
----------------
function vec_vmrghb
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_vmrghb
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_vmrghb
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
----------------
-- vec_mergel --
----------------
function vec_mergel
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_mergel
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_mergel
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_mergel
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_mergel
(A : vector_pixel;
B : vector_pixel) return vector_pixel;
function vec_mergel
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_mergel
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_mergel
(A : vector_float;
B : vector_float) return vector_float;
function vec_mergel
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_mergel
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_mergel
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
----------------
-- vec_vmrglw --
----------------
function vec_vmrglw
(A : vector_float;
B : vector_float) return vector_float;
function vec_vmrglw
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_vmrglw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vmrglw
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
----------------
-- vec_vmrglh --
----------------
function vec_vmrglh
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_vmrglh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_vmrglh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vmrglh
(A : vector_pixel;
B : vector_pixel) return vector_pixel;
----------------
-- vec_vmrglb --
----------------
function vec_vmrglb
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_vmrglb
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_vmrglb
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
----------------
-- vec_mfvscr --
----------------
function vec_mfvscr return vector_unsigned_short;
-------------
-- vec_min --
-------------
function vec_min
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_min
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_min
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_min
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_min
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_min
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_min
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_min
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_min
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_min
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_min
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_min
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_min
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_min
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_min
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_min
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_min
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_min
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_min
(A : vector_float;
B : vector_float) return vector_float;
----------------
-- vec_vminfp --
----------------
function vec_vminfp
(A : vector_float;
B : vector_float) return vector_float;
----------------
-- vec_vminsw --
----------------
function vec_vminsw
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_vminsw
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_vminsw
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
----------------
-- vec_vminuw --
----------------
function vec_vminuw
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vminuw
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_vminuw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
----------------
-- vec_vminsh --
----------------
function vec_vminsh
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_vminsh
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_vminsh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
----------------
-- vec_vminuh --
----------------
function vec_vminuh
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vminuh
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_vminuh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
----------------
-- vec_vminsb --
----------------
function vec_vminsb
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_vminsb
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_vminsb
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
----------------
-- vec_vminub --
----------------
function vec_vminub
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_vminub
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_vminub
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
---------------
-- vec_mladd --
---------------
function vec_mladd
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short;
function vec_mladd
(A : vector_signed_short;
B : vector_unsigned_short;
C : vector_unsigned_short) return vector_signed_short;
function vec_mladd
(A : vector_unsigned_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short;
function vec_mladd
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_short) return vector_unsigned_short;
----------------
-- vec_mradds --
----------------
function vec_mradds
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short;
--------------
-- vec_msum --
--------------
function vec_msum
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_unsigned_int) return vector_unsigned_int;
function vec_msum
(A : vector_signed_char;
B : vector_unsigned_char;
C : vector_signed_int) return vector_signed_int;
function vec_msum
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_int) return vector_unsigned_int;
function vec_msum
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_int) return vector_signed_int;
------------------
-- vec_vmsumshm --
------------------
function vec_vmsumshm
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_int) return vector_signed_int;
------------------
-- vec_vmsumuhm --
------------------
function vec_vmsumuhm
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_int) return vector_unsigned_int;
------------------
-- vec_vmsummbm --
------------------
function vec_vmsummbm
(A : vector_signed_char;
B : vector_unsigned_char;
C : vector_signed_int) return vector_signed_int;
------------------
-- vec_vmsumubm --
------------------
function vec_vmsumubm
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_unsigned_int) return vector_unsigned_int;
---------------
-- vec_msums --
---------------
function vec_msums
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_int) return vector_unsigned_int;
function vec_msums
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_int) return vector_signed_int;
function vec_vmsumshs
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_int) return vector_signed_int;
------------------
-- vec_vmsumuhs --
------------------
function vec_vmsumuhs
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_int) return vector_unsigned_int;
----------------
-- vec_mtvscr --
----------------
procedure vec_mtvscr
(A : vector_signed_int);
procedure vec_mtvscr
(A : vector_unsigned_int);
procedure vec_mtvscr
(A : vector_bool_int);
procedure vec_mtvscr
(A : vector_signed_short);
procedure vec_mtvscr
(A : vector_unsigned_short);
procedure vec_mtvscr
(A : vector_bool_short);
procedure vec_mtvscr
(A : vector_pixel);
procedure vec_mtvscr
(A : vector_signed_char);
procedure vec_mtvscr
(A : vector_unsigned_char);
procedure vec_mtvscr
(A : vector_bool_char);
--------------
-- vec_mule --
--------------
function vec_mule
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_short;
function vec_mule
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_short;
function vec_mule
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_int;
function vec_mule
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_int;
-----------------
-- vec_vmulesh --
-----------------
function vec_vmulesh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_int;
-----------------
-- vec_vmuleuh --
-----------------
function vec_vmuleuh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_int;
-----------------
-- vec_vmulesb --
-----------------
function vec_vmulesb
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_short;
-----------------
-- vec_vmuleub --
-----------------
function vec_vmuleub
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_short;
--------------
-- vec_mulo --
--------------
function vec_mulo
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_short;
function vec_mulo
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_short;
function vec_mulo
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_int;
function vec_mulo
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_int;
-----------------
-- vec_vmulosh --
-----------------
function vec_vmulosh
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_int;
-----------------
-- vec_vmulouh --
-----------------
function vec_vmulouh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_int;
-----------------
-- vec_vmulosb --
-----------------
function vec_vmulosb
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_short;
-----------------
-- vec_vmuloub --
-----------------
function vec_vmuloub
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_short;
---------------
-- vec_nmsub --
---------------
function vec_nmsub
(A : vector_float;
B : vector_float;
C : vector_float) return vector_float;
-------------
-- vec_nor --
-------------
function vec_nor
(A : vector_float;
B : vector_float) return vector_float;
function vec_nor
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_nor
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_nor
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_nor
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_nor
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_nor
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_nor
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_nor
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_nor
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
------------
-- vec_or --
------------
function vec_or
(A : vector_float;
B : vector_float) return vector_float;
function vec_or
(A : vector_float;
B : vector_bool_int) return vector_float;
function vec_or
(A : vector_bool_int;
B : vector_float) return vector_float;
function vec_or
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_or
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_or
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_or
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_or
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_or
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_or
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_or
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_or
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_or
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_or
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_or
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_or
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_or
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_or
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_or
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_or
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_or
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_or
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_or
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_or
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
--------------
-- vec_pack --
--------------
function vec_pack
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_char;
function vec_pack
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_char;
function vec_pack
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_char;
function vec_pack
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_short;
function vec_pack
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_short;
function vec_pack
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_short;
-----------------
-- vec_vpkuwum --
-----------------
function vec_vpkuwum
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_short;
function vec_vpkuwum
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_short;
function vec_vpkuwum
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_short;
-----------------
-- vec_vpkuhum --
-----------------
function vec_vpkuhum
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_char;
function vec_vpkuhum
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_char;
function vec_vpkuhum
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_char;
----------------
-- vec_packpx --
----------------
function vec_packpx
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_pixel;
---------------
-- vec_packs --
---------------
function vec_packs
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_char;
function vec_packs
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_char;
function vec_packs
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_short;
function vec_packs
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_short;
-----------------
-- vec_vpkswss --
-----------------
function vec_vpkswss
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_short;
-----------------
-- vec_vpkuwus --
-----------------
function vec_vpkuwus
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_short;
-----------------
-- vec_vpkshss --
-----------------
function vec_vpkshss
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_char;
-----------------
-- vec_vpkuhus --
-----------------
function vec_vpkuhus
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_char;
----------------
-- vec_packsu --
----------------
function vec_packsu
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_char;
function vec_packsu
(A : vector_signed_short;
B : vector_signed_short) return vector_unsigned_char;
function vec_packsu
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_short;
function vec_packsu
(A : vector_signed_int;
B : vector_signed_int) return vector_unsigned_short;
-----------------
-- vec_vpkswus --
-----------------
function vec_vpkswus
(A : vector_signed_int;
B : vector_signed_int) return vector_unsigned_short;
-----------------
-- vec_vpkshus --
-----------------
function vec_vpkshus
(A : vector_signed_short;
B : vector_signed_short) return vector_unsigned_char;
--------------
-- vec_perm --
--------------
function vec_perm
(A : vector_float;
B : vector_float;
C : vector_unsigned_char) return vector_float;
function vec_perm
(A : vector_signed_int;
B : vector_signed_int;
C : vector_unsigned_char) return vector_signed_int;
function vec_perm
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : vector_unsigned_char) return vector_unsigned_int;
function vec_perm
(A : vector_bool_int;
B : vector_bool_int;
C : vector_unsigned_char) return vector_bool_int;
function vec_perm
(A : vector_signed_short;
B : vector_signed_short;
C : vector_unsigned_char) return vector_signed_short;
function vec_perm
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_char) return vector_unsigned_short;
function vec_perm
(A : vector_bool_short;
B : vector_bool_short;
C : vector_unsigned_char) return vector_bool_short;
function vec_perm
(A : vector_pixel;
B : vector_pixel;
C : vector_unsigned_char) return vector_pixel;
function vec_perm
(A : vector_signed_char;
B : vector_signed_char;
C : vector_unsigned_char) return vector_signed_char;
function vec_perm
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_unsigned_char) return vector_unsigned_char;
function vec_perm
(A : vector_bool_char;
B : vector_bool_char;
C : vector_unsigned_char) return vector_bool_char;
------------
-- vec_re --
------------
function vec_re
(A : vector_float) return vector_float;
------------
-- vec_rl --
------------
function vec_rl
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_rl
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_rl
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_rl
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_rl
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_rl
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_vrlw --
--------------
function vec_vrlw
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_vrlw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_vrlh --
--------------
function vec_vrlh
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_vrlh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
--------------
-- vec_vrlb --
--------------
function vec_vrlb
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_vrlb
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
---------------
-- vec_round --
---------------
function vec_round
(A : vector_float) return vector_float;
----------------
-- vec_rsqrte --
----------------
function vec_rsqrte
(A : vector_float) return vector_float;
-------------
-- vec_sel --
-------------
function vec_sel
(A : vector_float;
B : vector_float;
C : vector_bool_int) return vector_float;
function vec_sel
(A : vector_float;
B : vector_float;
C : vector_unsigned_int) return vector_float;
function vec_sel
(A : vector_signed_int;
B : vector_signed_int;
C : vector_bool_int) return vector_signed_int;
function vec_sel
(A : vector_signed_int;
B : vector_signed_int;
C : vector_unsigned_int) return vector_signed_int;
function vec_sel
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : vector_bool_int) return vector_unsigned_int;
function vec_sel
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : vector_unsigned_int) return vector_unsigned_int;
function vec_sel
(A : vector_bool_int;
B : vector_bool_int;
C : vector_bool_int) return vector_bool_int;
function vec_sel
(A : vector_bool_int;
B : vector_bool_int;
C : vector_unsigned_int) return vector_bool_int;
function vec_sel
(A : vector_signed_short;
B : vector_signed_short;
C : vector_bool_short) return vector_signed_short;
function vec_sel
(A : vector_signed_short;
B : vector_signed_short;
C : vector_unsigned_short) return vector_signed_short;
function vec_sel
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_bool_short) return vector_unsigned_short;
function vec_sel
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_short) return vector_unsigned_short;
function vec_sel
(A : vector_bool_short;
B : vector_bool_short;
C : vector_bool_short) return vector_bool_short;
function vec_sel
(A : vector_bool_short;
B : vector_bool_short;
C : vector_unsigned_short) return vector_bool_short;
function vec_sel
(A : vector_signed_char;
B : vector_signed_char;
C : vector_bool_char) return vector_signed_char;
function vec_sel
(A : vector_signed_char;
B : vector_signed_char;
C : vector_unsigned_char) return vector_signed_char;
function vec_sel
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_bool_char) return vector_unsigned_char;
function vec_sel
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_unsigned_char) return vector_unsigned_char;
function vec_sel
(A : vector_bool_char;
B : vector_bool_char;
C : vector_bool_char) return vector_bool_char;
function vec_sel
(A : vector_bool_char;
B : vector_bool_char;
C : vector_unsigned_char) return vector_bool_char;
------------
-- vec_sl --
------------
function vec_sl
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_sl
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_sl
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_sl
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_sl
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_sl
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_vslw --
--------------
function vec_vslw
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_vslw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_vslh --
--------------
function vec_vslh
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_vslh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
--------------
-- vec_vslb --
--------------
function vec_vslb
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_vslb
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
-------------
-- vec_sld --
-------------
function vec_sld
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : c_int) return vector_unsigned_int;
function vec_sld
(A : vector_bool_int;
B : vector_bool_int;
C : c_int) return vector_bool_int;
function vec_sld
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : c_int) return vector_unsigned_short;
function vec_sld
(A : vector_bool_short;
B : vector_bool_short;
C : c_int) return vector_bool_short;
function vec_sld
(A : vector_pixel;
B : vector_pixel;
C : c_int) return vector_pixel;
function vec_sld
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : c_int) return vector_unsigned_char;
function vec_sld
(A : vector_bool_char;
B : vector_bool_char;
C : c_int) return vector_bool_char;
pragma Inline_Always (vec_sld);
pragma Convention (Intrinsic, vec_sld);
function vec_sld
(A : vector_float;
B : vector_float;
C : c_int) return vector_float
renames Low_Level_Vectors.vsldoi_4sf;
function vec_sld
(A : vector_signed_int;
B : vector_signed_int;
C : c_int) return vector_signed_int
renames Low_Level_Vectors.vsldoi_4si;
function vec_sld
(A : vector_signed_short;
B : vector_signed_short;
C : c_int) return vector_signed_short
renames Low_Level_Vectors.vsldoi_8hi;
function vec_sld
(A : vector_signed_char;
B : vector_signed_char;
C : c_int) return vector_signed_char
renames Low_Level_Vectors.vsldoi_16qi;
-------------
-- vec_sll --
-------------
function vec_sll
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_sll
(A : vector_signed_int;
B : vector_unsigned_short) return vector_signed_int;
function vec_sll
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int;
function vec_sll
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_sll
(A : vector_unsigned_int;
B : vector_unsigned_short) return vector_unsigned_int;
function vec_sll
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int;
function vec_sll
(A : vector_bool_int;
B : vector_unsigned_int) return vector_bool_int;
function vec_sll
(A : vector_bool_int;
B : vector_unsigned_short) return vector_bool_int;
function vec_sll
(A : vector_bool_int;
B : vector_unsigned_char) return vector_bool_int;
function vec_sll
(A : vector_signed_short;
B : vector_unsigned_int) return vector_signed_short;
function vec_sll
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_sll
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short;
function vec_sll
(A : vector_unsigned_short;
B : vector_unsigned_int) return vector_unsigned_short;
function vec_sll
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_sll
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short;
function vec_sll
(A : vector_bool_short;
B : vector_unsigned_int) return vector_bool_short;
function vec_sll
(A : vector_bool_short;
B : vector_unsigned_short) return vector_bool_short;
function vec_sll
(A : vector_bool_short;
B : vector_unsigned_char) return vector_bool_short;
function vec_sll
(A : vector_pixel;
B : vector_unsigned_int) return vector_pixel;
function vec_sll
(A : vector_pixel;
B : vector_unsigned_short) return vector_pixel;
function vec_sll
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel;
function vec_sll
(A : vector_signed_char;
B : vector_unsigned_int) return vector_signed_char;
function vec_sll
(A : vector_signed_char;
B : vector_unsigned_short) return vector_signed_char;
function vec_sll
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_sll
(A : vector_unsigned_char;
B : vector_unsigned_int) return vector_unsigned_char;
function vec_sll
(A : vector_unsigned_char;
B : vector_unsigned_short) return vector_unsigned_char;
function vec_sll
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_sll
(A : vector_bool_char;
B : vector_unsigned_int) return vector_bool_char;
function vec_sll
(A : vector_bool_char;
B : vector_unsigned_short) return vector_bool_char;
function vec_sll
(A : vector_bool_char;
B : vector_unsigned_char) return vector_bool_char;
-------------
-- vec_slo --
-------------
function vec_slo
(A : vector_float;
B : vector_signed_char) return vector_float;
function vec_slo
(A : vector_float;
B : vector_unsigned_char) return vector_float;
function vec_slo
(A : vector_signed_int;
B : vector_signed_char) return vector_signed_int;
function vec_slo
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int;
function vec_slo
(A : vector_unsigned_int;
B : vector_signed_char) return vector_unsigned_int;
function vec_slo
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int;
function vec_slo
(A : vector_signed_short;
B : vector_signed_char) return vector_signed_short;
function vec_slo
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short;
function vec_slo
(A : vector_unsigned_short;
B : vector_signed_char) return vector_unsigned_short;
function vec_slo
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short;
function vec_slo
(A : vector_pixel;
B : vector_signed_char) return vector_pixel;
function vec_slo
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel;
function vec_slo
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_slo
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_slo
(A : vector_unsigned_char;
B : vector_signed_char) return vector_unsigned_char;
function vec_slo
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
----------------
-- vec_vspltw --
----------------
function vec_vspltw
(A : vector_float;
B : c_int) return vector_float;
function vec_vspltw
(A : vector_unsigned_int;
B : c_int) return vector_unsigned_int;
function vec_vspltw
(A : vector_bool_int;
B : c_int) return vector_bool_int;
pragma Inline_Always (vec_vspltw);
pragma Convention (Intrinsic, vec_vspltw);
function vec_vspltw
(A : vector_signed_int;
B : c_int) return vector_signed_int
renames Low_Level_Vectors.vspltw;
----------------
-- vec_vsplth --
----------------
function vec_vsplth
(A : vector_bool_short;
B : c_int) return vector_bool_short;
function vec_vsplth
(A : vector_unsigned_short;
B : c_int) return vector_unsigned_short;
function vec_vsplth
(A : vector_pixel;
B : c_int) return vector_pixel;
pragma Inline_Always (vec_vsplth);
pragma Convention (Intrinsic, vec_vsplth);
function vec_vsplth
(A : vector_signed_short;
B : c_int) return vector_signed_short
renames Low_Level_Vectors.vsplth;
----------------
-- vec_vspltb --
----------------
function vec_vspltb
(A : vector_unsigned_char;
B : c_int) return vector_unsigned_char;
function vec_vspltb
(A : vector_bool_char;
B : c_int) return vector_bool_char;
pragma Inline_Always (vec_vspltb);
pragma Convention (Intrinsic, vec_vspltb);
function vec_vspltb
(A : vector_signed_char;
B : c_int) return vector_signed_char
renames Low_Level_Vectors.vspltb;
------------------
-- vec_vspltisb --
------------------
function vec_vspltisb
(A : c_int) return vector_signed_char
renames Low_Level_Vectors.vspltisb;
------------------
-- vec_vspltish --
------------------
function vec_vspltish
(A : c_int) return vector_signed_short
renames Low_Level_Vectors.vspltish;
------------------
-- vec_vspltisw --
------------------
function vec_vspltisw
(A : c_int) return vector_signed_int
renames Low_Level_Vectors.vspltisw;
------------
-- vec_sr --
------------
function vec_sr
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_sr
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_sr
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_sr
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_sr
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_sr
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_vsrw --
--------------
function vec_vsrw
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_vsrw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_vsrh --
--------------
function vec_vsrh
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_vsrh
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
--------------
-- vec_vsrb --
--------------
function vec_vsrb
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_vsrb
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
-------------
-- vec_sra --
-------------
function vec_sra
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_sra
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_sra
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_sra
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_sra
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_sra
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
---------------
-- vec_vsraw --
---------------
function vec_vsraw
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_vsraw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vsrah
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_vsrah
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vsrab
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_vsrab
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
-------------
-- vec_srl --
-------------
function vec_srl
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int;
function vec_srl
(A : vector_signed_int;
B : vector_unsigned_short) return vector_signed_int;
function vec_srl
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int;
function vec_srl
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_srl
(A : vector_unsigned_int;
B : vector_unsigned_short) return vector_unsigned_int;
function vec_srl
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int;
function vec_srl
(A : vector_bool_int;
B : vector_unsigned_int) return vector_bool_int;
function vec_srl
(A : vector_bool_int;
B : vector_unsigned_short) return vector_bool_int;
function vec_srl
(A : vector_bool_int;
B : vector_unsigned_char) return vector_bool_int;
function vec_srl
(A : vector_signed_short;
B : vector_unsigned_int) return vector_signed_short;
function vec_srl
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short;
function vec_srl
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short;
function vec_srl
(A : vector_unsigned_short;
B : vector_unsigned_int) return vector_unsigned_short;
function vec_srl
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_srl
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short;
function vec_srl
(A : vector_bool_short;
B : vector_unsigned_int) return vector_bool_short;
function vec_srl
(A : vector_bool_short;
B : vector_unsigned_short) return vector_bool_short;
function vec_srl
(A : vector_bool_short;
B : vector_unsigned_char) return vector_bool_short;
function vec_srl
(A : vector_pixel;
B : vector_unsigned_int) return vector_pixel;
function vec_srl
(A : vector_pixel;
B : vector_unsigned_short) return vector_pixel;
function vec_srl
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel;
function vec_srl
(A : vector_signed_char;
B : vector_unsigned_int) return vector_signed_char;
function vec_srl
(A : vector_signed_char;
B : vector_unsigned_short) return vector_signed_char;
function vec_srl
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_srl
(A : vector_unsigned_char;
B : vector_unsigned_int) return vector_unsigned_char;
function vec_srl
(A : vector_unsigned_char;
B : vector_unsigned_short) return vector_unsigned_char;
function vec_srl
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_srl
(A : vector_bool_char;
B : vector_unsigned_int) return vector_bool_char;
function vec_srl
(A : vector_bool_char;
B : vector_unsigned_short) return vector_bool_char;
function vec_srl
(A : vector_bool_char;
B : vector_unsigned_char) return vector_bool_char;
function vec_sro
(A : vector_float;
B : vector_signed_char) return vector_float;
function vec_sro
(A : vector_float;
B : vector_unsigned_char) return vector_float;
function vec_sro
(A : vector_signed_int;
B : vector_signed_char) return vector_signed_int;
function vec_sro
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int;
function vec_sro
(A : vector_unsigned_int;
B : vector_signed_char) return vector_unsigned_int;
function vec_sro
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int;
function vec_sro
(A : vector_signed_short;
B : vector_signed_char) return vector_signed_short;
function vec_sro
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short;
function vec_sro
(A : vector_unsigned_short;
B : vector_signed_char) return vector_unsigned_short;
function vec_sro
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short;
function vec_sro
(A : vector_pixel;
B : vector_signed_char) return vector_pixel;
function vec_sro
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel;
function vec_sro
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_sro
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char;
function vec_sro
(A : vector_unsigned_char;
B : vector_signed_char) return vector_unsigned_char;
function vec_sro
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
procedure vec_st
(A : vector_float;
B : c_int;
C : vector_float_ptr);
procedure vec_st
(A : vector_float;
B : c_int;
C : float_ptr);
procedure vec_st
(A : vector_signed_int;
B : c_int;
C : vector_signed_int_ptr);
procedure vec_st
(A : vector_signed_int;
B : c_int;
C : int_ptr);
procedure vec_st
(A : vector_unsigned_int;
B : c_int;
C : vector_unsigned_int_ptr);
procedure vec_st
(A : vector_unsigned_int;
B : c_int;
C : unsigned_int_ptr);
procedure vec_st
(A : vector_bool_int;
B : c_int;
C : vector_bool_int_ptr);
procedure vec_st
(A : vector_bool_int;
B : c_int;
C : unsigned_int_ptr);
procedure vec_st
(A : vector_bool_int;
B : c_int;
C : int_ptr);
procedure vec_st
(A : vector_signed_short;
B : c_int;
C : vector_signed_short_ptr);
procedure vec_st
(A : vector_signed_short;
B : c_int;
C : short_ptr);
procedure vec_st
(A : vector_unsigned_short;
B : c_int;
C : vector_unsigned_short_ptr);
procedure vec_st
(A : vector_unsigned_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_st
(A : vector_bool_short;
B : c_int;
C : vector_bool_short_ptr);
procedure vec_st
(A : vector_bool_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_st
(A : vector_pixel;
B : c_int;
C : vector_pixel_ptr);
procedure vec_st
(A : vector_pixel;
B : c_int;
C : unsigned_short_ptr);
procedure vec_st
(A : vector_pixel;
B : c_int;
C : short_ptr);
procedure vec_st
(A : vector_bool_short;
B : c_int;
C : short_ptr);
procedure vec_st
(A : vector_signed_char;
B : c_int;
C : vector_signed_char_ptr);
procedure vec_st
(A : vector_signed_char;
B : c_int;
C : signed_char_ptr);
procedure vec_st
(A : vector_unsigned_char;
B : c_int;
C : vector_unsigned_char_ptr);
procedure vec_st
(A : vector_unsigned_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_st
(A : vector_bool_char;
B : c_int;
C : vector_bool_char_ptr);
procedure vec_st
(A : vector_bool_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_st
(A : vector_bool_char;
B : c_int;
C : signed_char_ptr);
-------------
-- vec_ste --
-------------
procedure vec_ste
(A : vector_signed_char;
B : c_int;
C : signed_char_ptr);
procedure vec_ste
(A : vector_unsigned_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_ste
(A : vector_bool_char;
B : c_int;
C : signed_char_ptr);
procedure vec_ste
(A : vector_bool_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_ste
(A : vector_signed_short;
B : c_int;
C : short_ptr);
procedure vec_ste
(A : vector_unsigned_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_ste
(A : vector_bool_short;
B : c_int;
C : short_ptr);
procedure vec_ste
(A : vector_bool_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_ste
(A : vector_pixel;
B : c_int;
C : short_ptr);
procedure vec_ste
(A : vector_pixel;
B : c_int;
C : unsigned_short_ptr);
procedure vec_ste
(A : vector_float;
B : c_int;
C : float_ptr);
procedure vec_ste
(A : vector_signed_int;
B : c_int;
C : int_ptr);
procedure vec_ste
(A : vector_unsigned_int;
B : c_int;
C : unsigned_int_ptr);
procedure vec_ste
(A : vector_bool_int;
B : c_int;
C : int_ptr);
procedure vec_ste
(A : vector_bool_int;
B : c_int;
C : unsigned_int_ptr);
----------------
-- vec_stvewx --
----------------
procedure vec_stvewx
(A : vector_float;
B : c_int;
C : float_ptr);
procedure vec_stvewx
(A : vector_signed_int;
B : c_int;
C : int_ptr);
procedure vec_stvewx
(A : vector_unsigned_int;
B : c_int;
C : unsigned_int_ptr);
procedure vec_stvewx
(A : vector_bool_int;
B : c_int;
C : int_ptr);
procedure vec_stvewx
(A : vector_bool_int;
B : c_int;
C : unsigned_int_ptr);
procedure vec_stvehx
(A : vector_signed_short;
B : c_int;
C : short_ptr);
procedure vec_stvehx
(A : vector_unsigned_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_stvehx
(A : vector_bool_short;
B : c_int;
C : short_ptr);
procedure vec_stvehx
(A : vector_bool_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_stvehx
(A : vector_pixel;
B : c_int;
C : short_ptr);
procedure vec_stvehx
(A : vector_pixel;
B : c_int;
C : unsigned_short_ptr);
procedure vec_stvebx
(A : vector_signed_char;
B : c_int;
C : signed_char_ptr);
procedure vec_stvebx
(A : vector_unsigned_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_stvebx
(A : vector_bool_char;
B : c_int;
C : signed_char_ptr);
procedure vec_stvebx
(A : vector_bool_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_stl
(A : vector_float;
B : c_int;
C : vector_float_ptr);
procedure vec_stl
(A : vector_float;
B : c_int;
C : float_ptr);
procedure vec_stl
(A : vector_signed_int;
B : c_int;
C : vector_signed_int_ptr);
procedure vec_stl
(A : vector_signed_int;
B : c_int;
C : int_ptr);
procedure vec_stl
(A : vector_unsigned_int;
B : c_int;
C : vector_unsigned_int_ptr);
procedure vec_stl
(A : vector_unsigned_int;
B : c_int;
C : unsigned_int_ptr);
procedure vec_stl
(A : vector_bool_int;
B : c_int;
C : vector_bool_int_ptr);
procedure vec_stl
(A : vector_bool_int;
B : c_int;
C : unsigned_int_ptr);
procedure vec_stl
(A : vector_bool_int;
B : c_int;
C : int_ptr);
procedure vec_stl
(A : vector_signed_short;
B : c_int;
C : vector_signed_short_ptr);
procedure vec_stl
(A : vector_signed_short;
B : c_int;
C : short_ptr);
procedure vec_stl
(A : vector_unsigned_short;
B : c_int;
C : vector_unsigned_short_ptr);
procedure vec_stl
(A : vector_unsigned_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_stl
(A : vector_bool_short;
B : c_int;
C : vector_bool_short_ptr);
procedure vec_stl
(A : vector_bool_short;
B : c_int;
C : unsigned_short_ptr);
procedure vec_stl
(A : vector_bool_short;
B : c_int;
C : short_ptr);
procedure vec_stl
(A : vector_pixel;
B : c_int;
C : vector_pixel_ptr);
procedure vec_stl
(A : vector_pixel;
B : c_int;
C : unsigned_short_ptr);
procedure vec_stl
(A : vector_pixel;
B : c_int;
C : short_ptr);
procedure vec_stl
(A : vector_signed_char;
B : c_int;
C : vector_signed_char_ptr);
procedure vec_stl
(A : vector_signed_char;
B : c_int;
C : signed_char_ptr);
procedure vec_stl
(A : vector_unsigned_char;
B : c_int;
C : vector_unsigned_char_ptr);
procedure vec_stl
(A : vector_unsigned_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_stl
(A : vector_bool_char;
B : c_int;
C : vector_bool_char_ptr);
procedure vec_stl
(A : vector_bool_char;
B : c_int;
C : unsigned_char_ptr);
procedure vec_stl
(A : vector_bool_char;
B : c_int;
C : signed_char_ptr);
-------------
-- vec_sub --
-------------
function vec_sub
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_sub
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_sub
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_sub
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_sub
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_sub
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_sub
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_sub
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_sub
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_sub
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_sub
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_sub
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_sub
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_sub
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_sub
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_sub
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_sub
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_sub
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_sub
(A : vector_float;
B : vector_float) return vector_float;
----------------
-- vec_vsubfp --
----------------
function vec_vsubfp
(A : vector_float;
B : vector_float) return vector_float;
-----------------
-- vec_vsubuwm --
-----------------
function vec_vsubuwm
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_vsubuwm
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_vsubuwm
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_vsubuwm
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vsubuwm
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_vsubuwm
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
-----------------
-- vec_vsubuhm --
-----------------
function vec_vsubuhm
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_vsubuhm
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_vsubuhm
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_vsubuhm
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vsubuhm
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_vsubuhm
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
-----------------
-- vec_vsububm --
-----------------
function vec_vsububm
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_vsububm
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_vsububm
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_vsububm
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_vsububm
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_vsububm
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
--------------
-- vec_subc --
--------------
function vec_subc
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
--------------
-- vec_subs --
--------------
function vec_subs
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_subs
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_subs
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_subs
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_subs
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_subs
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_subs
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_subs
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_subs
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_subs
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_subs
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_subs
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_subs
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_subs
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_subs
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_subs
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_subs
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_subs
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
-----------------
-- vec_vsubsws --
-----------------
function vec_vsubsws
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_vsubsws
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_vsubsws
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
-----------------
-- vec_vsubuws --
-----------------
function vec_vsubuws
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_vsubuws
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_vsubuws
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
-----------------
-- vec_vsubshs --
-----------------
function vec_vsubshs
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_vsubshs
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_vsubshs
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
-----------------
-- vec_vsubuhs --
-----------------
function vec_vsubuhs
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_vsubuhs
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_vsubuhs
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
-----------------
-- vec_vsubsbs --
-----------------
function vec_vsubsbs
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_vsubsbs
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_vsubsbs
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
-----------------
-- vec_vsububs --
-----------------
function vec_vsububs
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_vsububs
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_vsububs
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
---------------
-- vec_sum4s --
---------------
function vec_sum4s
(A : vector_unsigned_char;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_sum4s
(A : vector_signed_char;
B : vector_signed_int) return vector_signed_int;
function vec_sum4s
(A : vector_signed_short;
B : vector_signed_int) return vector_signed_int;
------------------
-- vec_vsum4shs --
------------------
function vec_vsum4shs
(A : vector_signed_short;
B : vector_signed_int) return vector_signed_int;
------------------
-- vec_vsum4sbs --
------------------
function vec_vsum4sbs
(A : vector_signed_char;
B : vector_signed_int) return vector_signed_int;
------------------
-- vec_vsum4ubs --
------------------
function vec_vsum4ubs
(A : vector_unsigned_char;
B : vector_unsigned_int) return vector_unsigned_int;
---------------
-- vec_sum2s --
---------------
function vec_sum2s
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
--------------
-- vec_sums --
--------------
function vec_sums
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_trunc
(A : vector_float) return vector_float;
function vec_unpackh
(A : vector_signed_char) return vector_signed_short;
function vec_unpackh
(A : vector_bool_char) return vector_bool_short;
function vec_unpackh
(A : vector_signed_short) return vector_signed_int;
function vec_unpackh
(A : vector_bool_short) return vector_bool_int;
function vec_unpackh
(A : vector_pixel) return vector_unsigned_int;
function vec_vupkhsh
(A : vector_bool_short) return vector_bool_int;
function vec_vupkhsh
(A : vector_signed_short) return vector_signed_int;
function vec_vupkhpx
(A : vector_pixel) return vector_unsigned_int;
function vec_vupkhsb
(A : vector_bool_char) return vector_bool_short;
function vec_vupkhsb
(A : vector_signed_char) return vector_signed_short;
function vec_unpackl
(A : vector_signed_char) return vector_signed_short;
function vec_unpackl
(A : vector_bool_char) return vector_bool_short;
function vec_unpackl
(A : vector_pixel) return vector_unsigned_int;
function vec_unpackl
(A : vector_signed_short) return vector_signed_int;
function vec_unpackl
(A : vector_bool_short) return vector_bool_int;
function vec_vupklpx
(A : vector_pixel) return vector_unsigned_int;
-----------------
-- vec_vupklsh --
-----------------
function vec_vupklsh
(A : vector_bool_short) return vector_bool_int;
function vec_vupklsh
(A : vector_signed_short) return vector_signed_int;
-----------------
-- vec_vupklsb --
-----------------
function vec_vupklsb
(A : vector_bool_char) return vector_bool_short;
function vec_vupklsb
(A : vector_signed_char) return vector_signed_short;
-------------
-- vec_xor --
-------------
function vec_xor
(A : vector_float;
B : vector_float) return vector_float;
function vec_xor
(A : vector_float;
B : vector_bool_int) return vector_float;
function vec_xor
(A : vector_bool_int;
B : vector_float) return vector_float;
function vec_xor
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int;
function vec_xor
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int;
function vec_xor
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int;
function vec_xor
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int;
function vec_xor
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_xor
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int;
function vec_xor
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int;
function vec_xor
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short;
function vec_xor
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short;
function vec_xor
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short;
function vec_xor
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short;
function vec_xor
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_xor
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short;
function vec_xor
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short;
function vec_xor
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char;
function vec_xor
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char;
function vec_xor
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char;
function vec_xor
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char;
function vec_xor
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char;
function vec_xor
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char;
function vec_xor
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char;
-- vec_all_eq --
function vec_all_eq
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_all_eq
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_all_eq
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_all_eq
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_all_eq
(A : vector_bool_char;
B : vector_bool_char) return c_int;
function vec_all_eq
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_all_eq
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_all_eq
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_all_eq
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_all_eq
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_all_eq
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_all_eq
(A : vector_bool_short;
B : vector_bool_short) return c_int;
function vec_all_eq
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_all_eq
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_all_eq
(A : vector_pixel;
B : vector_pixel) return c_int;
function vec_all_eq
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_all_eq
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_all_eq
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_all_eq
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_all_eq
(A : vector_bool_int;
B : vector_bool_int) return c_int;
function vec_all_eq
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_all_eq
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_all_eq
(A : vector_float;
B : vector_float) return c_int;
----------------
-- vec_all_ge --
----------------
function vec_all_ge
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_all_ge
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_all_ge
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_all_ge
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_all_ge
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_all_ge
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_all_ge
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_all_ge
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_all_ge
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_all_ge
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_all_ge
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_all_ge
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_all_ge
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_all_ge
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_all_ge
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_all_ge
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_all_ge
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_all_ge
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_all_ge
(A : vector_float;
B : vector_float) return c_int;
----------------
-- vec_all_gt --
----------------
function vec_all_gt
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_all_gt
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_all_gt
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_all_gt
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_all_gt
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_all_gt
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_all_gt
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_all_gt
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_all_gt
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_all_gt
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_all_gt
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_all_gt
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_all_gt
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_all_gt
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_all_gt
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_all_gt
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_all_gt
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_all_gt
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_all_gt
(A : vector_float;
B : vector_float) return c_int;
----------------
-- vec_all_in --
----------------
function vec_all_in
(A : vector_float;
B : vector_float) return c_int;
----------------
-- vec_all_le --
----------------
function vec_all_le
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_all_le
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_all_le
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_all_le
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_all_le
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_all_le
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_all_le
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_all_le
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_all_le
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_all_le
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_all_le
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_all_le
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_all_le
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_all_le
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_all_le
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_all_le
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_all_le
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_all_le
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_all_le
(A : vector_float;
B : vector_float) return c_int;
----------------
-- vec_all_lt --
----------------
function vec_all_lt
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_all_lt
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_all_lt
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_all_lt
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_all_lt
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_all_lt
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_all_lt
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_all_lt
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_all_lt
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_all_lt
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_all_lt
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_all_lt
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_all_lt
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_all_lt
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_all_lt
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_all_lt
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_all_lt
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_all_lt
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_all_lt
(A : vector_float;
B : vector_float) return c_int;
-----------------
-- vec_all_nan --
-----------------
function vec_all_nan
(A : vector_float) return c_int;
----------------
-- vec_all_ne --
----------------
function vec_all_ne
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_all_ne
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_all_ne
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_all_ne
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_all_ne
(A : vector_bool_char;
B : vector_bool_char) return c_int;
function vec_all_ne
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_all_ne
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_all_ne
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_all_ne
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_all_ne
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_all_ne
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_all_ne
(A : vector_bool_short;
B : vector_bool_short) return c_int;
function vec_all_ne
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_all_ne
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_all_ne
(A : vector_pixel;
B : vector_pixel) return c_int;
function vec_all_ne
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_all_ne
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_all_ne
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_all_ne
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_all_ne
(A : vector_bool_int;
B : vector_bool_int) return c_int;
function vec_all_ne
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_all_ne
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_all_ne
(A : vector_float;
B : vector_float) return c_int;
-----------------
-- vec_all_nge --
-----------------
function vec_all_nge
(A : vector_float;
B : vector_float) return c_int;
-----------------
-- vec_all_ngt --
-----------------
function vec_all_ngt
(A : vector_float;
B : vector_float) return c_int;
-----------------
-- vec_all_nle --
-----------------
function vec_all_nle
(A : vector_float;
B : vector_float) return c_int;
-----------------
-- vec_all_nlt --
-----------------
function vec_all_nlt
(A : vector_float;
B : vector_float) return c_int;
---------------------
-- vec_all_numeric --
---------------------
function vec_all_numeric
(A : vector_float) return c_int;
----------------
-- vec_any_eq --
----------------
function vec_any_eq
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_any_eq
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_any_eq
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_any_eq
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_any_eq
(A : vector_bool_char;
B : vector_bool_char) return c_int;
function vec_any_eq
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_any_eq
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_any_eq
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_any_eq
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_any_eq
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_any_eq
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_any_eq
(A : vector_bool_short;
B : vector_bool_short) return c_int;
function vec_any_eq
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_any_eq
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_any_eq
(A : vector_pixel;
B : vector_pixel) return c_int;
function vec_any_eq
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_any_eq
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_any_eq
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_any_eq
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_any_eq
(A : vector_bool_int;
B : vector_bool_int) return c_int;
function vec_any_eq
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_any_eq
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_any_eq
(A : vector_float;
B : vector_float) return c_int;
----------------
-- vec_any_ge --
----------------
function vec_any_ge
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_any_ge
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_any_ge
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_any_ge
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_any_ge
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_any_ge
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_any_ge
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_any_ge
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_any_ge
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_any_ge
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_any_ge
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_any_ge
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_any_ge
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_any_ge
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_any_ge
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_any_ge
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_any_ge
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_any_ge
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_any_ge
(A : vector_float;
B : vector_float) return c_int;
----------------
-- vec_any_gt --
----------------
function vec_any_gt
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_any_gt
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_any_gt
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_any_gt
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_any_gt
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_any_gt
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_any_gt
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_any_gt
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_any_gt
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_any_gt
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_any_gt
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_any_gt
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_any_gt
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_any_gt
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_any_gt
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_any_gt
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_any_gt
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_any_gt
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_any_gt
(A : vector_float;
B : vector_float) return c_int;
function vec_any_le
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_any_le
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_any_le
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_any_le
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_any_le
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_any_le
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_any_le
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_any_le
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_any_le
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_any_le
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_any_le
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_any_le
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_any_le
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_any_le
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_any_le
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_any_le
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_any_le
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_any_le
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_any_le
(A : vector_float;
B : vector_float) return c_int;
function vec_any_lt
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_any_lt
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_any_lt
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_any_lt
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_any_lt
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_any_lt
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_any_lt
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_any_lt
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_any_lt
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_any_lt
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_any_lt
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_any_lt
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_any_lt
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_any_lt
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_any_lt
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_any_lt
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_any_lt
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_any_lt
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_any_lt
(A : vector_float;
B : vector_float) return c_int;
function vec_any_nan
(A : vector_float) return c_int;
function vec_any_ne
(A : vector_signed_char;
B : vector_bool_char) return c_int;
function vec_any_ne
(A : vector_signed_char;
B : vector_signed_char) return c_int;
function vec_any_ne
(A : vector_unsigned_char;
B : vector_bool_char) return c_int;
function vec_any_ne
(A : vector_unsigned_char;
B : vector_unsigned_char) return c_int;
function vec_any_ne
(A : vector_bool_char;
B : vector_bool_char) return c_int;
function vec_any_ne
(A : vector_bool_char;
B : vector_unsigned_char) return c_int;
function vec_any_ne
(A : vector_bool_char;
B : vector_signed_char) return c_int;
function vec_any_ne
(A : vector_signed_short;
B : vector_bool_short) return c_int;
function vec_any_ne
(A : vector_signed_short;
B : vector_signed_short) return c_int;
function vec_any_ne
(A : vector_unsigned_short;
B : vector_bool_short) return c_int;
function vec_any_ne
(A : vector_unsigned_short;
B : vector_unsigned_short) return c_int;
function vec_any_ne
(A : vector_bool_short;
B : vector_bool_short) return c_int;
function vec_any_ne
(A : vector_bool_short;
B : vector_unsigned_short) return c_int;
function vec_any_ne
(A : vector_bool_short;
B : vector_signed_short) return c_int;
function vec_any_ne
(A : vector_pixel;
B : vector_pixel) return c_int;
function vec_any_ne
(A : vector_signed_int;
B : vector_bool_int) return c_int;
function vec_any_ne
(A : vector_signed_int;
B : vector_signed_int) return c_int;
function vec_any_ne
(A : vector_unsigned_int;
B : vector_bool_int) return c_int;
function vec_any_ne
(A : vector_unsigned_int;
B : vector_unsigned_int) return c_int;
function vec_any_ne
(A : vector_bool_int;
B : vector_bool_int) return c_int;
function vec_any_ne
(A : vector_bool_int;
B : vector_unsigned_int) return c_int;
function vec_any_ne
(A : vector_bool_int;
B : vector_signed_int) return c_int;
function vec_any_ne
(A : vector_float;
B : vector_float) return c_int;
-----------------
-- vec_any_nge --
-----------------
function vec_any_nge
(A : vector_float;
B : vector_float) return c_int;
function vec_any_ngt
(A : vector_float;
B : vector_float) return c_int;
function vec_any_nle
(A : vector_float;
B : vector_float) return c_int;
function vec_any_nlt
(A : vector_float;
B : vector_float) return c_int;
function vec_any_numeric
(A : vector_float) return c_int;
function vec_any_out
(A : vector_float;
B : vector_float) return c_int;
function vec_splat_s8
(A : c_int) return vector_signed_char
renames vec_vspltisb;
-------------------
-- vec_splat_s16 --
-------------------
function vec_splat_s16
(A : c_int) return vector_signed_short
renames vec_vspltish;
-------------------
-- vec_splat_s32 --
-------------------
function vec_splat_s32
(A : c_int) return vector_signed_int
renames vec_vspltisw;
function vec_splat
(A : vector_signed_char;
B : c_int) return vector_signed_char
renames vec_vspltb;
function vec_splat
(A : vector_unsigned_char;
B : c_int) return vector_unsigned_char
renames vec_vspltb;
function vec_splat
(A : vector_bool_char;
B : c_int) return vector_bool_char
renames vec_vspltb;
function vec_splat
(A : vector_signed_short;
B : c_int) return vector_signed_short
renames vec_vsplth;
function vec_splat
(A : vector_unsigned_short;
B : c_int) return vector_unsigned_short
renames vec_vsplth;
function vec_splat
(A : vector_bool_short;
B : c_int) return vector_bool_short
renames vec_vsplth;
function vec_splat
(A : vector_pixel;
B : c_int) return vector_pixel
renames vec_vsplth;
function vec_splat
(A : vector_float;
B : c_int) return vector_float
renames vec_vspltw;
function vec_splat
(A : vector_signed_int;
B : c_int) return vector_signed_int
renames vec_vspltw;
function vec_splat
(A : vector_unsigned_int;
B : c_int) return vector_unsigned_int
renames vec_vspltw;
function vec_splat
(A : vector_bool_int;
B : c_int) return vector_bool_int
renames vec_vspltw;
------------------
-- vec_splat_u8 --
------------------
function vec_splat_u8
(A : c_int) return vector_unsigned_char;
pragma Inline_Always (vec_splat_u8);
pragma Convention (Intrinsic, vec_splat_u8);
-------------------
-- vec_splat_u16 --
-------------------
function vec_splat_u16
(A : c_int) return vector_unsigned_short;
pragma Inline_Always (vec_splat_u16);
pragma Convention (Intrinsic, vec_splat_u16);
-------------------
-- vec_splat_u32 --
-------------------
function vec_splat_u32
(A : c_int) return vector_unsigned_int;
pragma Inline_Always (vec_splat_u32);
pragma Convention (Intrinsic, vec_splat_u32);
-------------
-- vec_ctf --
-------------
function vec_ctf
(A : vector_unsigned_int;
B : c_int) return vector_float
renames vec_vcfux;
function vec_ctf
(A : vector_signed_int;
B : c_int) return vector_float
renames vec_vcfsx;
-------------
-- vec_cts --
-------------
function vec_cts
(A : vector_float;
B : c_int) return vector_signed_int
renames vec_vctsxs;
function vec_ctu
(A : vector_float;
B : c_int) return vector_unsigned_int
renames vec_vctuxs;
function vec_vaddcuw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_addc;
function vec_vand
(A : vector_float;
B : vector_float) return vector_float
renames vec_and;
function vec_vand
(A : vector_float;
B : vector_bool_int) return vector_float
renames vec_and;
function vec_vand
(A : vector_bool_int;
B : vector_float) return vector_float
renames vec_and;
function vec_vand
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int
renames vec_and;
function vec_vand
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int
renames vec_and;
function vec_vand
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int
renames vec_and;
function vec_vand
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int
renames vec_and;
function vec_vand
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_and;
function vec_vand
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int
renames vec_and;
function vec_vand
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_and;
function vec_vand
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short
renames vec_and;
function vec_vand
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short
renames vec_and;
function vec_vand
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short
renames vec_and;
function vec_vand
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short
renames vec_and;
function vec_vand
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_and;
function vec_vand
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short
renames vec_and;
function vec_vand
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_and;
function vec_vand
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char
renames vec_and;
function vec_vand
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char
renames vec_and;
function vec_vand
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char
renames vec_and;
function vec_vand
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char
renames vec_and;
function vec_vand
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_and;
function vec_vand
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char
renames vec_and;
function vec_vand
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_and;
---------------
-- vec_vandc --
---------------
function vec_vandc
(A : vector_float;
B : vector_float) return vector_float
renames vec_andc;
function vec_vandc
(A : vector_float;
B : vector_bool_int) return vector_float
renames vec_andc;
function vec_vandc
(A : vector_bool_int;
B : vector_float) return vector_float
renames vec_andc;
function vec_vandc
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int
renames vec_andc;
function vec_vandc
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int
renames vec_andc;
function vec_vandc
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int
renames vec_andc;
function vec_vandc
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int
renames vec_andc;
function vec_vandc
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_andc;
function vec_vandc
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int
renames vec_andc;
function vec_vandc
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_andc;
function vec_vandc
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short
renames vec_andc;
function vec_vandc
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short
renames vec_andc;
function vec_vandc
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short
renames vec_andc;
function vec_vandc
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short
renames vec_andc;
function vec_vandc
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_andc;
function vec_vandc
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short
renames vec_andc;
function vec_vandc
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_andc;
function vec_vandc
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char
renames vec_andc;
function vec_vandc
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char
renames vec_andc;
function vec_vandc
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char
renames vec_andc;
function vec_vandc
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char
renames vec_andc;
function vec_vandc
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_andc;
function vec_vandc
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char
renames vec_andc;
function vec_vandc
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_andc;
---------------
-- vec_vrfip --
---------------
function vec_vrfip
(A : vector_float) return vector_float
renames vec_ceil;
-----------------
-- vec_vcmpbfp --
-----------------
function vec_vcmpbfp
(A : vector_float;
B : vector_float) return vector_signed_int
renames vec_cmpb;
function vec_vcmpgefp
(A : vector_float;
B : vector_float) return vector_bool_int
renames vec_cmpge;
function vec_vexptefp
(A : vector_float) return vector_float
renames vec_expte;
---------------
-- vec_vrfim --
---------------
function vec_vrfim
(A : vector_float) return vector_float
renames vec_floor;
function vec_lvx
(A : c_long;
B : const_vector_float_ptr) return vector_float
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_float_ptr) return vector_float
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_bool_int_ptr) return vector_bool_int
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_signed_int_ptr) return vector_signed_int
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_int_ptr) return vector_signed_int
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_long_ptr) return vector_signed_int
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_unsigned_int_ptr) return vector_unsigned_int
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_unsigned_int_ptr) return vector_unsigned_int
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_unsigned_long_ptr) return vector_unsigned_int
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_bool_short_ptr) return vector_bool_short
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_pixel_ptr) return vector_pixel
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_signed_short_ptr) return vector_signed_short
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_short_ptr) return vector_signed_short
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_unsigned_short_ptr) return vector_unsigned_short
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_unsigned_short_ptr) return vector_unsigned_short
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_bool_char_ptr) return vector_bool_char
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_signed_char_ptr) return vector_signed_char
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_signed_char_ptr) return vector_signed_char
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_vector_unsigned_char_ptr) return vector_unsigned_char
renames vec_ld;
function vec_lvx
(A : c_long;
B : const_unsigned_char_ptr) return vector_unsigned_char
renames vec_ld;
function vec_lvxl
(A : c_long;
B : const_vector_float_ptr) return vector_float
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_float_ptr) return vector_float
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_bool_int_ptr) return vector_bool_int
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_signed_int_ptr) return vector_signed_int
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_int_ptr) return vector_signed_int
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_long_ptr) return vector_signed_int
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_unsigned_int_ptr) return vector_unsigned_int
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_unsigned_int_ptr) return vector_unsigned_int
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_unsigned_long_ptr) return vector_unsigned_int
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_bool_short_ptr) return vector_bool_short
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_pixel_ptr) return vector_pixel
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_signed_short_ptr) return vector_signed_short
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_short_ptr) return vector_signed_short
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_unsigned_short_ptr) return vector_unsigned_short
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_unsigned_short_ptr) return vector_unsigned_short
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_bool_char_ptr) return vector_bool_char
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_signed_char_ptr) return vector_signed_char
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_signed_char_ptr) return vector_signed_char
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_vector_unsigned_char_ptr) return vector_unsigned_char
renames vec_ldl;
function vec_lvxl
(A : c_long;
B : const_unsigned_char_ptr) return vector_unsigned_char
renames vec_ldl;
function vec_vlogefp
(A : vector_float) return vector_float
renames vec_loge;
-----------------
-- vec_vmaddfp --
-----------------
function vec_vmaddfp
(A : vector_float;
B : vector_float;
C : vector_float) return vector_float
renames vec_madd;
-------------------
-- vec_vmhaddshs --
-------------------
function vec_vmhaddshs
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short
renames vec_madds;
-------------------
-- vec_vmladduhm --
-------------------
function vec_vmladduhm
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short
renames vec_mladd;
function vec_vmladduhm
(A : vector_signed_short;
B : vector_unsigned_short;
C : vector_unsigned_short) return vector_signed_short
renames vec_mladd;
function vec_vmladduhm
(A : vector_unsigned_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short
renames vec_mladd;
function vec_vmladduhm
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_short) return vector_unsigned_short
renames vec_mladd;
--------------------
-- vec_vmhraddshs --
--------------------
function vec_vmhraddshs
(A : vector_signed_short;
B : vector_signed_short;
C : vector_signed_short) return vector_signed_short
renames vec_mradds;
------------------
-- vec_vnmsubfp --
------------------
function vec_vnmsubfp
(A : vector_float;
B : vector_float;
C : vector_float) return vector_float
renames vec_nmsub;
--------------
-- vec_vnor --
--------------
function vec_vnor
(A : vector_float;
B : vector_float) return vector_float
renames vec_nor;
function vec_vnor
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int
renames vec_nor;
function vec_vnor
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_nor;
function vec_vnor
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int
renames vec_nor;
function vec_vnor
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short
renames vec_nor;
function vec_vnor
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_nor;
function vec_vnor
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short
renames vec_nor;
function vec_vnor
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char
renames vec_nor;
function vec_vnor
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_nor;
function vec_vnor
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char
renames vec_nor;
-------------
-- vec_vor --
-------------
function vec_vor
(A : vector_float;
B : vector_float) return vector_float
renames vec_or;
function vec_vor
(A : vector_float;
B : vector_bool_int) return vector_float
renames vec_or;
function vec_vor
(A : vector_bool_int;
B : vector_float) return vector_float
renames vec_or;
function vec_vor
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int
renames vec_or;
function vec_vor
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int
renames vec_or;
function vec_vor
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int
renames vec_or;
function vec_vor
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int
renames vec_or;
function vec_vor
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_or;
function vec_vor
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int
renames vec_or;
function vec_vor
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_or;
function vec_vor
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short
renames vec_or;
function vec_vor
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short
renames vec_or;
function vec_vor
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short
renames vec_or;
function vec_vor
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short
renames vec_or;
function vec_vor
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_or;
function vec_vor
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short
renames vec_or;
function vec_vor
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_or;
function vec_vor
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char
renames vec_or;
function vec_vor
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char
renames vec_or;
function vec_vor
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char
renames vec_or;
function vec_vor
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char
renames vec_or;
function vec_vor
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_or;
function vec_vor
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char
renames vec_or;
function vec_vor
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_or;
---------------
-- vec_vpkpx --
---------------
function vec_vpkpx
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_pixel
renames vec_packpx;
---------------
-- vec_vperm --
---------------
function vec_vperm
(A : vector_float;
B : vector_float;
C : vector_unsigned_char) return vector_float
renames vec_perm;
function vec_vperm
(A : vector_signed_int;
B : vector_signed_int;
C : vector_unsigned_char) return vector_signed_int
renames vec_perm;
function vec_vperm
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : vector_unsigned_char) return vector_unsigned_int
renames vec_perm;
function vec_vperm
(A : vector_bool_int;
B : vector_bool_int;
C : vector_unsigned_char) return vector_bool_int
renames vec_perm;
function vec_vperm
(A : vector_signed_short;
B : vector_signed_short;
C : vector_unsigned_char) return vector_signed_short
renames vec_perm;
function vec_vperm
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_char) return vector_unsigned_short
renames vec_perm;
function vec_vperm
(A : vector_bool_short;
B : vector_bool_short;
C : vector_unsigned_char) return vector_bool_short
renames vec_perm;
function vec_vperm
(A : vector_pixel;
B : vector_pixel;
C : vector_unsigned_char) return vector_pixel
renames vec_perm;
function vec_vperm
(A : vector_signed_char;
B : vector_signed_char;
C : vector_unsigned_char) return vector_signed_char
renames vec_perm;
function vec_vperm
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_unsigned_char) return vector_unsigned_char
renames vec_perm;
function vec_vperm
(A : vector_bool_char;
B : vector_bool_char;
C : vector_unsigned_char) return vector_bool_char
renames vec_perm;
---------------
-- vec_vrefp --
---------------
function vec_vrefp
(A : vector_float) return vector_float
renames vec_re;
---------------
-- vec_vrfin --
---------------
function vec_vrfin
(A : vector_float) return vector_float
renames vec_round;
function vec_vrsqrtefp
(A : vector_float) return vector_float
renames vec_rsqrte;
function vec_vsel
(A : vector_float;
B : vector_float;
C : vector_bool_int) return vector_float
renames vec_sel;
function vec_vsel
(A : vector_float;
B : vector_float;
C : vector_unsigned_int) return vector_float
renames vec_sel;
function vec_vsel
(A : vector_signed_int;
B : vector_signed_int;
C : vector_bool_int) return vector_signed_int
renames vec_sel;
function vec_vsel
(A : vector_signed_int;
B : vector_signed_int;
C : vector_unsigned_int) return vector_signed_int
renames vec_sel;
function vec_vsel
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : vector_bool_int) return vector_unsigned_int
renames vec_sel;
function vec_vsel
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : vector_unsigned_int) return vector_unsigned_int
renames vec_sel;
function vec_vsel
(A : vector_bool_int;
B : vector_bool_int;
C : vector_bool_int) return vector_bool_int
renames vec_sel;
function vec_vsel
(A : vector_bool_int;
B : vector_bool_int;
C : vector_unsigned_int) return vector_bool_int
renames vec_sel;
function vec_vsel
(A : vector_signed_short;
B : vector_signed_short;
C : vector_bool_short) return vector_signed_short
renames vec_sel;
function vec_vsel
(A : vector_signed_short;
B : vector_signed_short;
C : vector_unsigned_short) return vector_signed_short
renames vec_sel;
function vec_vsel
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_bool_short) return vector_unsigned_short
renames vec_sel;
function vec_vsel
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : vector_unsigned_short) return vector_unsigned_short
renames vec_sel;
function vec_vsel
(A : vector_bool_short;
B : vector_bool_short;
C : vector_bool_short) return vector_bool_short
renames vec_sel;
function vec_vsel
(A : vector_bool_short;
B : vector_bool_short;
C : vector_unsigned_short) return vector_bool_short
renames vec_sel;
function vec_vsel
(A : vector_signed_char;
B : vector_signed_char;
C : vector_bool_char) return vector_signed_char
renames vec_sel;
function vec_vsel
(A : vector_signed_char;
B : vector_signed_char;
C : vector_unsigned_char) return vector_signed_char
renames vec_sel;
function vec_vsel
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_bool_char) return vector_unsigned_char
renames vec_sel;
function vec_vsel
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : vector_unsigned_char) return vector_unsigned_char
renames vec_sel;
function vec_vsel
(A : vector_bool_char;
B : vector_bool_char;
C : vector_bool_char) return vector_bool_char
renames vec_sel;
function vec_vsel
(A : vector_bool_char;
B : vector_bool_char;
C : vector_unsigned_char) return vector_bool_char
renames vec_sel;
----------------
-- vec_vsldoi --
----------------
function vec_vsldoi
(A : vector_float;
B : vector_float;
C : c_int) return vector_float
renames vec_sld;
function vec_vsldoi
(A : vector_signed_int;
B : vector_signed_int;
C : c_int) return vector_signed_int
renames vec_sld;
function vec_vsldoi
(A : vector_unsigned_int;
B : vector_unsigned_int;
C : c_int) return vector_unsigned_int
renames vec_sld;
function vec_vsldoi
(A : vector_bool_int;
B : vector_bool_int;
C : c_int) return vector_bool_int
renames vec_sld;
function vec_vsldoi
(A : vector_signed_short;
B : vector_signed_short;
C : c_int) return vector_signed_short
renames vec_sld;
function vec_vsldoi
(A : vector_unsigned_short;
B : vector_unsigned_short;
C : c_int) return vector_unsigned_short
renames vec_sld;
function vec_vsldoi
(A : vector_bool_short;
B : vector_bool_short;
C : c_int) return vector_bool_short
renames vec_sld;
function vec_vsldoi
(A : vector_pixel;
B : vector_pixel;
C : c_int) return vector_pixel
renames vec_sld;
function vec_vsldoi
(A : vector_signed_char;
B : vector_signed_char;
C : c_int) return vector_signed_char
renames vec_sld;
function vec_vsldoi
(A : vector_unsigned_char;
B : vector_unsigned_char;
C : c_int) return vector_unsigned_char
renames vec_sld;
function vec_vsldoi
(A : vector_bool_char;
B : vector_bool_char;
C : c_int) return vector_bool_char
renames vec_sld;
-------------
-- vec_vsl --
-------------
function vec_vsl
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int
renames vec_sll;
function vec_vsl
(A : vector_signed_int;
B : vector_unsigned_short) return vector_signed_int
renames vec_sll;
function vec_vsl
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int
renames vec_sll;
function vec_vsl
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_sll;
function vec_vsl
(A : vector_unsigned_int;
B : vector_unsigned_short) return vector_unsigned_int
renames vec_sll;
function vec_vsl
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int
renames vec_sll;
function vec_vsl
(A : vector_bool_int;
B : vector_unsigned_int) return vector_bool_int
renames vec_sll;
function vec_vsl
(A : vector_bool_int;
B : vector_unsigned_short) return vector_bool_int
renames vec_sll;
function vec_vsl
(A : vector_bool_int;
B : vector_unsigned_char) return vector_bool_int
renames vec_sll;
function vec_vsl
(A : vector_signed_short;
B : vector_unsigned_int) return vector_signed_short
renames vec_sll;
function vec_vsl
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short
renames vec_sll;
function vec_vsl
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short
renames vec_sll;
function vec_vsl
(A : vector_unsigned_short;
B : vector_unsigned_int) return vector_unsigned_short
renames vec_sll;
function vec_vsl
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_sll;
function vec_vsl
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short
renames vec_sll;
function vec_vsl
(A : vector_bool_short;
B : vector_unsigned_int) return vector_bool_short
renames vec_sll;
function vec_vsl
(A : vector_bool_short;
B : vector_unsigned_short) return vector_bool_short
renames vec_sll;
function vec_vsl
(A : vector_bool_short;
B : vector_unsigned_char) return vector_bool_short
renames vec_sll;
function vec_vsl
(A : vector_pixel;
B : vector_unsigned_int) return vector_pixel
renames vec_sll;
function vec_vsl
(A : vector_pixel;
B : vector_unsigned_short) return vector_pixel
renames vec_sll;
function vec_vsl
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel
renames vec_sll;
function vec_vsl
(A : vector_signed_char;
B : vector_unsigned_int) return vector_signed_char
renames vec_sll;
function vec_vsl
(A : vector_signed_char;
B : vector_unsigned_short) return vector_signed_char
renames vec_sll;
function vec_vsl
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char
renames vec_sll;
function vec_vsl
(A : vector_unsigned_char;
B : vector_unsigned_int) return vector_unsigned_char
renames vec_sll;
function vec_vsl
(A : vector_unsigned_char;
B : vector_unsigned_short) return vector_unsigned_char
renames vec_sll;
function vec_vsl
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_sll;
function vec_vsl
(A : vector_bool_char;
B : vector_unsigned_int) return vector_bool_char
renames vec_sll;
function vec_vsl
(A : vector_bool_char;
B : vector_unsigned_short) return vector_bool_char
renames vec_sll;
function vec_vsl
(A : vector_bool_char;
B : vector_unsigned_char) return vector_bool_char
renames vec_sll;
--------------
-- vec_vslo --
--------------
function vec_vslo
(A : vector_float;
B : vector_signed_char) return vector_float
renames vec_slo;
function vec_vslo
(A : vector_float;
B : vector_unsigned_char) return vector_float
renames vec_slo;
function vec_vslo
(A : vector_signed_int;
B : vector_signed_char) return vector_signed_int
renames vec_slo;
function vec_vslo
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int
renames vec_slo;
function vec_vslo
(A : vector_unsigned_int;
B : vector_signed_char) return vector_unsigned_int
renames vec_slo;
function vec_vslo
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int
renames vec_slo;
function vec_vslo
(A : vector_signed_short;
B : vector_signed_char) return vector_signed_short
renames vec_slo;
function vec_vslo
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short
renames vec_slo;
function vec_vslo
(A : vector_unsigned_short;
B : vector_signed_char) return vector_unsigned_short
renames vec_slo;
function vec_vslo
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short
renames vec_slo;
function vec_vslo
(A : vector_pixel;
B : vector_signed_char) return vector_pixel
renames vec_slo;
function vec_vslo
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel
renames vec_slo;
function vec_vslo
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char
renames vec_slo;
function vec_vslo
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char
renames vec_slo;
function vec_vslo
(A : vector_unsigned_char;
B : vector_signed_char) return vector_unsigned_char
renames vec_slo;
function vec_vslo
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_slo;
function vec_vsr
(A : vector_signed_int;
B : vector_unsigned_int) return vector_signed_int
renames vec_srl;
function vec_vsr
(A : vector_signed_int;
B : vector_unsigned_short) return vector_signed_int
renames vec_srl;
function vec_vsr
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int
renames vec_srl;
function vec_vsr
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_srl;
function vec_vsr
(A : vector_unsigned_int;
B : vector_unsigned_short) return vector_unsigned_int
renames vec_srl;
function vec_vsr
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int
renames vec_srl;
function vec_vsr
(A : vector_bool_int;
B : vector_unsigned_int) return vector_bool_int
renames vec_srl;
function vec_vsr
(A : vector_bool_int;
B : vector_unsigned_short) return vector_bool_int
renames vec_srl;
function vec_vsr
(A : vector_bool_int;
B : vector_unsigned_char) return vector_bool_int
renames vec_srl;
function vec_vsr
(A : vector_signed_short;
B : vector_unsigned_int) return vector_signed_short
renames vec_srl;
function vec_vsr
(A : vector_signed_short;
B : vector_unsigned_short) return vector_signed_short
renames vec_srl;
function vec_vsr
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short
renames vec_srl;
function vec_vsr
(A : vector_unsigned_short;
B : vector_unsigned_int) return vector_unsigned_short
renames vec_srl;
function vec_vsr
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_srl;
function vec_vsr
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short
renames vec_srl;
function vec_vsr
(A : vector_bool_short;
B : vector_unsigned_int) return vector_bool_short
renames vec_srl;
function vec_vsr
(A : vector_bool_short;
B : vector_unsigned_short) return vector_bool_short
renames vec_srl;
function vec_vsr
(A : vector_bool_short;
B : vector_unsigned_char) return vector_bool_short
renames vec_srl;
function vec_vsr
(A : vector_pixel;
B : vector_unsigned_int) return vector_pixel
renames vec_srl;
function vec_vsr
(A : vector_pixel;
B : vector_unsigned_short) return vector_pixel
renames vec_srl;
function vec_vsr
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel
renames vec_srl;
function vec_vsr
(A : vector_signed_char;
B : vector_unsigned_int) return vector_signed_char
renames vec_srl;
function vec_vsr
(A : vector_signed_char;
B : vector_unsigned_short) return vector_signed_char
renames vec_srl;
function vec_vsr
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char
renames vec_srl;
function vec_vsr
(A : vector_unsigned_char;
B : vector_unsigned_int) return vector_unsigned_char
renames vec_srl;
function vec_vsr
(A : vector_unsigned_char;
B : vector_unsigned_short) return vector_unsigned_char
renames vec_srl;
function vec_vsr
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_srl;
function vec_vsr
(A : vector_bool_char;
B : vector_unsigned_int) return vector_bool_char
renames vec_srl;
function vec_vsr
(A : vector_bool_char;
B : vector_unsigned_short) return vector_bool_char
renames vec_srl;
function vec_vsr
(A : vector_bool_char;
B : vector_unsigned_char) return vector_bool_char
renames vec_srl;
function vec_vsro
(A : vector_float;
B : vector_signed_char) return vector_float
renames vec_sro;
function vec_vsro
(A : vector_float;
B : vector_unsigned_char) return vector_float
renames vec_sro;
function vec_vsro
(A : vector_signed_int;
B : vector_signed_char) return vector_signed_int
renames vec_sro;
function vec_vsro
(A : vector_signed_int;
B : vector_unsigned_char) return vector_signed_int
renames vec_sro;
function vec_vsro
(A : vector_unsigned_int;
B : vector_signed_char) return vector_unsigned_int
renames vec_sro;
function vec_vsro
(A : vector_unsigned_int;
B : vector_unsigned_char) return vector_unsigned_int
renames vec_sro;
function vec_vsro
(A : vector_signed_short;
B : vector_signed_char) return vector_signed_short
renames vec_sro;
function vec_vsro
(A : vector_signed_short;
B : vector_unsigned_char) return vector_signed_short
renames vec_sro;
function vec_vsro
(A : vector_unsigned_short;
B : vector_signed_char) return vector_unsigned_short
renames vec_sro;
function vec_vsro
(A : vector_unsigned_short;
B : vector_unsigned_char) return vector_unsigned_short
renames vec_sro;
function vec_vsro
(A : vector_pixel;
B : vector_signed_char) return vector_pixel
renames vec_sro;
function vec_vsro
(A : vector_pixel;
B : vector_unsigned_char) return vector_pixel
renames vec_sro;
function vec_vsro
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char
renames vec_sro;
function vec_vsro
(A : vector_signed_char;
B : vector_unsigned_char) return vector_signed_char
renames vec_sro;
function vec_vsro
(A : vector_unsigned_char;
B : vector_signed_char) return vector_unsigned_char
renames vec_sro;
function vec_vsro
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_sro;
--------------
-- vec_stvx --
--------------
procedure vec_stvx
(A : vector_float;
B : c_int;
C : vector_float_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_float;
B : c_int;
C : float_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_signed_int;
B : c_int;
C : vector_signed_int_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_signed_int;
B : c_int;
C : int_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_unsigned_int;
B : c_int;
C : vector_unsigned_int_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_unsigned_int;
B : c_int;
C : unsigned_int_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_int;
B : c_int;
C : vector_bool_int_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_int;
B : c_int;
C : unsigned_int_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_int;
B : c_int;
C : int_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_signed_short;
B : c_int;
C : vector_signed_short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_signed_short;
B : c_int;
C : short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_unsigned_short;
B : c_int;
C : vector_unsigned_short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_unsigned_short;
B : c_int;
C : unsigned_short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_short;
B : c_int;
C : vector_bool_short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_short;
B : c_int;
C : unsigned_short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_pixel;
B : c_int;
C : vector_pixel_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_pixel;
B : c_int;
C : unsigned_short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_pixel;
B : c_int;
C : short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_short;
B : c_int;
C : short_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_signed_char;
B : c_int;
C : vector_signed_char_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_signed_char;
B : c_int;
C : signed_char_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_unsigned_char;
B : c_int;
C : vector_unsigned_char_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_unsigned_char;
B : c_int;
C : unsigned_char_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_char;
B : c_int;
C : vector_bool_char_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_char;
B : c_int;
C : unsigned_char_ptr)
renames vec_st;
procedure vec_stvx
(A : vector_bool_char;
B : c_int;
C : signed_char_ptr)
renames vec_st;
---------------
-- vec_stvxl --
---------------
procedure vec_stvxl
(A : vector_float;
B : c_int;
C : vector_float_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_float;
B : c_int;
C : float_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_signed_int;
B : c_int;
C : vector_signed_int_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_signed_int;
B : c_int;
C : int_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_unsigned_int;
B : c_int;
C : vector_unsigned_int_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_unsigned_int;
B : c_int;
C : unsigned_int_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_int;
B : c_int;
C : vector_bool_int_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_int;
B : c_int;
C : unsigned_int_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_int;
B : c_int;
C : int_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_signed_short;
B : c_int;
C : vector_signed_short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_signed_short;
B : c_int;
C : short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_unsigned_short;
B : c_int;
C : vector_unsigned_short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_unsigned_short;
B : c_int;
C : unsigned_short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_short;
B : c_int;
C : vector_bool_short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_short;
B : c_int;
C : unsigned_short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_short;
B : c_int;
C : short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_pixel;
B : c_int;
C : vector_pixel_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_pixel;
B : c_int;
C : unsigned_short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_pixel;
B : c_int;
C : short_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_signed_char;
B : c_int;
C : vector_signed_char_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_signed_char;
B : c_int;
C : signed_char_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_unsigned_char;
B : c_int;
C : vector_unsigned_char_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_unsigned_char;
B : c_int;
C : unsigned_char_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_char;
B : c_int;
C : vector_bool_char_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_char;
B : c_int;
C : unsigned_char_ptr)
renames vec_stl;
procedure vec_stvxl
(A : vector_bool_char;
B : c_int;
C : signed_char_ptr)
renames vec_stl;
function vec_vsubcuw
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_subc;
------------------
-- vec_vsum2sws --
------------------
function vec_vsum2sws
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int
renames vec_sum2s;
function vec_vsumsws
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int
renames vec_sums;
function vec_vrfiz
(A : vector_float) return vector_float
renames vec_trunc;
--------------
-- vec_vxor --
--------------
function vec_vxor
(A : vector_float;
B : vector_float) return vector_float
renames vec_xor;
function vec_vxor
(A : vector_float;
B : vector_bool_int) return vector_float
renames vec_xor;
function vec_vxor
(A : vector_bool_int;
B : vector_float) return vector_float
renames vec_xor;
function vec_vxor
(A : vector_bool_int;
B : vector_bool_int) return vector_bool_int
renames vec_xor;
function vec_vxor
(A : vector_bool_int;
B : vector_signed_int) return vector_signed_int
renames vec_xor;
function vec_vxor
(A : vector_signed_int;
B : vector_bool_int) return vector_signed_int
renames vec_xor;
function vec_vxor
(A : vector_signed_int;
B : vector_signed_int) return vector_signed_int
renames vec_xor;
function vec_vxor
(A : vector_bool_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_xor;
function vec_vxor
(A : vector_unsigned_int;
B : vector_bool_int) return vector_unsigned_int
renames vec_xor;
function vec_vxor
(A : vector_unsigned_int;
B : vector_unsigned_int) return vector_unsigned_int
renames vec_xor;
function vec_vxor
(A : vector_bool_short;
B : vector_bool_short) return vector_bool_short
renames vec_xor;
function vec_vxor
(A : vector_bool_short;
B : vector_signed_short) return vector_signed_short
renames vec_xor;
function vec_vxor
(A : vector_signed_short;
B : vector_bool_short) return vector_signed_short
renames vec_xor;
function vec_vxor
(A : vector_signed_short;
B : vector_signed_short) return vector_signed_short
renames vec_xor;
function vec_vxor
(A : vector_bool_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_xor;
function vec_vxor
(A : vector_unsigned_short;
B : vector_bool_short) return vector_unsigned_short
renames vec_xor;
function vec_vxor
(A : vector_unsigned_short;
B : vector_unsigned_short) return vector_unsigned_short
renames vec_xor;
function vec_vxor
(A : vector_bool_char;
B : vector_signed_char) return vector_signed_char
renames vec_xor;
function vec_vxor
(A : vector_bool_char;
B : vector_bool_char) return vector_bool_char
renames vec_xor;
function vec_vxor
(A : vector_signed_char;
B : vector_bool_char) return vector_signed_char
renames vec_xor;
function vec_vxor
(A : vector_signed_char;
B : vector_signed_char) return vector_signed_char
renames vec_xor;
function vec_vxor
(A : vector_bool_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_xor;
function vec_vxor
(A : vector_unsigned_char;
B : vector_bool_char) return vector_unsigned_char
renames vec_xor;
function vec_vxor
(A : vector_unsigned_char;
B : vector_unsigned_char) return vector_unsigned_char
renames vec_xor;
--------------
-- vec_step --
--------------
function vec_step (V : vector_unsigned_char) return Integer;
function vec_step (V : vector_signed_char) return Integer;
function vec_step (V : vector_bool_char) return Integer;
function vec_step (V : vector_unsigned_short) return Integer;
function vec_step (V : vector_signed_short) return Integer;
function vec_step (V : vector_bool_short) return Integer;
function vec_step (V : vector_unsigned_int) return Integer;
function vec_step (V : vector_signed_int) return Integer;
function vec_step (V : vector_bool_int) return Integer;
function vec_step (V : vector_float) return Integer;
function vec_step (V : vector_pixel) return Integer;
private
pragma Inline_Always (vec_abs);
pragma Inline_Always (vec_abss);
pragma Inline_Always (vec_add);
pragma Inline_Always (vec_vaddfp);
pragma Inline_Always (vec_vadduwm);
pragma Inline_Always (vec_vadduhm);
pragma Inline_Always (vec_vaddubm);
pragma Inline_Always (vec_addc);
pragma Inline_Always (vec_adds);
pragma Inline_Always (vec_vaddsws);
pragma Inline_Always (vec_vadduws);
pragma Inline_Always (vec_vaddshs);
pragma Inline_Always (vec_vadduhs);
pragma Inline_Always (vec_vaddsbs);
pragma Inline_Always (vec_vaddubs);
pragma Inline_Always (vec_and);
pragma Inline_Always (vec_andc);
pragma Inline_Always (vec_avg);
pragma Inline_Always (vec_vavgsw);
pragma Inline_Always (vec_vavguw);
pragma Inline_Always (vec_vavgsh);
pragma Inline_Always (vec_vavguh);
pragma Inline_Always (vec_vavgsb);
pragma Inline_Always (vec_vavgub);
pragma Inline_Always (vec_ceil);
pragma Inline_Always (vec_cmpb);
pragma Inline_Always (vec_cmpeq);
pragma Inline_Always (vec_vcmpeqfp);
pragma Inline_Always (vec_vcmpequw);
pragma Inline_Always (vec_vcmpequh);
pragma Inline_Always (vec_vcmpequb);
pragma Inline_Always (vec_cmpge);
pragma Inline_Always (vec_cmpgt);
pragma Inline_Always (vec_vcmpgtfp);
pragma Inline_Always (vec_vcmpgtsw);
pragma Inline_Always (vec_vcmpgtuw);
pragma Inline_Always (vec_vcmpgtsh);
pragma Inline_Always (vec_vcmpgtuh);
pragma Inline_Always (vec_vcmpgtsb);
pragma Inline_Always (vec_vcmpgtub);
pragma Inline_Always (vec_cmple);
pragma Inline_Always (vec_cmplt);
pragma Inline_Always (vec_expte);
pragma Inline_Always (vec_floor);
pragma Inline_Always (vec_ld);
pragma Inline_Always (vec_lde);
pragma Inline_Always (vec_lvewx);
pragma Inline_Always (vec_lvehx);
pragma Inline_Always (vec_lvebx);
pragma Inline_Always (vec_ldl);
pragma Inline_Always (vec_loge);
pragma Inline_Always (vec_lvsl);
pragma Inline_Always (vec_lvsr);
pragma Inline_Always (vec_madd);
pragma Inline_Always (vec_madds);
pragma Inline_Always (vec_max);
pragma Inline_Always (vec_vmaxfp);
pragma Inline_Always (vec_vmaxsw);
pragma Inline_Always (vec_vmaxuw);
pragma Inline_Always (vec_vmaxsh);
pragma Inline_Always (vec_vmaxuh);
pragma Inline_Always (vec_vmaxsb);
pragma Inline_Always (vec_vmaxub);
pragma Inline_Always (vec_mergeh);
pragma Inline_Always (vec_vmrghw);
pragma Inline_Always (vec_vmrghh);
pragma Inline_Always (vec_vmrghb);
pragma Inline_Always (vec_mergel);
pragma Inline_Always (vec_vmrglw);
pragma Inline_Always (vec_vmrglh);
pragma Inline_Always (vec_vmrglb);
pragma Inline_Always (vec_mfvscr);
pragma Inline_Always (vec_min);
pragma Inline_Always (vec_vminfp);
pragma Inline_Always (vec_vminsw);
pragma Inline_Always (vec_vminuw);
pragma Inline_Always (vec_vminsh);
pragma Inline_Always (vec_vminuh);
pragma Inline_Always (vec_vminsb);
pragma Inline_Always (vec_vminub);
pragma Inline_Always (vec_mladd);
pragma Inline_Always (vec_mradds);
pragma Inline_Always (vec_msum);
pragma Inline_Always (vec_vmsumshm);
pragma Inline_Always (vec_vmsumuhm);
pragma Inline_Always (vec_vmsummbm);
pragma Inline_Always (vec_vmsumubm);
pragma Inline_Always (vec_msums);
pragma Inline_Always (vec_vmsumshs);
pragma Inline_Always (vec_vmsumuhs);
pragma Inline_Always (vec_mtvscr);
pragma Inline_Always (vec_mule);
pragma Inline_Always (vec_vmulesh);
pragma Inline_Always (vec_vmuleuh);
pragma Inline_Always (vec_vmulesb);
pragma Inline_Always (vec_vmuleub);
pragma Inline_Always (vec_mulo);
pragma Inline_Always (vec_vmulosh);
pragma Inline_Always (vec_vmulouh);
pragma Inline_Always (vec_vmulosb);
pragma Inline_Always (vec_vmuloub);
pragma Inline_Always (vec_nmsub);
pragma Inline_Always (vec_nor);
pragma Inline_Always (vec_or);
pragma Inline_Always (vec_pack);
pragma Inline_Always (vec_vpkuwum);
pragma Inline_Always (vec_vpkuhum);
pragma Inline_Always (vec_packpx);
pragma Inline_Always (vec_packs);
pragma Inline_Always (vec_vpkswss);
pragma Inline_Always (vec_vpkuwus);
pragma Inline_Always (vec_vpkshss);
pragma Inline_Always (vec_vpkuhus);
pragma Inline_Always (vec_packsu);
pragma Inline_Always (vec_vpkswus);
pragma Inline_Always (vec_vpkshus);
pragma Inline_Always (vec_perm);
pragma Inline_Always (vec_re);
pragma Inline_Always (vec_rl);
pragma Inline_Always (vec_vrlw);
pragma Inline_Always (vec_vrlh);
pragma Inline_Always (vec_vrlb);
pragma Inline_Always (vec_round);
pragma Inline_Always (vec_rsqrte);
pragma Inline_Always (vec_sel);
pragma Inline_Always (vec_sl);
pragma Inline_Always (vec_vslw);
pragma Inline_Always (vec_vslh);
pragma Inline_Always (vec_vslb);
pragma Inline_Always (vec_sll);
pragma Inline_Always (vec_slo);
pragma Inline_Always (vec_sr);
pragma Inline_Always (vec_vsrw);
pragma Inline_Always (vec_vsrh);
pragma Inline_Always (vec_vsrb);
pragma Inline_Always (vec_sra);
pragma Inline_Always (vec_vsraw);
pragma Inline_Always (vec_vsrah);
pragma Inline_Always (vec_vsrab);
pragma Inline_Always (vec_srl);
pragma Inline_Always (vec_sro);
pragma Inline_Always (vec_st);
pragma Inline_Always (vec_ste);
pragma Inline_Always (vec_stvewx);
pragma Inline_Always (vec_stvehx);
pragma Inline_Always (vec_stvebx);
pragma Inline_Always (vec_stl);
pragma Inline_Always (vec_sub);
pragma Inline_Always (vec_vsubfp);
pragma Inline_Always (vec_vsubuwm);
pragma Inline_Always (vec_vsubuhm);
pragma Inline_Always (vec_vsububm);
pragma Inline_Always (vec_subc);
pragma Inline_Always (vec_subs);
pragma Inline_Always (vec_vsubsws);
pragma Inline_Always (vec_vsubuws);
pragma Inline_Always (vec_vsubshs);
pragma Inline_Always (vec_vsubuhs);
pragma Inline_Always (vec_vsubsbs);
pragma Inline_Always (vec_vsububs);
pragma Inline_Always (vec_sum4s);
pragma Inline_Always (vec_vsum4shs);
pragma Inline_Always (vec_vsum4sbs);
pragma Inline_Always (vec_vsum4ubs);
pragma Inline_Always (vec_sum2s);
pragma Inline_Always (vec_sums);
pragma Inline_Always (vec_trunc);
pragma Inline_Always (vec_unpackh);
pragma Inline_Always (vec_vupkhsh);
pragma Inline_Always (vec_vupkhpx);
pragma Inline_Always (vec_vupkhsb);
pragma Inline_Always (vec_unpackl);
pragma Inline_Always (vec_vupklpx);
pragma Inline_Always (vec_vupklsh);
pragma Inline_Always (vec_vupklsb);
pragma Inline_Always (vec_xor);
pragma Inline_Always (vec_all_eq);
pragma Inline_Always (vec_all_ge);
pragma Inline_Always (vec_all_gt);
pragma Inline_Always (vec_all_in);
pragma Inline_Always (vec_all_le);
pragma Inline_Always (vec_all_lt);
pragma Inline_Always (vec_all_nan);
pragma Inline_Always (vec_all_ne);
pragma Inline_Always (vec_all_nge);
pragma Inline_Always (vec_all_ngt);
pragma Inline_Always (vec_all_nle);
pragma Inline_Always (vec_all_nlt);
pragma Inline_Always (vec_all_numeric);
pragma Inline_Always (vec_any_eq);
pragma Inline_Always (vec_any_ge);
pragma Inline_Always (vec_any_gt);
pragma Inline_Always (vec_any_le);
pragma Inline_Always (vec_any_lt);
pragma Inline_Always (vec_any_nan);
pragma Inline_Always (vec_any_ne);
pragma Inline_Always (vec_any_nge);
pragma Inline_Always (vec_any_ngt);
pragma Inline_Always (vec_any_nle);
pragma Inline_Always (vec_any_nlt);
pragma Inline_Always (vec_any_numeric);
pragma Inline_Always (vec_any_out);
pragma Inline_Always (vec_step);
end GNAT.Altivec.Vector_Operations;
|
-----------------------------------------------------------------------
-- mgrep -- Mail grep
-- Copyright (C) 2020 Stephane Carrez
-- Written by Stephane Carrez (Stephane.Carrez@gmail.com)
--
-- 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 Intl;
package Mgrep is
function "-" (Message : in String) return String is (Intl."-" (Message));
private
-- Configure the logs.
procedure Configure_Logs (Debug : in Boolean;
Dump : in Boolean;
Verbose : in Boolean);
end Mgrep;
|
-- Smart_Ptrs_Tests
-- Unit tests for Auto_Counters Smart_Ptrs package
-- Copyright (c) 2016, James Humphry - see LICENSE file for details
private with Ada.Strings.Unbounded;
with AUnit; use AUnit;
with AUnit.Test_Cases; use AUnit.Test_Cases;
with Counters_Spec;
generic
with package Counters is new Counters_Spec(others => <>);
Counter_Type_Name : String;
package Smart_Ptrs_Tests is
type Smart_Ptrs_Test is new Test_Cases.Test_Case with null record;
procedure Register_Tests (T: in out Smart_Ptrs_Test);
function Name (T : Smart_Ptrs_Test) return Test_String;
procedure Set_Up (T : in out Smart_Ptrs_Test);
procedure Check_Smart_Ptr (T : in out Test_Cases.Test_Case'Class);
procedure Check_Weak_Ptrs (T : in out Test_Cases.Test_Case'Class);
procedure Check_WP_SR (T : in out Test_Cases.Test_Case'Class);
procedure Check_Smart_Ref (T : in out Test_Cases.Test_Case'Class);
procedure Check_SP_SR (T : in out Test_Cases.Test_Case'Class);
private
-- RM 3.10.2(32) means we cannot hide this away inside the body of the
-- generic unit - the use of unbounded strings and the Test_Details type
-- is just to make things less irritating.
use Ada.Strings.Unbounded;
function "+"(Source : in String) return Unbounded_String
renames To_Unbounded_String;
type Test_Details is
record
T : Test_Routine;
D : Unbounded_String;
end record;
Test_Details_List: array (Positive range <>) of Test_Details :=
( (Check_Smart_Ptr'Access, +"Check Smart_Ptr"),
(Check_Weak_Ptrs'Access, +"Check Weak_Ptr & Smart_Ptr interaction"),
(Check_WP_SR'Access, +"Check Weak_Ptr & Smart_Ref interaction"),
(Check_Smart_Ref'Access, +"Check Smart_Ref"),
(Check_SP_SR'Access, +"CheckSmart_Ptr & Smart_Ref interaction")
);
end Smart_Ptrs_Tests;
|
with Ada.Text_IO;
with ship;
with Planet;
with Player;
with Rule;
procedure main is
my_ship: ship.Ship_Data := ship.is_StarShip;
my_homeworld : Planet.Object := Planet.Build ("Earth", 1, 3, 1);
your_homeworld : Planet.Object := Planet.Build ("Moon", 1, 3, 1);
player1 : Player.Object := Player.Build ("human",
Rule.starship_power,
Rule.hard_build,
Rule.military,
my_homeworld);
begin
Ada.Text_IO.Put_Line ("my ship: " & ship.show_me_ship_type (my_ship));
Ada.Text_IO.Put_Line ("my ship before build: " & Integer'Image (ship.show_me_ship_data (my_ship, ship.build)));
ship.modify_ship_data (my_ship, ship.build, 1);
Ada.Text_IO.Put_Line ("my ship after build: " & Integer'Image (ship.show_me_ship_data (my_ship, ship.build)));
Ada.Text_IO.Put_Line (my_homeworld.show);
Ada.Text_IO.Put_Line (your_homeworld.show);
end main;
|
-- Copyright 2017 Jeff Foley. All rights reserved.
-- Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
local url = require("url")
name = "Bing"
type = "scrape"
function start()
setratelimit(1)
end
function vertical(ctx, domain)
for i=1,201,10 do
local ok = scrape(ctx, {['url']=buildurl(domain, i)})
if not ok then
break
end
checkratelimit()
end
end
function buildurl(domain, pagenum)
local query = "domain:" .. domain .. " -site:www." .. domain
local params = {
q=query,
first=pagenum,
FORM="PORE",
}
return "https://www.bing.com/search?" .. url.build_query_string(params)
end
|
-- C97203A.ADA
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
-- CHECK THAT A CONDITIONAL_ENTRY_CALL CAN APPEAR IN PLACES WHERE A
-- SELECTIVE_WAIT CANNOT.
-- PART 1: PACKAGE BODY EMBEDDED IN TASK BODY.
-- RM 4/01/1982
WITH REPORT;
USE REPORT;
PROCEDURE C97203A IS
BEGIN
TEST ( "C97203A" , "CHECK THAT A CONDITIONAL_ENTRY_CALL CAN" &
" APPEAR WHERE A SELECTIVE_WAIT CANNOT" );
-------------------------------------------------------------------
DECLARE
TASK TT IS
ENTRY A ( AUTHORIZED : IN BOOLEAN );
END TT ;
TASK BODY TT IS
PACKAGE WITHIN_TASK_BODY IS
-- NOTHING HERE
END WITHIN_TASK_BODY ;
PACKAGE BODY WITHIN_TASK_BODY IS
BEGIN
SELECT -- NOT A SELECTIVE_WAIT
A ( FALSE ) ; -- CALLING (OWN) ENTRY
ELSE
COMMENT( "ALTERNATIVE BRANCH TAKEN" );
END SELECT;
END WITHIN_TASK_BODY ;
BEGIN
ACCEPT A ( AUTHORIZED : IN BOOLEAN ) DO
IF AUTHORIZED THEN
COMMENT( "AUTHORIZED ENTRY_CALL" );
ELSE
FAILED( "UNAUTHORIZED ENTRY_CALL" );
END IF;
END A ;
END TT ;
PACKAGE OUTSIDE_TASK_BODY IS
-- NOTHING HERE
END OUTSIDE_TASK_BODY ;
PACKAGE BODY OUTSIDE_TASK_BODY IS
BEGIN
SELECT -- NOT A SELECTIVE_WAIT
TT.A ( FALSE ) ; -- UNBORN
ELSE
COMMENT( "(OUT:) ALTERNATIVE BRANCH TAKEN" );
END SELECT;
END OUTSIDE_TASK_BODY ;
BEGIN
TT.A ( TRUE );
EXCEPTION
WHEN TASKING_ERROR =>
FAILED( "TASKING ERROR" );
END ;
-------------------------------------------------------------------
RESULT ;
END C97203A ;
|
with Aliasing;
procedure ATest
is
begin
Aliasing.Test;
end ATest;
|
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME LIBRARY COMPONENTS --
-- --
-- S Y S T E M . C O M P A R E _ A R R A Y _ S I G N E D _ 16 --
-- --
-- B o d y --
-- --
-- Copyright (C) 2002-2005 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 2, 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 COPYING. If not, write --
-- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
-- Boston, MA 02110-1301, 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. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with System.Address_Operations; use System.Address_Operations;
with Unchecked_Conversion;
package body System.Compare_Array_Signed_16 is
type Word is mod 2 ** 32;
-- Used to process operands by words
type Half is range -(2 ** 15) .. (2 ** 15) - 1;
for Half'Size use 16;
-- Used to process operands by half words
type Uhalf is record
H : Half;
end record;
pragma Pack (Uhalf);
for Uhalf'Alignment use 1;
-- Used to process operands when unaligned
type WP is access Word;
type HP is access Half;
type UP is access Uhalf;
function W is new Unchecked_Conversion (Address, WP);
function H is new Unchecked_Conversion (Address, HP);
function U is new Unchecked_Conversion (Address, UP);
-----------------------
-- Compare_Array_S16 --
-----------------------
function Compare_Array_S16
(Left : System.Address;
Right : System.Address;
Left_Len : Natural;
Right_Len : Natural) return Integer
is
Clen : Natural := Natural'Min (Left_Len, Right_Len);
-- Number of elements left to compare
L : Address := Left;
R : Address := Right;
-- Pointers to next elements to compare
begin
-- Go by words if possible
if ModA (OrA (Left, Right), 4) = 0 then
while Clen > 1
and then W (L).all = W (R).all
loop
Clen := Clen - 2;
L := AddA (L, 4);
R := AddA (R, 4);
end loop;
end if;
-- Case of going by aligned half words
if ModA (OrA (Left, Right), 2) = 0 then
while Clen /= 0 loop
if H (L).all /= H (R).all then
if H (L).all > H (R).all then
return +1;
else
return -1;
end if;
end if;
Clen := Clen - 1;
L := AddA (L, 2);
R := AddA (R, 2);
end loop;
-- Case of going by unaligned half words
else
while Clen /= 0 loop
if U (L).H /= U (R).H then
if U (L).H > U (R).H then
return +1;
else
return -1;
end if;
end if;
Clen := Clen - 1;
L := AddA (L, 2);
R := AddA (R, 2);
end loop;
end if;
-- Here if common section equal, result decided by lengths
if Left_Len = Right_Len then
return 0;
elsif Left_Len > Right_Len then
return +1;
else
return -1;
end if;
end Compare_Array_S16;
end System.Compare_Array_Signed_16;
|
with Ada.Text_IO; use Ada.Text_IO;
procedure Greet_5b is
I : Integer := 1; -- Variable declaration
-- ^ Type
-- ^ Initial value
begin
loop
Put_Line ("Hello, World!" & Integer'Image (I));
exit when I = 5; -- Exit statement
-- ^ Boolean condition
-- Assignment
I := I + 1; -- There is no i++ short form to increment a variable
end loop;
end Greet_5b;
|
with Ada.Text_IO;
procedure Program is
Comment_Characters : String := "#;";
begin
loop
declare
Line : String := Ada.Text_IO.Get_Line;
begin
exit when Line'Length = 0;
Outer_Loop : for I in Line'Range loop
for J in Comment_Characters'Range loop
if Comment_Characters(J) = Line(I) then
Ada.Text_IO.Put_Line(Line(Line'First .. I - 1));
exit Outer_Loop;
end if;
end loop;
end loop Outer_Loop;
end;
end loop;
end Program;
|
------------------------------------------------------------------------------
-- --
-- GNU ADA RUN-TIME LIBRARY (GNARL) COMPONENTS --
-- --
-- S Y S T E M . T A S K _ P R I M I T I V E S . O P E R A T I O N S --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2006, Free Software Foundation, Inc. --
-- --
-- GNARL 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 2, or (at your option) any later ver- --
-- sion. GNARL 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 GNARL; see file COPYING. If not, write --
-- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
-- Boston, MA 02110-1301, 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. --
-- --
-- GNARL was developed by the GNARL team at Florida State University. --
-- Extensive contributions were provided by Ada Core Technologies, Inc. --
-- --
------------------------------------------------------------------------------
-- This is a GNU/Linux (GNU/LinuxThreads) version of this package
-- This package contains all the GNULL primitives that interface directly
-- with the underlying OS.
pragma Polling (Off);
-- Turn off polling, we do not want ATC polling to take place during
-- tasking operations. It causes infinite loops and other problems.
with Interfaces.C;
-- used for int
-- size_t
with System.Tasking.Debug;
-- used for Known_Tasks
with System.Interrupt_Management;
-- used for Keep_Unmasked
-- Abort_Task_Interrupt
-- Interrupt_ID
with System.OS_Primitives;
-- used for Delay_Modes
with System.Soft_Links;
-- used for Abort_Defer/Undefer
-- We use System.Soft_Links instead of System.Tasking.Initialization
-- because the later is a higher level package that we shouldn't depend on.
-- For example when using the restricted run time, it is replaced by
-- System.Tasking.Restricted.Stages.
with Ada.Exceptions;
-- used for Raise_Exception
-- Raise_From_Signal_Handler
-- Exception_Id
with Unchecked_Conversion;
with Unchecked_Deallocation;
package body System.Task_Primitives.Operations is
package SSL renames System.Soft_Links;
use System.Tasking.Debug;
use System.Tasking;
use Interfaces.C;
use System.OS_Interface;
use System.Parameters;
use System.OS_Primitives;
----------------
-- Local Data --
----------------
-- The followings are logically constants, but need to be initialized
-- at run time.
Single_RTS_Lock : aliased RTS_Lock;
-- This is a lock to allow only one thread of control in the RTS at
-- a time; it is used to execute in mutual exclusion from all other tasks.
-- Used mainly in Single_Lock mode, but also to protect All_Tasks_List
ATCB_Key : aliased pthread_key_t;
-- Key used to find the Ada Task_Id associated with a thread
Environment_Task_Id : Task_Id;
-- A variable to hold Task_Id for the environment task
Unblocked_Signal_Mask : aliased sigset_t;
-- The set of signals that should be unblocked in all tasks
-- The followings are internal configuration constants needed
Next_Serial_Number : Task_Serial_Number := 100;
-- We start at 100, to reserve some special values for
-- using in error checking.
Time_Slice_Val : Integer;
pragma Import (C, Time_Slice_Val, "__gl_time_slice_val");
Dispatching_Policy : Character;
pragma Import (C, Dispatching_Policy, "__gl_task_dispatching_policy");
-- The following are effectively constants, but they need to
-- be initialized by calling a pthread_ function.
Mutex_Attr : aliased pthread_mutexattr_t;
Cond_Attr : aliased pthread_condattr_t;
Foreign_Task_Elaborated : aliased Boolean := True;
-- Used to identified fake tasks (i.e., non-Ada Threads)
--------------------
-- Local Packages --
--------------------
package Specific is
procedure Initialize (Environment_Task : Task_Id);
pragma Inline (Initialize);
-- Initialize various data needed by this package
function Is_Valid_Task return Boolean;
pragma Inline (Is_Valid_Task);
-- Does executing thread have a TCB?
procedure Set (Self_Id : Task_Id);
pragma Inline (Set);
-- Set the self id for the current task
function Self return Task_Id;
pragma Inline (Self);
-- Return a pointer to the Ada Task Control Block of the calling task.
end Specific;
package body Specific is separate;
-- The body of this package is target specific
---------------------------------
-- Support for foreign threads --
---------------------------------
function Register_Foreign_Thread (Thread : Thread_Id) return Task_Id;
-- Allocate and Initialize a new ATCB for the current Thread
function Register_Foreign_Thread
(Thread : Thread_Id) return Task_Id is separate;
-----------------------
-- Local Subprograms --
-----------------------
subtype unsigned_long is Interfaces.C.unsigned_long;
procedure Abort_Handler (signo : Signal);
function To_pthread_t is new Unchecked_Conversion
(unsigned_long, System.OS_Interface.pthread_t);
-------------------
-- Abort_Handler --
-------------------
procedure Abort_Handler (signo : Signal) is
pragma Unreferenced (signo);
Self_Id : constant Task_Id := Self;
Result : Interfaces.C.int;
Old_Set : aliased sigset_t;
begin
if ZCX_By_Default and then GCC_ZCX_Support then
return;
end if;
if Self_Id.Deferral_Level = 0
and then Self_Id.Pending_ATC_Level < Self_Id.ATC_Nesting_Level
and then not Self_Id.Aborting
then
Self_Id.Aborting := True;
-- Make sure signals used for RTS internal purpose are unmasked
Result := pthread_sigmask (SIG_UNBLOCK,
Unblocked_Signal_Mask'Unchecked_Access, Old_Set'Unchecked_Access);
pragma Assert (Result = 0);
raise Standard'Abort_Signal;
end if;
end Abort_Handler;
--------------
-- Lock_RTS --
--------------
procedure Lock_RTS is
begin
Write_Lock (Single_RTS_Lock'Access, Global_Lock => True);
end Lock_RTS;
----------------
-- Unlock_RTS --
----------------
procedure Unlock_RTS is
begin
Unlock (Single_RTS_Lock'Access, Global_Lock => True);
end Unlock_RTS;
-----------------
-- Stack_Guard --
-----------------
-- The underlying thread system extends the memory (up to 2MB) when needed
procedure Stack_Guard (T : ST.Task_Id; On : Boolean) is
pragma Unreferenced (T);
pragma Unreferenced (On);
begin
null;
end Stack_Guard;
--------------------
-- Get_Thread_Id --
--------------------
function Get_Thread_Id (T : ST.Task_Id) return OSI.Thread_Id is
begin
return T.Common.LL.Thread;
end Get_Thread_Id;
----------
-- Self --
----------
function Self return Task_Id renames Specific.Self;
---------------------
-- Initialize_Lock --
---------------------
-- Note: mutexes and cond_variables needed per-task basis are
-- initialized in Initialize_TCB and the Storage_Error is
-- handled. Other mutexes (such as RTS_Lock, Memory_Lock...)
-- used in RTS is initialized before any status change of RTS.
-- Therefore rasing Storage_Error in the following routines
-- should be able to be handled safely.
procedure Initialize_Lock
(Prio : System.Any_Priority;
L : access Lock)
is
pragma Unreferenced (Prio);
Result : Interfaces.C.int;
begin
Result := pthread_mutex_init (L, Mutex_Attr'Access);
pragma Assert (Result = 0 or else Result = ENOMEM);
if Result = ENOMEM then
Ada.Exceptions.Raise_Exception (Storage_Error'Identity,
"Failed to allocate a lock");
end if;
end Initialize_Lock;
procedure Initialize_Lock (L : access RTS_Lock; Level : Lock_Level) is
pragma Unreferenced (Level);
Result : Interfaces.C.int;
begin
Result := pthread_mutex_init (L, Mutex_Attr'Access);
pragma Assert (Result = 0 or else Result = ENOMEM);
if Result = ENOMEM then
raise Storage_Error;
end if;
end Initialize_Lock;
-------------------
-- Finalize_Lock --
-------------------
procedure Finalize_Lock (L : access Lock) is
Result : Interfaces.C.int;
begin
Result := pthread_mutex_destroy (L);
pragma Assert (Result = 0);
end Finalize_Lock;
procedure Finalize_Lock (L : access RTS_Lock) is
Result : Interfaces.C.int;
begin
Result := pthread_mutex_destroy (L);
pragma Assert (Result = 0);
end Finalize_Lock;
----------------
-- Write_Lock --
----------------
procedure Write_Lock (L : access Lock; Ceiling_Violation : out Boolean) is
Result : Interfaces.C.int;
begin
Result := pthread_mutex_lock (L);
Ceiling_Violation := Result = EINVAL;
-- Assume the cause of EINVAL is a priority ceiling violation
pragma Assert (Result = 0 or else Result = EINVAL);
end Write_Lock;
procedure Write_Lock
(L : access RTS_Lock;
Global_Lock : Boolean := False)
is
Result : Interfaces.C.int;
begin
if not Single_Lock or else Global_Lock then
Result := pthread_mutex_lock (L);
pragma Assert (Result = 0);
end if;
end Write_Lock;
procedure Write_Lock (T : Task_Id) is
Result : Interfaces.C.int;
begin
if not Single_Lock then
Result := pthread_mutex_lock (T.Common.LL.L'Access);
pragma Assert (Result = 0);
end if;
end Write_Lock;
---------------
-- Read_Lock --
---------------
procedure Read_Lock (L : access Lock; Ceiling_Violation : out Boolean) is
begin
Write_Lock (L, Ceiling_Violation);
end Read_Lock;
------------
-- Unlock --
------------
procedure Unlock (L : access Lock) is
Result : Interfaces.C.int;
begin
Result := pthread_mutex_unlock (L);
pragma Assert (Result = 0);
end Unlock;
procedure Unlock (L : access RTS_Lock; Global_Lock : Boolean := False) is
Result : Interfaces.C.int;
begin
if not Single_Lock or else Global_Lock then
Result := pthread_mutex_unlock (L);
pragma Assert (Result = 0);
end if;
end Unlock;
procedure Unlock (T : Task_Id) is
Result : Interfaces.C.int;
begin
if not Single_Lock then
Result := pthread_mutex_unlock (T.Common.LL.L'Access);
pragma Assert (Result = 0);
end if;
end Unlock;
-----------
-- Sleep --
-----------
procedure Sleep
(Self_ID : Task_Id;
Reason : System.Tasking.Task_States)
is
pragma Unreferenced (Reason);
Result : Interfaces.C.int;
begin
pragma Assert (Self_ID = Self);
if Single_Lock then
Result := pthread_cond_wait
(Self_ID.Common.LL.CV'Access, Single_RTS_Lock'Access);
else
Result := pthread_cond_wait
(Self_ID.Common.LL.CV'Access, Self_ID.Common.LL.L'Access);
end if;
-- EINTR is not considered a failure
pragma Assert (Result = 0 or else Result = EINTR);
end Sleep;
-----------------
-- Timed_Sleep --
-----------------
-- This is for use within the run-time system, so abort is
-- assumed to be already deferred, and the caller should be
-- holding its own ATCB lock.
procedure Timed_Sleep
(Self_ID : Task_Id;
Time : Duration;
Mode : ST.Delay_Modes;
Reason : System.Tasking.Task_States;
Timedout : out Boolean;
Yielded : out Boolean)
is
pragma Unreferenced (Reason);
Check_Time : constant Duration := Monotonic_Clock;
Abs_Time : Duration;
Request : aliased timespec;
Result : Interfaces.C.int;
begin
Timedout := True;
Yielded := False;
if Mode = Relative then
Abs_Time := Duration'Min (Time, Max_Sensible_Delay) + Check_Time;
else
Abs_Time := Duration'Min (Check_Time + Max_Sensible_Delay, Time);
end if;
if Abs_Time > Check_Time then
Request := To_Timespec (Abs_Time);
loop
exit when Self_ID.Pending_ATC_Level < Self_ID.ATC_Nesting_Level
or else Self_ID.Pending_Priority_Change;
if Single_Lock then
Result := pthread_cond_timedwait
(Self_ID.Common.LL.CV'Access, Single_RTS_Lock'Access,
Request'Access);
else
Result := pthread_cond_timedwait
(Self_ID.Common.LL.CV'Access, Self_ID.Common.LL.L'Access,
Request'Access);
end if;
exit when Abs_Time <= Monotonic_Clock;
if Result = 0 or Result = EINTR then
-- somebody may have called Wakeup for us
Timedout := False;
exit;
end if;
pragma Assert (Result = ETIMEDOUT);
end loop;
end if;
end Timed_Sleep;
-----------------
-- Timed_Delay --
-----------------
-- This is for use in implementing delay statements, so
-- we assume the caller is abort-deferred but is holding
-- no locks.
procedure Timed_Delay
(Self_ID : Task_Id;
Time : Duration;
Mode : ST.Delay_Modes)
is
Check_Time : constant Duration := Monotonic_Clock;
Abs_Time : Duration;
Request : aliased timespec;
Result : Interfaces.C.int;
begin
if Single_Lock then
Lock_RTS;
end if;
Write_Lock (Self_ID);
if Mode = Relative then
Abs_Time := Time + Check_Time;
else
Abs_Time := Duration'Min (Check_Time + Max_Sensible_Delay, Time);
end if;
if Abs_Time > Check_Time then
Request := To_Timespec (Abs_Time);
Self_ID.Common.State := Delay_Sleep;
loop
if Self_ID.Pending_Priority_Change then
Self_ID.Pending_Priority_Change := False;
Self_ID.Common.Base_Priority := Self_ID.New_Base_Priority;
Set_Priority (Self_ID, Self_ID.Common.Base_Priority);
end if;
exit when Self_ID.Pending_ATC_Level < Self_ID.ATC_Nesting_Level;
if Single_Lock then
Result := pthread_cond_timedwait (Self_ID.Common.LL.CV'Access,
Single_RTS_Lock'Access, Request'Access);
else
Result := pthread_cond_timedwait (Self_ID.Common.LL.CV'Access,
Self_ID.Common.LL.L'Access, Request'Access);
end if;
exit when Abs_Time <= Monotonic_Clock;
pragma Assert (Result = 0 or else
Result = ETIMEDOUT or else
Result = EINTR);
end loop;
Self_ID.Common.State := Runnable;
end if;
Unlock (Self_ID);
if Single_Lock then
Unlock_RTS;
end if;
Result := sched_yield;
end Timed_Delay;
---------------------
-- Monotonic_Clock --
---------------------
function Monotonic_Clock return Duration is
TV : aliased struct_timeval;
Result : Interfaces.C.int;
begin
Result := gettimeofday (TV'Access, System.Null_Address);
pragma Assert (Result = 0);
return To_Duration (TV);
end Monotonic_Clock;
-------------------
-- RT_Resolution --
-------------------
function RT_Resolution return Duration is
begin
return 10#1.0#E-6;
end RT_Resolution;
------------
-- Wakeup --
------------
procedure Wakeup (T : Task_Id; Reason : System.Tasking.Task_States) is
pragma Unreferenced (Reason);
Result : Interfaces.C.int;
begin
Result := pthread_cond_signal (T.Common.LL.CV'Access);
pragma Assert (Result = 0);
end Wakeup;
-----------
-- Yield --
-----------
procedure Yield (Do_Yield : Boolean := True) is
Result : Interfaces.C.int;
pragma Unreferenced (Result);
begin
if Do_Yield then
Result := sched_yield;
end if;
end Yield;
------------------
-- Set_Priority --
------------------
procedure Set_Priority
(T : Task_Id;
Prio : System.Any_Priority;
Loss_Of_Inheritance : Boolean := False)
is
pragma Unreferenced (Loss_Of_Inheritance);
Result : Interfaces.C.int;
Param : aliased struct_sched_param;
begin
T.Common.Current_Priority := Prio;
-- Priorities are in range 1 .. 99 on GNU/Linux, so we map
-- map 0 .. 31 to 1 .. 32
Param.sched_priority := Interfaces.C.int (Prio) + 1;
if Time_Slice_Val > 0 then
Result := pthread_setschedparam
(T.Common.LL.Thread, SCHED_RR, Param'Access);
elsif Dispatching_Policy = 'F' or else Time_Slice_Val = 0 then
Result := pthread_setschedparam
(T.Common.LL.Thread, SCHED_FIFO, Param'Access);
else
Param.sched_priority := 0;
Result := pthread_setschedparam
(T.Common.LL.Thread, SCHED_OTHER, Param'Access);
end if;
pragma Assert (Result = 0 or else Result = EPERM);
end Set_Priority;
------------------
-- Get_Priority --
------------------
function Get_Priority (T : Task_Id) return System.Any_Priority is
begin
return T.Common.Current_Priority;
end Get_Priority;
----------------
-- Enter_Task --
----------------
procedure Enter_Task (Self_ID : Task_Id) is
begin
Self_ID.Common.LL.Thread := pthread_self;
Specific.Set (Self_ID);
Lock_RTS;
for J in Known_Tasks'Range loop
if Known_Tasks (J) = null then
Known_Tasks (J) := Self_ID;
Self_ID.Known_Tasks_Index := J;
exit;
end if;
end loop;
Unlock_RTS;
end Enter_Task;
--------------
-- New_ATCB --
--------------
function New_ATCB (Entry_Num : Task_Entry_Index) return Task_Id is
begin
return new Ada_Task_Control_Block (Entry_Num);
end New_ATCB;
-------------------
-- Is_Valid_Task --
-------------------
function Is_Valid_Task return Boolean renames Specific.Is_Valid_Task;
-----------------------------
-- Register_Foreign_Thread --
-----------------------------
function Register_Foreign_Thread return Task_Id is
begin
if Is_Valid_Task then
return Self;
else
return Register_Foreign_Thread (pthread_self);
end if;
end Register_Foreign_Thread;
--------------------
-- Initialize_TCB --
--------------------
procedure Initialize_TCB (Self_ID : Task_Id; Succeeded : out Boolean) is
Result : Interfaces.C.int;
begin
-- Give the task a unique serial number
Self_ID.Serial_Number := Next_Serial_Number;
Next_Serial_Number := Next_Serial_Number + 1;
pragma Assert (Next_Serial_Number /= 0);
Self_ID.Common.LL.Thread := To_pthread_t (-1);
if not Single_Lock then
Result := pthread_mutex_init (Self_ID.Common.LL.L'Access,
Mutex_Attr'Access);
pragma Assert (Result = 0 or else Result = ENOMEM);
if Result /= 0 then
Succeeded := False;
return;
end if;
end if;
Result := pthread_cond_init (Self_ID.Common.LL.CV'Access,
Cond_Attr'Access);
pragma Assert (Result = 0 or else Result = ENOMEM);
if Result = 0 then
Succeeded := True;
else
if not Single_Lock then
Result := pthread_mutex_destroy (Self_ID.Common.LL.L'Access);
pragma Assert (Result = 0);
end if;
Succeeded := False;
end if;
end Initialize_TCB;
-----------------
-- Create_Task --
-----------------
procedure Create_Task
(T : Task_Id;
Wrapper : System.Address;
Stack_Size : System.Parameters.Size_Type;
Priority : System.Any_Priority;
Succeeded : out Boolean)
is
Attributes : aliased pthread_attr_t;
Result : Interfaces.C.int;
begin
Result := pthread_attr_init (Attributes'Access);
pragma Assert (Result = 0 or else Result = ENOMEM);
if Result /= 0 then
Succeeded := False;
return;
end if;
Result :=
pthread_attr_setstacksize
(Attributes'Access, Interfaces.C.size_t (Stack_Size));
pragma Assert (Result = 0);
Result :=
pthread_attr_setdetachstate
(Attributes'Access, PTHREAD_CREATE_DETACHED);
pragma Assert (Result = 0);
-- Since the initial signal mask of a thread is inherited from the
-- creator, and the Environment task has all its signals masked, we
-- do not need to manipulate caller's signal mask at this point.
-- All tasks in RTS will have All_Tasks_Mask initially.
Result := pthread_create
(T.Common.LL.Thread'Access,
Attributes'Access,
Thread_Body_Access (Wrapper),
To_Address (T));
pragma Assert (Result = 0 or else Result = EAGAIN);
Succeeded := Result = 0;
Result := pthread_attr_destroy (Attributes'Access);
pragma Assert (Result = 0);
Set_Priority (T, Priority);
end Create_Task;
------------------
-- Finalize_TCB --
------------------
procedure Finalize_TCB (T : Task_Id) is
Result : Interfaces.C.int;
Tmp : Task_Id := T;
Is_Self : constant Boolean := T = Self;
procedure Free is new
Unchecked_Deallocation (Ada_Task_Control_Block, Task_Id);
begin
if not Single_Lock then
Result := pthread_mutex_destroy (T.Common.LL.L'Access);
pragma Assert (Result = 0);
end if;
Result := pthread_cond_destroy (T.Common.LL.CV'Access);
pragma Assert (Result = 0);
if T.Known_Tasks_Index /= -1 then
Known_Tasks (T.Known_Tasks_Index) := null;
end if;
Free (Tmp);
if Is_Self then
Specific.Set (null);
end if;
end Finalize_TCB;
---------------
-- Exit_Task --
---------------
procedure Exit_Task is
begin
Specific.Set (null);
end Exit_Task;
----------------
-- Abort_Task --
----------------
procedure Abort_Task (T : Task_Id) is
Result : Interfaces.C.int;
begin
Result := pthread_kill (T.Common.LL.Thread,
Signal (System.Interrupt_Management.Abort_Task_Interrupt));
pragma Assert (Result = 0);
end Abort_Task;
----------------
-- Initialize --
----------------
procedure Initialize (S : in out Suspension_Object) is
Result : Interfaces.C.int;
begin
-- Initialize internal state. It is always initialized to False (ARM
-- D.10 par. 6).
S.State := False;
S.Waiting := False;
-- Initialize internal mutex
Result := pthread_mutex_init (S.L'Access, Mutex_Attr'Access);
pragma Assert (Result = 0 or else Result = ENOMEM);
if Result = ENOMEM then
raise Storage_Error;
end if;
-- Initialize internal condition variable
Result := pthread_cond_init (S.CV'Access, Cond_Attr'Access);
pragma Assert (Result = 0 or else Result = ENOMEM);
if Result /= 0 then
Result := pthread_mutex_destroy (S.L'Access);
pragma Assert (Result = 0);
if Result = ENOMEM then
raise Storage_Error;
end if;
end if;
end Initialize;
--------------
-- Finalize --
--------------
procedure Finalize (S : in out Suspension_Object) is
Result : Interfaces.C.int;
begin
-- Destroy internal mutex
Result := pthread_mutex_destroy (S.L'Access);
pragma Assert (Result = 0);
-- Destroy internal condition variable
Result := pthread_cond_destroy (S.CV'Access);
pragma Assert (Result = 0);
end Finalize;
-------------------
-- Current_State --
-------------------
function Current_State (S : Suspension_Object) return Boolean is
begin
-- We do not want to use lock on this read operation. State is marked
-- as Atomic so that we ensure that the value retrieved is correct.
return S.State;
end Current_State;
---------------
-- Set_False --
---------------
procedure Set_False (S : in out Suspension_Object) is
Result : Interfaces.C.int;
begin
SSL.Abort_Defer.all;
Result := pthread_mutex_lock (S.L'Access);
pragma Assert (Result = 0);
S.State := False;
Result := pthread_mutex_unlock (S.L'Access);
pragma Assert (Result = 0);
SSL.Abort_Undefer.all;
end Set_False;
--------------
-- Set_True --
--------------
procedure Set_True (S : in out Suspension_Object) is
Result : Interfaces.C.int;
begin
SSL.Abort_Defer.all;
Result := pthread_mutex_lock (S.L'Access);
pragma Assert (Result = 0);
-- If there is already a task waiting on this suspension object then
-- we resume it, leaving the state of the suspension object to False,
-- as it is specified in ARM D.10 par. 9. Otherwise, it just leaves
-- the state to True.
if S.Waiting then
S.Waiting := False;
S.State := False;
Result := pthread_cond_signal (S.CV'Access);
pragma Assert (Result = 0);
else
S.State := True;
end if;
Result := pthread_mutex_unlock (S.L'Access);
pragma Assert (Result = 0);
SSL.Abort_Undefer.all;
end Set_True;
------------------------
-- Suspend_Until_True --
------------------------
procedure Suspend_Until_True (S : in out Suspension_Object) is
Result : Interfaces.C.int;
begin
SSL.Abort_Defer.all;
Result := pthread_mutex_lock (S.L'Access);
pragma Assert (Result = 0);
if S.Waiting then
-- Program_Error must be raised upon calling Suspend_Until_True
-- if another task is already waiting on that suspension object
-- (ARM D.10 par. 10).
Result := pthread_mutex_unlock (S.L'Access);
pragma Assert (Result = 0);
SSL.Abort_Undefer.all;
raise Program_Error;
else
-- Suspend the task if the state is False. Otherwise, the task
-- continues its execution, and the state of the suspension object
-- is set to False (ARM D.10 par. 9).
if S.State then
S.State := False;
else
S.Waiting := True;
Result := pthread_cond_wait (S.CV'Access, S.L'Access);
end if;
Result := pthread_mutex_unlock (S.L'Access);
pragma Assert (Result = 0);
SSL.Abort_Undefer.all;
end if;
end Suspend_Until_True;
----------------
-- Check_Exit --
----------------
-- Dummy version
function Check_Exit (Self_ID : ST.Task_Id) return Boolean is
pragma Unreferenced (Self_ID);
begin
return True;
end Check_Exit;
--------------------
-- Check_No_Locks --
--------------------
function Check_No_Locks (Self_ID : ST.Task_Id) return Boolean is
pragma Unreferenced (Self_ID);
begin
return True;
end Check_No_Locks;
----------------------
-- Environment_Task --
----------------------
function Environment_Task return Task_Id is
begin
return Environment_Task_Id;
end Environment_Task;
------------------
-- Suspend_Task --
------------------
function Suspend_Task
(T : ST.Task_Id;
Thread_Self : Thread_Id) return Boolean
is
begin
if T.Common.LL.Thread /= Thread_Self then
return pthread_kill (T.Common.LL.Thread, SIGSTOP) = 0;
else
return True;
end if;
end Suspend_Task;
-----------------
-- Resume_Task --
-----------------
function Resume_Task
(T : ST.Task_Id;
Thread_Self : Thread_Id) return Boolean
is
begin
if T.Common.LL.Thread /= Thread_Self then
return pthread_kill (T.Common.LL.Thread, SIGCONT) = 0;
else
return True;
end if;
end Resume_Task;
----------------
-- Initialize --
----------------
procedure Initialize (Environment_Task : Task_Id) is
act : aliased struct_sigaction;
old_act : aliased struct_sigaction;
Tmp_Set : aliased sigset_t;
Result : Interfaces.C.int;
function State
(Int : System.Interrupt_Management.Interrupt_ID) return Character;
pragma Import (C, State, "__gnat_get_interrupt_state");
-- Get interrupt state. Defined in a-init.c
-- The input argument is the interrupt number,
-- and the result is one of the following:
Default : constant Character := 's';
-- 'n' this interrupt not set by any Interrupt_State pragma
-- 'u' Interrupt_State pragma set state to User
-- 'r' Interrupt_State pragma set state to Runtime
-- 's' Interrupt_State pragma set state to System (use "default"
-- system handler)
begin
Environment_Task_Id := Environment_Task;
Interrupt_Management.Initialize;
-- Prepare the set of signals that should be unblocked in all tasks
Result := sigemptyset (Unblocked_Signal_Mask'Access);
pragma Assert (Result = 0);
for J in Interrupt_Management.Interrupt_ID loop
if System.Interrupt_Management.Keep_Unmasked (J) then
Result := sigaddset (Unblocked_Signal_Mask'Access, Signal (J));
pragma Assert (Result = 0);
end if;
end loop;
Result := pthread_mutexattr_init (Mutex_Attr'Access);
pragma Assert (Result = 0);
Result := pthread_condattr_init (Cond_Attr'Access);
pragma Assert (Result = 0);
Initialize_Lock (Single_RTS_Lock'Access, RTS_Lock_Level);
-- Initialize the global RTS lock
Specific.Initialize (Environment_Task);
Enter_Task (Environment_Task);
-- Install the abort-signal handler
if State (System.Interrupt_Management.Abort_Task_Interrupt)
/= Default
then
act.sa_flags := 0;
act.sa_handler := Abort_Handler'Address;
Result := sigemptyset (Tmp_Set'Access);
pragma Assert (Result = 0);
act.sa_mask := Tmp_Set;
Result :=
sigaction
(Signal (Interrupt_Management.Abort_Task_Interrupt),
act'Unchecked_Access,
old_act'Unchecked_Access);
pragma Assert (Result = 0);
end if;
end Initialize;
end System.Task_Primitives.Operations;
|
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- S Y S T E M . M A C H I N E _ R E S E T --
-- --
-- B o d y --
-- --
-- Copyright (C) 2011-2013, 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. --
-- --
-- --
-- --
-- --
-- --
-- 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 Interfaces;
package body System.Machine_Reset is
procedure Os_Exit (Status : Integer);
pragma No_Return (Os_Exit);
pragma Export (Ada, Os_Exit, "exit");
-- Shutdown or restart the board
procedure Os_Abort;
pragma No_Return (Os_Abort);
pragma Export (Ada, Os_Abort, "abort");
-- Likewise
--------------
-- Os_Abort --
--------------
procedure Os_Abort is
begin
Os_Exit (1);
end Os_Abort;
-------------
-- Os_Exit --
-------------
procedure Os_Exit (Status : Integer) is
pragma Unreferenced (Status);
-- The parameter is just for ISO-C compatibility
APINT : Interfaces.Unsigned_32;
for APINT'Address use 16#E000_ED0C#;
pragma Import (Ada, APINT);
pragma Volatile (APINT);
begin
APINT := 16#05FA_0004#;
loop
null;
end loop;
end Os_Exit;
----------
-- Stop --
----------
procedure Stop is
begin
Os_Exit (0);
end Stop;
end System.Machine_Reset;
|
with Ada.Environment_Variables; use Ada.Environment_Variables;
with Ada.Text_IO; use Ada.Text_IO;
with Interfaces; use Interfaces;
with Interfaces.C; use Interfaces.C;
with System; use System;
with Ada.Unchecked_Conversion;
procedure outcomes is
type stack is array (0..9) of Integer;
deck : stack;
D, P, N : Integer;
function dlopen (filename : char_array; flag : int) return address;
pragma import (c, dlopen);
function dlsym (handle : address; symbol : char_array) return address;
pragma import (c, dlsym);
type partitions is access function (cards: out Stack; subtotal: Integer) return Integer;
pragma Convention (C, partitions);
function To_Ptr is new Ada.Unchecked_Conversion (Address, partitions);
library : address := dlopen (to_c ("./libpartitions.so"), 1);
zpartitions : partitions := to_ptr (dlsym (library, to_c ("partitions")));
begin
deck := (4,4,4,4,4,4,4,4,4,16);
d := 0;
for I in Integer range 0 .. 9 loop
-- Dealer showing
Deck(I) := Deck(I)-1;
p := 0;
for j in Integer range 0 .. 9 loop
Deck(J) := Deck(J)-1;
n := zpartitions(deck, j+1);
Deck(J) := Deck(J)+1;
p := P+N;
end loop;
Put_Line ("Dealer showing " & Integer'Image(I) & " partitions =" & Integer'Image(P));
d := D+P;
Deck(I) := Deck(I)+1;
end loop;
Put_Line ("Total partitions =" & Integer'Image(D));
end Outcomes;
|
------------------------------------------------------------------------------
-- --
-- GNAT LIBRARY COMPONENTS --
-- --
-- ADA.CONTAINERS.GENERIC_SORT --
-- --
-- S p e c --
-- --
-- Copyright (C) 2011-2020, 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/>. --
-- --
-- This unit was originally developed by Matthew J Heaney. --
------------------------------------------------------------------------------
-- Allows an anonymous array (or array-like container) to be sorted. Generic
-- formal Before returns the result of comparing the elements designated by
-- the indexes, and generic formal Swap exchanges the designated elements.
generic
type Index_Type is (<>);
with function Before (Left, Right : Index_Type) return Boolean;
with procedure Swap (Left, Right : Index_Type);
procedure Ada.Containers.Generic_Sort (First, Last : Index_Type'Base);
pragma Pure (Ada.Containers.Generic_Sort);
-- Reorders the elements of an indexable structure, over the range
-- First .. Last, such that the elements are sorted in the ordering determined
-- by the generic formal function Before; Before should return True if Left is
-- to be sorted before Right. The generic formal Before compares the elements
-- having the given indices, and the generic formal Swap exchanges the values
-- of the indicated elements. Any exception raised during evaluation of Before
-- or Swap is propagated.
--
-- The actual function for the generic formal function "<" is expected to
-- return the same value each time it is called with a particular pair of
-- element values. It should not modify Container and it should define a
-- strict weak ordering relationship: irreflexive, asymmetric, transitive, and
-- in addition, if x < y for any values x and y, then for all other values z,
-- (x < z) or (z < y). If the actual for "<" behaves in some other manner,
-- the behavior of the instance of Generic_Sort is unspecified. The number of
-- times Generic_Sort calls "<" is unspecified.
|
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --
-- --
-- S Y S T E M . S T R I N G _ O P S --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2020, 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. --
-- --
------------------------------------------------------------------------------
-- NOTE: This package is obsolescent. It is no longer used by the compiler
-- which now generates concatenation inline. It is retained only because
-- it may be used during bootstrapping using old versions of the compiler.
pragma Compiler_Unit_Warning;
package body System.String_Ops is
----------------
-- Str_Concat --
----------------
function Str_Concat (X, Y : String) return String is
begin
if X'Length = 0 then
return Y;
else
declare
L : constant Natural := X'Length + Y'Length;
R : String (X'First .. X'First + L - 1);
begin
R (X'Range) := X;
R (X'First + X'Length .. R'Last) := Y;
return R;
end;
end if;
end Str_Concat;
-------------------
-- Str_Concat_CC --
-------------------
function Str_Concat_CC (X, Y : Character) return String is
R : String (1 .. 2);
begin
R (1) := X;
R (2) := Y;
return R;
end Str_Concat_CC;
-------------------
-- Str_Concat_CS --
-------------------
function Str_Concat_CS (X : Character; Y : String) return String is
R : String (1 .. Y'Length + 1);
begin
R (1) := X;
R (2 .. R'Last) := Y;
return R;
end Str_Concat_CS;
-------------------
-- Str_Concat_SC --
-------------------
function Str_Concat_SC (X : String; Y : Character) return String is
begin
if X'Length = 0 then
return (1 => Y);
else
declare
R : String (X'First .. X'Last + 1);
begin
R (X'Range) := X;
R (R'Last) := Y;
return R;
end;
end if;
end Str_Concat_SC;
end System.String_Ops;
|
-- Copyright (C) 2015-2021 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/>.
package body Pck is
procedure Update_Signed_Small (S : in out Signed_Small) is
begin
null;
end Update_Signed_Small;
end Pck;
|
with GNAT.OS_Lib;
with TOML.File_IO;
with Simple_Logging;
package body CLIC.Config.Load is
package Trace renames Simple_Logging;
use TOML;
---------------
-- From_TOML --
---------------
procedure From_TOML (C : in out CLIC.Config.Instance;
Origin : String;
Path : String;
Check : Check_Import := null)
is
Table : constant TOML_Value := Load_TOML_File (Path);
begin
C.Import (Table, Origin, Check => Check);
end From_TOML;
--------------------
-- Load_TOML_File --
--------------------
function Load_TOML_File (Path : String) return TOML.TOML_Value is
begin
if GNAT.OS_Lib.Is_Read_Accessible_File (Path) then
declare
Config : constant TOML.Read_Result :=
TOML.File_IO.Load_File (Path);
begin
if Config.Success then
if Config.Value.Kind /= TOML.TOML_Table then
Trace.Error ("Bad config file '" & Path &
"': TOML table expected.");
else
return Config.Value;
end if;
else
Trace.Detail ("error while loading '" & Path & "':");
Trace.Detail
(Ada.Strings.Unbounded.To_String (Config.Message));
end if;
end;
else
Trace.Detail ("Config file is not readable or doesn't exist: '" &
Path & "'");
end if;
return No_TOML_Value;
end Load_TOML_File;
end CLIC.Config.Load;
|
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --
-- --
-- S Y S T E M . B B . C P U _ S P E C I F I C --
-- --
-- S p e c --
-- --
-- Copyright (C) 1999-2002 Universidad Politecnica de Madrid --
-- Copyright (C) 2003-2004 The European Space Agency --
-- Copyright (C) 2003-2015, 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 contains the primitives which are dependent on the
-- underlying processor.
pragma Restrictions (No_Elaboration_Code);
with System;
with Interfaces;
package System.BB.CPU_Specific is
pragma Preelaborate;
------------------------
-- Context management --
------------------------
-- The context buffer is a type that represents thread's state and is not
-- otherwise stored in main memory. This typically includes all user-
-- visible registers, and possibly some other status as well.
-- In case different contexts have different amounts of state (for example,
-- due to absence of a floating-point unit in a particular configuration,
-- or just the FPU not being used), it is expected that these details
-- are handled in the implementation.
type Context_Buffer is record
-- Only callee-saved (ie dedicated and nonvolatile) registers need to
-- be saved.
R1h : Interfaces.Unsigned_32;
R1 : System.Address;
R2 : Interfaces.Unsigned_64;
R13 : Interfaces.Unsigned_64;
R14h : Interfaces.Unsigned_32;
R14 : System.Address;
R15h : Interfaces.Unsigned_32;
R15 : System.Address;
R16 : Interfaces.Unsigned_64;
R17 : Interfaces.Unsigned_64;
R18 : Interfaces.Unsigned_64;
R19 : Interfaces.Unsigned_64;
R20 : Interfaces.Unsigned_64;
R21 : Interfaces.Unsigned_64;
R22 : Interfaces.Unsigned_64;
R23 : Interfaces.Unsigned_64;
R24 : Interfaces.Unsigned_64;
R25 : Interfaces.Unsigned_64;
R26 : Interfaces.Unsigned_64;
R27 : Interfaces.Unsigned_64;
R28 : Interfaces.Unsigned_64;
R29 : Interfaces.Unsigned_64;
R30 : Interfaces.Unsigned_64;
R31 : Interfaces.Unsigned_64;
CR : System.Address;
LR : System.Address;
SPEFPSCR : Interfaces.Unsigned_32;
end record;
Stack_Alignment : constant := 16;
-- Stack alignment defined by the ABI
--------------------
-- Initialization --
--------------------
procedure Initialize_CPU;
-- Initialize the CPU
procedure Finish_Initialize_Context
(Buffer : not null access Context_Buffer);
-- Complete context initialization
---------------------------------
-- Interrupt and Trap Handling --
---------------------------------
type Vector_Id is range 0 .. 63;
-- This corresponds to the IVOR number
External_Interrupt_Excp : constant Vector_Id := 4;
Decrementer_Excp : constant Vector_Id := 10;
Floatting_Point_Data_Excp : constant Vector_Id := 33;
procedure Install_Exception_Handler
(Service_Routine : System.Address;
Vector : Vector_Id);
-- Install a new handler in the exception table
procedure Install_Error_Handlers;
-- Called at system initialization time to install a CPU specific trap
-- handler, GNAT_Error_Handler, that converts synchronous traps to
-- appropriate exceptions.
-------------
-- Variant --
-------------
PowerPC_Book_E : constant Boolean := True;
-- Does the CPU implement PowerPC Book-E standard
end System.BB.CPU_Specific;
|
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- S Y S T E M . P A C K _ 0 5 --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2014, 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. --
-- --
------------------------------------------------------------------------------
with System.Storage_Elements;
with System.Unsigned_Types;
package body System.Pack_05 is
subtype Bit_Order is System.Bit_Order;
Reverse_Bit_Order : constant Bit_Order :=
Bit_Order'Val (1 - Bit_Order'Pos (System.Default_Bit_Order));
subtype Ofs is System.Storage_Elements.Storage_Offset;
subtype Uns is System.Unsigned_Types.Unsigned;
subtype N07 is System.Unsigned_Types.Unsigned range 0 .. 7;
use type System.Storage_Elements.Storage_Offset;
use type System.Unsigned_Types.Unsigned;
type Cluster is record
E0, E1, E2, E3, E4, E5, E6, E7 : Bits_05;
end record;
for Cluster use record
E0 at 0 range 0 * Bits .. 0 * Bits + Bits - 1;
E1 at 0 range 1 * Bits .. 1 * Bits + Bits - 1;
E2 at 0 range 2 * Bits .. 2 * Bits + Bits - 1;
E3 at 0 range 3 * Bits .. 3 * Bits + Bits - 1;
E4 at 0 range 4 * Bits .. 4 * Bits + Bits - 1;
E5 at 0 range 5 * Bits .. 5 * Bits + Bits - 1;
E6 at 0 range 6 * Bits .. 6 * Bits + Bits - 1;
E7 at 0 range 7 * Bits .. 7 * Bits + Bits - 1;
end record;
for Cluster'Size use Bits * 8;
for Cluster'Alignment use Integer'Min (Standard'Maximum_Alignment,
1 +
1 * Boolean'Pos (Bits mod 2 = 0) +
2 * Boolean'Pos (Bits mod 4 = 0));
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
type Cluster_Ref is access Cluster;
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
type Rev_Cluster_Ref is access Rev_Cluster;
------------
-- Get_05 --
------------
function Get_05
(Arr : System.Address;
N : Natural;
Rev_SSO : Boolean) return Bits_05
is
A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
C : Cluster_Ref with Address => A'Address, Import;
RC : Rev_Cluster_Ref with Address => A'Address, Import;
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
when 0 => return RC.E0;
when 1 => return RC.E1;
when 2 => return RC.E2;
when 3 => return RC.E3;
when 4 => return RC.E4;
when 5 => return RC.E5;
when 6 => return RC.E6;
when 7 => return RC.E7;
end case;
else
case N07 (Uns (N) mod 8) is
when 0 => return C.E0;
when 1 => return C.E1;
when 2 => return C.E2;
when 3 => return C.E3;
when 4 => return C.E4;
when 5 => return C.E5;
when 6 => return C.E6;
when 7 => return C.E7;
end case;
end if;
end Get_05;
------------
-- Set_05 --
------------
procedure Set_05
(Arr : System.Address;
N : Natural;
E : Bits_05;
Rev_SSO : Boolean)
is
A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
C : Cluster_Ref with Address => A'Address, Import;
RC : Rev_Cluster_Ref with Address => A'Address, Import;
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
when 0 => RC.E0 := E;
when 1 => RC.E1 := E;
when 2 => RC.E2 := E;
when 3 => RC.E3 := E;
when 4 => RC.E4 := E;
when 5 => RC.E5 := E;
when 6 => RC.E6 := E;
when 7 => RC.E7 := E;
end case;
else
case N07 (Uns (N) mod 8) is
when 0 => C.E0 := E;
when 1 => C.E1 := E;
when 2 => C.E2 := E;
when 3 => C.E3 := E;
when 4 => C.E4 := E;
when 5 => C.E5 := E;
when 6 => C.E6 := E;
when 7 => C.E7 := E;
end case;
end if;
end Set_05;
end System.Pack_05;
|
-----------------------------------------------------------------------
-- util-processes-tests - Test for processes
-- Copyright (C) 2011 Stephane Carrez
-- Written by Stephane Carrez (Stephane.Carrez@gmail.com)
--
-- 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.Processes.Tests is
procedure Add_Tests (Suite : in Util.Tests.Access_Test_Suite);
type Test is new Util.Tests.Test with null record;
-- Tests when the process is not launched
procedure Test_No_Process (T : in out Test);
-- Test executing a process
procedure Test_Spawn (T : in out Test);
-- Test output pipe redirection: read the process standard output
procedure Test_Output_Pipe (T : in out Test);
-- Test input pipe redirection: write the process standard input
procedure Test_Input_Pipe (T : in out Test);
-- Test launching several processes through pipes in several threads.
procedure Test_Multi_Spawn (T : in out Test);
-- Test output file redirection.
procedure Test_Output_Redirect (T : in out Test);
end Util.Processes.Tests;
|
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- S Y S T E M . F A T _ I E E E _ S H O R T _ F L O A T --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2005,2009 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. --
-- --
-- --
-- --
-- --
-- --
-- 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 an instantiation of the floating-point attribute
-- runtime routines for IEEE short float. This is used on VMS targets where
-- we can't just use Float, since this may have been mapped to Vax_Float
-- using a Float_Representation configuration pragma.
with System.Fat_Gen;
package System.Fat_IEEE_Short_Float is
pragma Pure;
type Fat_IEEE_Short is digits 6;
pragma Float_Representation (IEEE_Float, Fat_IEEE_Short);
-- Note the only entity from this package that is accessed by Rtsfind
-- is the name of the package instantiation. Entities within this package
-- (i.e. the individual floating-point attribute routines) are accessed
-- by name using selected notation.
package Attr_IEEE_Short is new System.Fat_Gen (Fat_IEEE_Short);
end System.Fat_IEEE_Short_Float;
|
pragma Ada_2005;
pragma Style_Checks (Off);
with Interfaces.C; use Interfaces.C;
with SDL_SDL_stdinc_h;
with Interfaces.C.Strings;
package SDL_SDL_cdrom_h is
SDL_MAX_TRACKS : constant := 99; -- ../include/SDL/SDL_cdrom.h:48
SDL_AUDIO_TRACK : constant := 16#00#; -- ../include/SDL/SDL_cdrom.h:54
SDL_DATA_TRACK : constant := 16#04#; -- ../include/SDL/SDL_cdrom.h:55
-- arg-macro: function CD_INDRIVE (status)
-- return (int)(status) > 0;
CD_FPS : constant := 75; -- ../include/SDL/SDL_cdrom.h:96
-- arg-macro: procedure FRAMES_TO_MSF (f, M, S, F)
-- { int value := f; *(F) := valuemodCD_FPS; value /= CD_FPS; *(S) := valuemod60; value /= 60; *(M) := value; }
-- arg-macro: function MSF_TO_FRAMES (M, S, F)
-- return (M)*60*CD_FPS+(S)*CD_FPS+(F);
subtype CDstatus is unsigned;
CD_TRAYEMPTY : constant CDstatus := 0;
CD_STOPPED : constant CDstatus := 1;
CD_PLAYING : constant CDstatus := 2;
CD_PAUSED : constant CDstatus := 3;
CD_ERROR : constant CDstatus := -1; --../include/SDL/SDL_cdrom.h:65
type SDL_CDtrack is record
id : aliased SDL_SDL_stdinc_h.Uint8; --../include/SDL/SDL_cdrom.h:71
c_type : aliased SDL_SDL_stdinc_h.Uint8; --../include/SDL/SDL_cdrom.h:72
unused : aliased SDL_SDL_stdinc_h.Uint16; --../include/SDL/SDL_cdrom.h:73
length : aliased SDL_SDL_stdinc_h.Uint32; --../include/SDL/SDL_cdrom.h:74
offset : aliased SDL_SDL_stdinc_h.Uint32; --../include/SDL/SDL_cdrom.h:75
end record;
pragma Convention (C_Pass_ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.