| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT COMPILER COMPONENTS -- |
| -- -- |
| -- G N A T . P E R F E C T _ H A S H _ G E N E R A T O R S -- |
| -- -- |
| -- B o d y -- |
| -- -- |
| -- Copyright (C) 2002-2011, AdaCore -- |
| -- -- |
| -- GNAT is free software; you can redistribute it and/or modify it under -- |
| -- terms of the GNU General Public License as published by the Free Soft- -- |
| -- ware Foundation; either version 3, or (at your option) any later ver- -- |
| -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- |
| -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
| -- or FITNESS FOR A PARTICULAR PURPOSE. -- |
| -- -- |
| -- As a special exception under Section 7 of GPL version 3, you are granted -- |
| -- additional permissions described in the GCC Runtime Library Exception, -- |
| -- version 3.1, as published by the Free Software Foundation. -- |
| -- -- |
| -- You should have received a copy of the GNU General Public License and -- |
| -- a copy of the GCC Runtime Library Exception along with this program; -- |
| -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- |
| -- <http://www.gnu.org/licenses/>. -- |
| -- -- |
| -- GNAT was originally developed by the GNAT team at New York University. -- |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| with Ada.IO_Exceptions; use Ada.IO_Exceptions; |
| with Ada.Characters.Handling; use Ada.Characters.Handling; |
| with Ada.Directories; |
| |
| with GNAT.Heap_Sort_G; |
| with GNAT.OS_Lib; use GNAT.OS_Lib; |
| with GNAT.Table; |
| |
| package body GNAT.Perfect_Hash_Generators is |
| |
| -- We are using the algorithm of J. Czech as described in Zbigniew J. |
| -- Czech, George Havas, and Bohdan S. Majewski ``An Optimal Algorithm for |
| -- Generating Minimal Perfect Hash Functions'', Information Processing |
| -- Letters, 43(1992) pp.257-264, Oct.1992 |
| |
| -- This minimal perfect hash function generator is based on random graphs |
| -- and produces a hash function of the form: |
| |
| -- h (w) = (g (f1 (w)) + g (f2 (w))) mod m |
| |
| -- where f1 and f2 are functions that map strings into integers, and g is |
| -- a function that maps integers into [0, m-1]. h can be order preserving. |
| -- For instance, let W = {w_0, ..., w_i, ..., w_m-1}, h can be defined |
| -- such that h (w_i) = i. |
| |
| -- This algorithm defines two possible constructions of f1 and f2. Method |
| -- b) stores the hash function in less memory space at the expense of |
| -- greater CPU time. |
| |
| -- a) fk (w) = sum (for i in 1 .. length (w)) (Tk (i, w (i))) mod n |
| |
| -- size (Tk) = max (for w in W) (length (w)) * size (used char set) |
| |
| -- b) fk (w) = sum (for i in 1 .. length (w)) (Tk (i) * w (i)) mod n |
| |
| -- size (Tk) = max (for w in W) (length (w)) but the table lookups are |
| -- replaced by multiplications. |
| |
| -- where Tk values are randomly generated. n is defined later on but the |
| -- algorithm recommends to use a value a little bit greater than 2m. Note |
| -- that for large values of m, the main memory space requirements comes |
| -- from the memory space for storing function g (>= 2m entries). |
| |
| -- Random graphs are frequently used to solve difficult problems that do |
| -- not have polynomial solutions. This algorithm is based on a weighted |
| -- undirected graph. It comprises two steps: mapping and assignment. |
| |
| -- In the mapping step, a graph G = (V, E) is constructed, where = {0, 1, |
| -- ..., n-1} and E = {(for w in W) (f1 (w), f2 (w))}. In order for the |
| -- assignment step to be successful, G has to be acyclic. To have a high |
| -- probability of generating an acyclic graph, n >= 2m. If it is not |
| -- acyclic, Tk have to be regenerated. |
| |
| -- In the assignment step, the algorithm builds function g. As G is |
| -- acyclic, there is a vertex v1 with only one neighbor v2. Let w_i be |
| -- the word such that v1 = f1 (w_i) and v2 = f2 (w_i). Let g (v1) = 0 by |
| -- construction and g (v2) = (i - g (v1)) mod n (or h (i) - g (v1) mod n). |
| -- If word w_j is such that v2 = f1 (w_j) and v3 = f2 (w_j), g (v3) = (j - |
| -- g (v2)) mod (or to be general, (h (j) - g (v2)) mod n). If w_i has no |
| -- neighbor, then another vertex is selected. The algorithm traverses G to |
| -- assign values to all the vertices. It cannot assign a value to an |
| -- already assigned vertex as G is acyclic. |
| |
| subtype Word_Id is Integer; |
| subtype Key_Id is Integer; |
| subtype Vertex_Id is Integer; |
| subtype Edge_Id is Integer; |
| subtype Table_Id is Integer; |
| |
| No_Vertex : constant Vertex_Id := -1; |
| No_Edge : constant Edge_Id := -1; |
| No_Table : constant Table_Id := -1; |
| |
| type Word_Type is new String_Access; |
| procedure Free_Word (W : in out Word_Type) renames Free; |
| function New_Word (S : String) return Word_Type; |
| |
| procedure Resize_Word (W : in out Word_Type; Len : Natural); |
| -- Resize string W to have a length Len |
| |
| type Key_Type is record |
| Edge : Edge_Id; |
| end record; |
| -- A key corresponds to an edge in the algorithm graph |
| |
| type Vertex_Type is record |
| First : Edge_Id; |
| Last : Edge_Id; |
| end record; |
| -- A vertex can be involved in several edges. First and Last are the bounds |
| -- of an array of edges stored in a global edge table. |
| |
| type Edge_Type is record |
| X : Vertex_Id; |
| Y : Vertex_Id; |
| Key : Key_Id; |
| end record; |
| -- An edge is a peer of vertices. In the algorithm, a key is associated to |
| -- an edge. |
| |
| package WT is new GNAT.Table (Word_Type, Word_Id, 0, 32, 32); |
| package IT is new GNAT.Table (Integer, Integer, 0, 32, 32); |
| -- The two main tables. WT is used to store the words in their initial |
| -- version and in their reduced version (that is words reduced to their |
| -- significant characters). As an instance of GNAT.Table, WT does not |
| -- initialize string pointers to null. This initialization has to be done |
| -- manually when the table is allocated. IT is used to store several |
| -- tables of components containing only integers. |
| |
| function Image (Int : Integer; W : Natural := 0) return String; |
| function Image (Str : String; W : Natural := 0) return String; |
| -- Return a string which includes string Str or integer Int preceded by |
| -- leading spaces if required by width W. |
| |
| function Trim_Trailing_Nuls (Str : String) return String; |
| -- Return Str with trailing NUL characters removed |
| |
| Output : File_Descriptor renames GNAT.OS_Lib.Standout; |
| -- Shortcuts |
| |
| EOL : constant Character := ASCII.LF; |
| |
| Max : constant := 78; |
| Last : Natural := 0; |
| Line : String (1 .. Max); |
| -- Use this line to provide buffered IO |
| |
| procedure Add (C : Character); |
| procedure Add (S : String); |
| -- Add a character or a string in Line and update Last |
| |
| procedure Put |
| (F : File_Descriptor; |
| S : String; |
| F1 : Natural; |
| L1 : Natural; |
| C1 : Natural; |
| F2 : Natural; |
| L2 : Natural; |
| C2 : Natural); |
| -- Write string S into file F as a element of an array of one or two |
| -- dimensions. Fk (resp. Lk and Ck) indicates the first (resp last and |
| -- current) index in the k-th dimension. If F1 = L1 the array is considered |
| -- as a one dimension array. This dimension is described by F2 and L2. This |
| -- routine takes care of all the parenthesis, spaces and commas needed to |
| -- format correctly the array. Moreover, the array is well indented and is |
| -- wrapped to fit in a 80 col line. When the line is full, the routine |
| -- writes it into file F. When the array is completed, the routine adds |
| -- semi-colon and writes the line into file F. |
| |
| procedure New_Line (File : File_Descriptor); |
| -- Simulate Ada.Text_IO.New_Line with GNAT.OS_Lib |
| |
| procedure Put (File : File_Descriptor; Str : String); |
| -- Simulate Ada.Text_IO.Put with GNAT.OS_Lib |
| |
| procedure Put_Used_Char_Set (File : File_Descriptor; Title : String); |
| -- Output a title and a used character set |
| |
| procedure Put_Int_Vector |
| (File : File_Descriptor; |
| Title : String; |
| Vector : Integer; |
| Length : Natural); |
| -- Output a title and a vector |
| |
| procedure Put_Int_Matrix |
| (File : File_Descriptor; |
| Title : String; |
| Table : Table_Id; |
| Len_1 : Natural; |
| Len_2 : Natural); |
| -- Output a title and a matrix. When the matrix has only one non-empty |
| -- dimension (Len_2 = 0), output a vector. |
| |
| procedure Put_Edges (File : File_Descriptor; Title : String); |
| -- Output a title and an edge table |
| |
| procedure Put_Initial_Keys (File : File_Descriptor; Title : String); |
| -- Output a title and a key table |
| |
| procedure Put_Reduced_Keys (File : File_Descriptor; Title : String); |
| -- Output a title and a key table |
| |
| procedure Put_Vertex_Table (File : File_Descriptor; Title : String); |
| -- Output a title and a vertex table |
| |
| function Ada_File_Base_Name (Pkg_Name : String) return String; |
| -- Return the base file name (i.e. without .ads/.adb extension) for an |
| -- Ada source file containing the named package, using the standard GNAT |
| -- file-naming convention. For example, if Pkg_Name is "Parent.Child", we |
| -- return "parent-child". |
| |
| ---------------------------------- |
| -- Character Position Selection -- |
| ---------------------------------- |
| |
| -- We reduce the maximum key size by selecting representative positions |
| -- in these keys. We build a matrix with one word per line. We fill the |
| -- remaining space of a line with ASCII.NUL. The heuristic selects the |
| -- position that induces the minimum number of collisions. If there are |
| -- collisions, select another position on the reduced key set responsible |
| -- of the collisions. Apply the heuristic until there is no more collision. |
| |
| procedure Apply_Position_Selection; |
| -- Apply Position selection and build the reduced key table |
| |
| procedure Parse_Position_Selection (Argument : String); |
| -- Parse Argument and compute the position set. Argument is list of |
| -- substrings separated by commas. Each substring represents a position |
| -- or a range of positions (like x-y). |
| |
| procedure Select_Character_Set; |
| -- Define an optimized used character set like Character'Pos in order not |
| -- to allocate tables of 256 entries. |
| |
| procedure Select_Char_Position; |
| -- Find a min char position set in order to reduce the max key length. The |
| -- heuristic selects the position that induces the minimum number of |
| -- collisions. If there are collisions, select another position on the |
| -- reduced key set responsible of the collisions. Apply the heuristic until |
| -- there is no collision. |
| |
| ----------------------------- |
| -- Random Graph Generation -- |
| ----------------------------- |
| |
| procedure Random (Seed : in out Natural); |
| -- Simulate Ada.Discrete_Numerics.Random |
| |
| procedure Generate_Mapping_Table |
| (Tab : Table_Id; |
| L1 : Natural; |
| L2 : Natural; |
| Seed : in out Natural); |
| -- Random generation of the tables below. T is already allocated |
| |
| procedure Generate_Mapping_Tables |
| (Opt : Optimization; |
| Seed : in out Natural); |
| -- Generate the mapping tables T1 and T2. They are used to define fk (w) = |
| -- sum (for i in 1 .. length (w)) (Tk (i, w (i))) mod n. Keys, NK and Chars |
| -- are used to compute the matrix size. |
| |
| --------------------------- |
| -- Algorithm Computation -- |
| --------------------------- |
| |
| procedure Compute_Edges_And_Vertices (Opt : Optimization); |
| -- Compute the edge and vertex tables. These are empty when a self loop is |
| -- detected (f1 (w) = f2 (w)). The edge table is sorted by X value and then |
| -- Y value. Keys is the key table and NK the number of keys. Chars is the |
| -- set of characters really used in Keys. NV is the number of vertices |
| -- recommended by the algorithm. T1 and T2 are the mapping tables needed to |
| -- compute f1 (w) and f2 (w). |
| |
| function Acyclic return Boolean; |
| -- Return True when the graph is acyclic. Vertices is the current vertex |
| -- table and Edges the current edge table. |
| |
| procedure Assign_Values_To_Vertices; |
| -- Execute the assignment step of the algorithm. Keys is the current key |
| -- table. Vertices and Edges represent the random graph. G is the result of |
| -- the assignment step such that: |
| -- h (w) = (g (f1 (w)) + g (f2 (w))) mod m |
| |
| function Sum |
| (Word : Word_Type; |
| Table : Table_Id; |
| Opt : Optimization) return Natural; |
| -- For an optimization of CPU_Time return |
| -- fk (w) = sum (for i in 1 .. length (w)) (Tk (i, w (i))) mod n |
| -- For an optimization of Memory_Space return |
| -- fk (w) = sum (for i in 1 .. length (w)) (Tk (i) * w (i)) mod n |
| -- Here NV = n |
| |
| ------------------------------- |
| -- Internal Table Management -- |
| ------------------------------- |
| |
| function Allocate (N : Natural; S : Natural := 1) return Table_Id; |
| -- Allocate N * S ints from IT table |
| |
| ---------- |
| -- Keys -- |
| ---------- |
| |
| Keys : Table_Id := No_Table; |
| NK : Natural := 0; |
| -- NK : Number of Keys |
| |
| function Initial (K : Key_Id) return Word_Id; |
| pragma Inline (Initial); |
| |
| function Reduced (K : Key_Id) return Word_Id; |
| pragma Inline (Reduced); |
| |
| function Get_Key (N : Key_Id) return Key_Type; |
| procedure Set_Key (N : Key_Id; Item : Key_Type); |
| -- Get or Set Nth element of Keys table |
| |
| ------------------ |
| -- Char_Pos_Set -- |
| ------------------ |
| |
| Char_Pos_Set : Table_Id := No_Table; |
| Char_Pos_Set_Len : Natural; |
| -- Character Selected Position Set |
| |
| function Get_Char_Pos (P : Natural) return Natural; |
| procedure Set_Char_Pos (P : Natural; Item : Natural); |
| -- Get or Set the string position of the Pth selected character |
| |
| ------------------- |
| -- Used_Char_Set -- |
| ------------------- |
| |
| Used_Char_Set : Table_Id := No_Table; |
| Used_Char_Set_Len : Natural; |
| -- Used Character Set : Define a new character mapping. When all the |
| -- characters are not present in the keys, in order to reduce the size |
| -- of some tables, we redefine the character mapping. |
| |
| function Get_Used_Char (C : Character) return Natural; |
| procedure Set_Used_Char (C : Character; Item : Natural); |
| |
| ------------ |
| -- Tables -- |
| ------------ |
| |
| T1 : Table_Id := No_Table; |
| T2 : Table_Id := No_Table; |
| T1_Len : Natural; |
| T2_Len : Natural; |
| -- T1 : Values table to compute F1 |
| -- T2 : Values table to compute F2 |
| |
| function Get_Table (T : Integer; X, Y : Natural) return Natural; |
| procedure Set_Table (T : Integer; X, Y : Natural; Item : Natural); |
| |
| ----------- |
| -- Graph -- |
| ----------- |
| |
| G : Table_Id := No_Table; |
| G_Len : Natural; |
| -- Values table to compute G |
| |
| NT : Natural := Default_Tries; |
| -- Number of tries running the algorithm before raising an error |
| |
| function Get_Graph (N : Natural) return Integer; |
| procedure Set_Graph (N : Natural; Item : Integer); |
| -- Get or Set Nth element of graph |
| |
| ----------- |
| -- Edges -- |
| ----------- |
| |
| Edge_Size : constant := 3; |
| Edges : Table_Id := No_Table; |
| Edges_Len : Natural; |
| -- Edges : Edge table of the random graph G |
| |
| function Get_Edges (F : Natural) return Edge_Type; |
| procedure Set_Edges (F : Natural; Item : Edge_Type); |
| |
| -------------- |
| -- Vertices -- |
| -------------- |
| |
| Vertex_Size : constant := 2; |
| |
| Vertices : Table_Id := No_Table; |
| -- Vertex table of the random graph G |
| |
| NV : Natural; |
| -- Number of Vertices |
| |
| function Get_Vertices (F : Natural) return Vertex_Type; |
| procedure Set_Vertices (F : Natural; Item : Vertex_Type); |
| -- Comments needed ??? |
| |
| K2V : Float; |
| -- Ratio between Keys and Vertices (parameter of Czech's algorithm) |
| |
| Opt : Optimization; |
| -- Optimization mode (memory vs CPU) |
| |
| Max_Key_Len : Natural := 0; |
| Min_Key_Len : Natural := 0; |
| -- Maximum and minimum of all the word length |
| |
| S : Natural; |
| -- Seed |
| |
| function Type_Size (L : Natural) return Natural; |
| -- Given the last L of an unsigned integer type T, return its size |
| |
| ------------- |
| -- Acyclic -- |
| ------------- |
| |
| function Acyclic return Boolean is |
| Marks : array (0 .. NV - 1) of Vertex_Id := (others => No_Vertex); |
| |
| function Traverse (Edge : Edge_Id; Mark : Vertex_Id) return Boolean; |
| -- Propagate Mark from X to Y. X is already marked. Mark Y and propagate |
| -- it to the edges of Y except the one representing the same key. Return |
| -- False when Y is marked with Mark. |
| |
| -------------- |
| -- Traverse -- |
| -------------- |
| |
| function Traverse (Edge : Edge_Id; Mark : Vertex_Id) return Boolean is |
| E : constant Edge_Type := Get_Edges (Edge); |
| K : constant Key_Id := E.Key; |
| Y : constant Vertex_Id := E.Y; |
| M : constant Vertex_Id := Marks (E.Y); |
| V : Vertex_Type; |
| |
| begin |
| if M = Mark then |
| return False; |
| |
| elsif M = No_Vertex then |
| Marks (Y) := Mark; |
| V := Get_Vertices (Y); |
| |
| for J in V.First .. V.Last loop |
| |
| -- Do not propagate to the edge representing the same key |
| |
| if Get_Edges (J).Key /= K |
| and then not Traverse (J, Mark) |
| then |
| return False; |
| end if; |
| end loop; |
| end if; |
| |
| return True; |
| end Traverse; |
| |
| Edge : Edge_Type; |
| |
| -- Start of processing for Acyclic |
| |
| begin |
| -- Edges valid range is |
| |
| for J in 1 .. Edges_Len - 1 loop |
| |
| Edge := Get_Edges (J); |
| |
| -- Mark X of E when it has not been already done |
| |
| if Marks (Edge.X) = No_Vertex then |
| Marks (Edge.X) := Edge.X; |
| end if; |
| |
| -- Traverse E when this has not already been done |
| |
| if Marks (Edge.Y) = No_Vertex |
| and then not Traverse (J, Edge.X) |
| then |
| return False; |
| end if; |
| end loop; |
| |
| return True; |
| end Acyclic; |
| |
| ------------------------ |
| -- Ada_File_Base_Name -- |
| ------------------------ |
| |
| function Ada_File_Base_Name (Pkg_Name : String) return String is |
| begin |
| -- Convert to lower case, then replace '.' with '-' |
| |
| return Result : String := To_Lower (Pkg_Name) do |
| for J in Result'Range loop |
| if Result (J) = '.' then |
| Result (J) := '-'; |
| end if; |
| end loop; |
| end return; |
| end Ada_File_Base_Name; |
| |
| --------- |
| -- Add -- |
| --------- |
| |
| procedure Add (C : Character) is |
| pragma Assert (C /= ASCII.NUL); |
| begin |
| Line (Last + 1) := C; |
| Last := Last + 1; |
| end Add; |
| |
| --------- |
| -- Add -- |
| --------- |
| |
| procedure Add (S : String) is |
| Len : constant Natural := S'Length; |
| begin |
| for J in S'Range loop |
| pragma Assert (S (J) /= ASCII.NUL); |
| null; |
| end loop; |
| |
| Line (Last + 1 .. Last + Len) := S; |
| Last := Last + Len; |
| end Add; |
| |
| -------------- |
| -- Allocate -- |
| -------------- |
| |
| function Allocate (N : Natural; S : Natural := 1) return Table_Id is |
| L : constant Integer := IT.Last; |
| begin |
| IT.Set_Last (L + N * S); |
| |
| -- Initialize, so debugging printouts don't trip over uninitialized |
| -- components. |
| |
| for J in L + 1 .. IT.Last loop |
| IT.Table (J) := -1; |
| end loop; |
| |
| return L + 1; |
| end Allocate; |
| |
| ------------------------------ |
| -- Apply_Position_Selection -- |
| ------------------------------ |
| |
| procedure Apply_Position_Selection is |
| begin |
| for J in 0 .. NK - 1 loop |
| declare |
| IW : constant String := WT.Table (Initial (J)).all; |
| RW : String (1 .. IW'Length) := (others => ASCII.NUL); |
| N : Natural := IW'First - 1; |
| |
| begin |
| -- Select the characters of Word included in the position |
| -- selection. |
| |
| for C in 0 .. Char_Pos_Set_Len - 1 loop |
| exit when IW (Get_Char_Pos (C)) = ASCII.NUL; |
| N := N + 1; |
| RW (N) := IW (Get_Char_Pos (C)); |
| end loop; |
| |
| -- Build the new table with the reduced word. Be careful |
| -- to deallocate the old version to avoid memory leaks. |
| |
| Free_Word (WT.Table (Reduced (J))); |
| WT.Table (Reduced (J)) := New_Word (RW); |
| Set_Key (J, (Edge => No_Edge)); |
| end; |
| end loop; |
| end Apply_Position_Selection; |
| |
| ------------------------------- |
| -- Assign_Values_To_Vertices -- |
| ------------------------------- |
| |
| procedure Assign_Values_To_Vertices is |
| X : Vertex_Id; |
| |
| procedure Assign (X : Vertex_Id); |
| -- Execute assignment on X's neighbors except the vertex that we are |
| -- coming from which is already assigned. |
| |
| ------------ |
| -- Assign -- |
| ------------ |
| |
| procedure Assign (X : Vertex_Id) is |
| E : Edge_Type; |
| V : constant Vertex_Type := Get_Vertices (X); |
| |
| begin |
| for J in V.First .. V.Last loop |
| E := Get_Edges (J); |
| |
| if Get_Graph (E.Y) = -1 then |
| Set_Graph (E.Y, (E.Key - Get_Graph (X)) mod NK); |
| Assign (E.Y); |
| end if; |
| end loop; |
| end Assign; |
| |
| -- Start of processing for Assign_Values_To_Vertices |
| |
| begin |
| -- Value -1 denotes an uninitialized value as it is supposed to |
| -- be in the range 0 .. NK. |
| |
| if G = No_Table then |
| G_Len := NV; |
| G := Allocate (G_Len, 1); |
| end if; |
| |
| for J in 0 .. G_Len - 1 loop |
| Set_Graph (J, -1); |
| end loop; |
| |
| for K in 0 .. NK - 1 loop |
| X := Get_Edges (Get_Key (K).Edge).X; |
| |
| if Get_Graph (X) = -1 then |
| Set_Graph (X, 0); |
| Assign (X); |
| end if; |
| end loop; |
| |
| for J in 0 .. G_Len - 1 loop |
| if Get_Graph (J) = -1 then |
| Set_Graph (J, 0); |
| end if; |
| end loop; |
| |
| if Verbose then |
| Put_Int_Vector (Output, "Assign Values To Vertices", G, G_Len); |
| end if; |
| end Assign_Values_To_Vertices; |
| |
| ------------- |
| -- Compute -- |
| ------------- |
| |
| procedure Compute (Position : String := Default_Position) is |
| Success : Boolean := False; |
| |
| begin |
| if NK = 0 then |
| raise Program_Error with "keywords set cannot be empty"; |
| end if; |
| |
| if Verbose then |
| Put_Initial_Keys (Output, "Initial Key Table"); |
| end if; |
| |
| if Position'Length /= 0 then |
| Parse_Position_Selection (Position); |
| else |
| Select_Char_Position; |
| end if; |
| |
| if Verbose then |
| Put_Int_Vector |
| (Output, "Char Position Set", Char_Pos_Set, Char_Pos_Set_Len); |
| end if; |
| |
| Apply_Position_Selection; |
| |
| if Verbose then |
| Put_Reduced_Keys (Output, "Reduced Keys Table"); |
| end if; |
| |
| Select_Character_Set; |
| |
| if Verbose then |
| Put_Used_Char_Set (Output, "Character Position Table"); |
| end if; |
| |
| -- Perform Czech's algorithm |
| |
| for J in 1 .. NT loop |
| Generate_Mapping_Tables (Opt, S); |
| Compute_Edges_And_Vertices (Opt); |
| |
| -- When graph is not empty (no self-loop from previous operation) and |
| -- not acyclic. |
| |
| if 0 < Edges_Len and then Acyclic then |
| Success := True; |
| exit; |
| end if; |
| end loop; |
| |
| if not Success then |
| raise Too_Many_Tries; |
| end if; |
| |
| Assign_Values_To_Vertices; |
| end Compute; |
| |
| -------------------------------- |
| -- Compute_Edges_And_Vertices -- |
| -------------------------------- |
| |
| procedure Compute_Edges_And_Vertices (Opt : Optimization) is |
| X : Natural; |
| Y : Natural; |
| Key : Key_Type; |
| Edge : Edge_Type; |
| Vertex : Vertex_Type; |
| Not_Acyclic : Boolean := False; |
| |
| procedure Move (From : Natural; To : Natural); |
| function Lt (L, R : Natural) return Boolean; |
| -- Subprograms needed for GNAT.Heap_Sort_G |
| |
| -------- |
| -- Lt -- |
| -------- |
| |
| function Lt (L, R : Natural) return Boolean is |
| EL : constant Edge_Type := Get_Edges (L); |
| ER : constant Edge_Type := Get_Edges (R); |
| begin |
| return EL.X < ER.X or else (EL.X = ER.X and then EL.Y < ER.Y); |
| end Lt; |
| |
| ---------- |
| -- Move -- |
| ---------- |
| |
| procedure Move (From : Natural; To : Natural) is |
| begin |
| Set_Edges (To, Get_Edges (From)); |
| end Move; |
| |
| package Sorting is new GNAT.Heap_Sort_G (Move, Lt); |
| |
| -- Start of processing for Compute_Edges_And_Vertices |
| |
| begin |
| -- We store edges from 1 to 2 * NK and leave zero alone in order to use |
| -- GNAT.Heap_Sort_G. |
| |
| Edges_Len := 2 * NK + 1; |
| |
| if Edges = No_Table then |
| Edges := Allocate (Edges_Len, Edge_Size); |
| end if; |
| |
| if Vertices = No_Table then |
| Vertices := Allocate (NV, Vertex_Size); |
| end if; |
| |
| for J in 0 .. NV - 1 loop |
| Set_Vertices (J, (No_Vertex, No_Vertex - 1)); |
| end loop; |
| |
| -- For each w, X = f1 (w) and Y = f2 (w) |
| |
| for J in 0 .. NK - 1 loop |
| Key := Get_Key (J); |
| Key.Edge := No_Edge; |
| Set_Key (J, Key); |
| |
| X := Sum (WT.Table (Reduced (J)), T1, Opt); |
| Y := Sum (WT.Table (Reduced (J)), T2, Opt); |
| |
| -- Discard T1 and T2 as soon as we discover a self loop |
| |
| if X = Y then |
| Not_Acyclic := True; |
| exit; |
| end if; |
| |
| -- We store (X, Y) and (Y, X) to ease assignment step |
| |
| Set_Edges (2 * J + 1, (X, Y, J)); |
| Set_Edges (2 * J + 2, (Y, X, J)); |
| end loop; |
| |
| -- Return an empty graph when self loop detected |
| |
| if Not_Acyclic then |
| Edges_Len := 0; |
| |
| else |
| if Verbose then |
| Put_Edges (Output, "Unsorted Edge Table"); |
| Put_Int_Matrix (Output, "Function Table 1", T1, |
| T1_Len, T2_Len); |
| Put_Int_Matrix (Output, "Function Table 2", T2, |
| T1_Len, T2_Len); |
| end if; |
| |
| -- Enforce consistency between edges and keys. Construct Vertices and |
| -- compute the list of neighbors of a vertex First .. Last as Edges |
| -- is sorted by X and then Y. To compute the neighbor list, sort the |
| -- edges. |
| |
| Sorting.Sort (Edges_Len - 1); |
| |
| if Verbose then |
| Put_Edges (Output, "Sorted Edge Table"); |
| Put_Int_Matrix (Output, "Function Table 1", T1, |
| T1_Len, T2_Len); |
| Put_Int_Matrix (Output, "Function Table 2", T2, |
| T1_Len, T2_Len); |
| end if; |
| |
| -- Edges valid range is 1 .. 2 * NK |
| |
| for E in 1 .. Edges_Len - 1 loop |
| Edge := Get_Edges (E); |
| Key := Get_Key (Edge.Key); |
| |
| if Key.Edge = No_Edge then |
| Key.Edge := E; |
| Set_Key (Edge.Key, Key); |
| end if; |
| |
| Vertex := Get_Vertices (Edge.X); |
| |
| if Vertex.First = No_Edge then |
| Vertex.First := E; |
| end if; |
| |
| Vertex.Last := E; |
| Set_Vertices (Edge.X, Vertex); |
| end loop; |
| |
| if Verbose then |
| Put_Reduced_Keys (Output, "Key Table"); |
| Put_Edges (Output, "Edge Table"); |
| Put_Vertex_Table (Output, "Vertex Table"); |
| end if; |
| end if; |
| end Compute_Edges_And_Vertices; |
| |
| ------------ |
| -- Define -- |
| ------------ |
| |
| procedure Define |
| (Name : Table_Name; |
| Item_Size : out Natural; |
| Length_1 : out Natural; |
| Length_2 : out Natural) |
| is |
| begin |
| case Name is |
| when Character_Position => |
| Item_Size := 8; |
| Length_1 := Char_Pos_Set_Len; |
| Length_2 := 0; |
| |
| when Used_Character_Set => |
| Item_Size := 8; |
| Length_1 := 256; |
| Length_2 := 0; |
| |
| when Function_Table_1 |
| | Function_Table_2 => |
| Item_Size := Type_Size (NV); |
| Length_1 := T1_Len; |
| Length_2 := T2_Len; |
| |
| when Graph_Table => |
| Item_Size := Type_Size (NK); |
| Length_1 := NV; |
| Length_2 := 0; |
| end case; |
| end Define; |
| |
| -------------- |
| -- Finalize -- |
| -------------- |
| |
| procedure Finalize is |
| begin |
| if Verbose then |
| Put (Output, "Finalize"); |
| New_Line (Output); |
| end if; |
| |
| -- Deallocate all the WT components (both initial and reduced ones) to |
| -- avoid memory leaks. |
| |
| for W in 0 .. WT.Last loop |
| |
| -- Note: WT.Table (NK) is a temporary variable, do not free it since |
| -- this would cause a double free. |
| |
| if W /= NK then |
| Free_Word (WT.Table (W)); |
| end if; |
| end loop; |
| |
| WT.Release; |
| IT.Release; |
| |
| -- Reset all variables for next usage |
| |
| Keys := No_Table; |
| |
| Char_Pos_Set := No_Table; |
| Char_Pos_Set_Len := 0; |
| |
| Used_Char_Set := No_Table; |
| Used_Char_Set_Len := 0; |
| |
| T1 := No_Table; |
| T2 := No_Table; |
| |
| T1_Len := 0; |
| T2_Len := 0; |
| |
| G := No_Table; |
| G_Len := 0; |
| |
| Edges := No_Table; |
| Edges_Len := 0; |
| |
| Vertices := No_Table; |
| NV := 0; |
| |
| NK := 0; |
| Max_Key_Len := 0; |
| Min_Key_Len := 0; |
| end Finalize; |
| |
| ---------------------------- |
| -- Generate_Mapping_Table -- |
| ---------------------------- |
| |
| procedure Generate_Mapping_Table |
| (Tab : Integer; |
| L1 : Natural; |
| L2 : Natural; |
| Seed : in out Natural) |
| is |
| begin |
| for J in 0 .. L1 - 1 loop |
| for K in 0 .. L2 - 1 loop |
| Random (Seed); |
| Set_Table (Tab, J, K, Seed mod NV); |
| end loop; |
| end loop; |
| end Generate_Mapping_Table; |
| |
| ----------------------------- |
| -- Generate_Mapping_Tables -- |
| ----------------------------- |
| |
| procedure Generate_Mapping_Tables |
| (Opt : Optimization; |
| Seed : in out Natural) |
| is |
| begin |
| -- If T1 and T2 are already allocated no need to do it twice. Reuse them |
| -- as their size has not changed. |
| |
| if T1 = No_Table and then T2 = No_Table then |
| declare |
| Used_Char_Last : Natural := 0; |
| Used_Char : Natural; |
| |
| begin |
| if Opt = CPU_Time then |
| for P in reverse Character'Range loop |
| Used_Char := Get_Used_Char (P); |
| if Used_Char /= 0 then |
| Used_Char_Last := Used_Char; |
| exit; |
| end if; |
| end loop; |
| end if; |
| |
| T1_Len := Char_Pos_Set_Len; |
| T2_Len := Used_Char_Last + 1; |
| T1 := Allocate (T1_Len * T2_Len); |
| T2 := Allocate (T1_Len * T2_Len); |
| end; |
| end if; |
| |
| Generate_Mapping_Table (T1, T1_Len, T2_Len, Seed); |
| Generate_Mapping_Table (T2, T1_Len, T2_Len, Seed); |
| |
| if Verbose then |
| Put_Used_Char_Set (Output, "Used Character Set"); |
| Put_Int_Matrix (Output, "Function Table 1", T1, |
| T1_Len, T2_Len); |
| Put_Int_Matrix (Output, "Function Table 2", T2, |
| T1_Len, T2_Len); |
| end if; |
| end Generate_Mapping_Tables; |
| |
| ------------------ |
| -- Get_Char_Pos -- |
| ------------------ |
| |
| function Get_Char_Pos (P : Natural) return Natural is |
| N : constant Natural := Char_Pos_Set + P; |
| begin |
| return IT.Table (N); |
| end Get_Char_Pos; |
| |
| --------------- |
| -- Get_Edges -- |
| --------------- |
| |
| function Get_Edges (F : Natural) return Edge_Type is |
| N : constant Natural := Edges + (F * Edge_Size); |
| E : Edge_Type; |
| begin |
| E.X := IT.Table (N); |
| E.Y := IT.Table (N + 1); |
| E.Key := IT.Table (N + 2); |
| return E; |
| end Get_Edges; |
| |
| --------------- |
| -- Get_Graph -- |
| --------------- |
| |
| function Get_Graph (N : Natural) return Integer is |
| begin |
| return IT.Table (G + N); |
| end Get_Graph; |
| |
| ------------- |
| -- Get_Key -- |
| ------------- |
| |
| function Get_Key (N : Key_Id) return Key_Type is |
| K : Key_Type; |
| begin |
| K.Edge := IT.Table (Keys + N); |
| return K; |
| end Get_Key; |
| |
| --------------- |
| -- Get_Table -- |
| --------------- |
| |
| function Get_Table (T : Integer; X, Y : Natural) return Natural is |
| N : constant Natural := T + (Y * T1_Len) + X; |
| begin |
| return IT.Table (N); |
| end Get_Table; |
| |
| ------------------- |
| -- Get_Used_Char -- |
| ------------------- |
| |
| function Get_Used_Char (C : Character) return Natural is |
| N : constant Natural := Used_Char_Set + Character'Pos (C); |
| begin |
| return IT.Table (N); |
| end Get_Used_Char; |
| |
| ------------------ |
| -- Get_Vertices -- |
| ------------------ |
| |
| function Get_Vertices (F : Natural) return Vertex_Type is |
| N : constant Natural := Vertices + (F * Vertex_Size); |
| V : Vertex_Type; |
| begin |
| V.First := IT.Table (N); |
| V.Last := IT.Table (N + 1); |
| return V; |
| end Get_Vertices; |
| |
| ----------- |
| -- Image -- |
| ----------- |
| |
| function Image (Int : Integer; W : Natural := 0) return String is |
| B : String (1 .. 32); |
| L : Natural := 0; |
| |
| procedure Img (V : Natural); |
| -- Compute image of V into B, starting at B (L), incrementing L |
| |
| --------- |
| -- Img -- |
| --------- |
| |
| procedure Img (V : Natural) is |
| begin |
| if V > 9 then |
| Img (V / 10); |
| end if; |
| |
| L := L + 1; |
| B (L) := Character'Val ((V mod 10) + Character'Pos ('0')); |
| end Img; |
| |
| -- Start of processing for Image |
| |
| begin |
| if Int < 0 then |
| L := L + 1; |
| B (L) := '-'; |
| Img (-Int); |
| else |
| Img (Int); |
| end if; |
| |
| return Image (B (1 .. L), W); |
| end Image; |
| |
| ----------- |
| -- Image -- |
| ----------- |
| |
| function Image (Str : String; W : Natural := 0) return String is |
| Len : constant Natural := Str'Length; |
| Max : Natural := Len; |
| |
| begin |
| if Max < W then |
| Max := W; |
| end if; |
| |
| declare |
| Buf : String (1 .. Max) := (1 .. Max => ' '); |
| |
| begin |
| for J in 0 .. Len - 1 loop |
| Buf (Max - Len + 1 + J) := Str (Str'First + J); |
| end loop; |
| |
| return Buf; |
| end; |
| end Image; |
| |
| ------------- |
| -- Initial -- |
| ------------- |
| |
| function Initial (K : Key_Id) return Word_Id is |
| begin |
| return K; |
| end Initial; |
| |
| ---------------- |
| -- Initialize -- |
| ---------------- |
| |
| procedure Initialize |
| (Seed : Natural; |
| K_To_V : Float := Default_K_To_V; |
| Optim : Optimization := Memory_Space; |
| Tries : Positive := Default_Tries) |
| is |
| begin |
| if Verbose then |
| Put (Output, "Initialize"); |
| New_Line (Output); |
| end if; |
| |
| -- Deallocate the part of the table concerning the reduced words. |
| -- Initial words are already present in the table. We may have reduced |
| -- words already there because a previous computation failed. We are |
| -- currently retrying and the reduced words have to be deallocated. |
| |
| for W in Reduced (0) .. WT.Last loop |
| Free_Word (WT.Table (W)); |
| end loop; |
| |
| IT.Init; |
| |
| -- Initialize of computation variables |
| |
| Keys := No_Table; |
| |
| Char_Pos_Set := No_Table; |
| Char_Pos_Set_Len := 0; |
| |
| Used_Char_Set := No_Table; |
| Used_Char_Set_Len := 0; |
| |
| T1 := No_Table; |
| T2 := No_Table; |
| |
| T1_Len := 0; |
| T2_Len := 0; |
| |
| G := No_Table; |
| G_Len := 0; |
| |
| Edges := No_Table; |
| Edges_Len := 0; |
| |
| Vertices := No_Table; |
| NV := 0; |
| |
| S := Seed; |
| K2V := K_To_V; |
| Opt := Optim; |
| NT := Tries; |
| |
| if K2V <= 2.0 then |
| raise Program_Error with "K to V ratio cannot be lower than 2.0"; |
| end if; |
| |
| -- Do not accept a value of K2V too close to 2.0 such that once |
| -- rounded up, NV = 2 * NK because the algorithm would not converge. |
| |
| NV := Natural (Float (NK) * K2V); |
| if NV <= 2 * NK then |
| NV := 2 * NK + 1; |
| end if; |
| |
| Keys := Allocate (NK); |
| |
| -- Resize initial words to have all of them at the same size |
| -- (so the size of the largest one). |
| |
| for K in 0 .. NK - 1 loop |
| Resize_Word (WT.Table (Initial (K)), Max_Key_Len); |
| end loop; |
| |
| -- Allocated the table to store the reduced words. As WT is a |
| -- GNAT.Table (using C memory management), pointers have to be |
| -- explicitly initialized to null. |
| |
| WT.Set_Last (Reduced (NK - 1)); |
| |
| -- Note: Reduced (0) = NK + 1 |
| |
| WT.Table (NK) := null; |
| |
| for W in 0 .. NK - 1 loop |
| WT.Table (Reduced (W)) := null; |
| end loop; |
| end Initialize; |
| |
| ------------ |
| -- Insert -- |
| ------------ |
| |
| procedure Insert (Value : String) is |
| Len : constant Natural := Value'Length; |
| |
| begin |
| if Verbose then |
| Put (Output, "Inserting """ & Value & """"); |
| New_Line (Output); |
| end if; |
| |
| for J in Value'Range loop |
| pragma Assert (Value (J) /= ASCII.NUL); |
| null; |
| end loop; |
| |
| WT.Set_Last (NK); |
| WT.Table (NK) := New_Word (Value); |
| NK := NK + 1; |
| |
| if Max_Key_Len < Len then |
| Max_Key_Len := Len; |
| end if; |
| |
| if Min_Key_Len = 0 or else Len < Min_Key_Len then |
| Min_Key_Len := Len; |
| end if; |
| end Insert; |
| |
| -------------- |
| -- New_Line -- |
| -------------- |
| |
| procedure New_Line (File : File_Descriptor) is |
| begin |
| if Write (File, EOL'Address, 1) /= 1 then |
| raise Program_Error; |
| end if; |
| end New_Line; |
| |
| -------------- |
| -- New_Word -- |
| -------------- |
| |
| function New_Word (S : String) return Word_Type is |
| begin |
| return new String'(S); |
| end New_Word; |
| |
| ------------------------------ |
| -- Parse_Position_Selection -- |
| ------------------------------ |
| |
| procedure Parse_Position_Selection (Argument : String) is |
| N : Natural := Argument'First; |
| L : constant Natural := Argument'Last; |
| M : constant Natural := Max_Key_Len; |
| |
| T : array (1 .. M) of Boolean := (others => False); |
| |
| function Parse_Index return Natural; |
| -- Parse argument starting at index N to find an index |
| |
| ----------------- |
| -- Parse_Index -- |
| ----------------- |
| |
| function Parse_Index return Natural is |
| C : Character := Argument (N); |
| V : Natural := 0; |
| |
| begin |
| if C = '$' then |
| N := N + 1; |
| return M; |
| end if; |
| |
| if C not in '0' .. '9' then |
| raise Program_Error with "cannot read position argument"; |
| end if; |
| |
| while C in '0' .. '9' loop |
| V := V * 10 + (Character'Pos (C) - Character'Pos ('0')); |
| N := N + 1; |
| exit when L < N; |
| C := Argument (N); |
| end loop; |
| |
| return V; |
| end Parse_Index; |
| |
| -- Start of processing for Parse_Position_Selection |
| |
| begin |
| -- Empty specification means all the positions |
| |
| if L < N then |
| Char_Pos_Set_Len := M; |
| Char_Pos_Set := Allocate (Char_Pos_Set_Len); |
| |
| for C in 0 .. Char_Pos_Set_Len - 1 loop |
| Set_Char_Pos (C, C + 1); |
| end loop; |
| |
| else |
| loop |
| declare |
| First, Last : Natural; |
| |
| begin |
| First := Parse_Index; |
| Last := First; |
| |
| -- Detect a range |
| |
| if N <= L and then Argument (N) = '-' then |
| N := N + 1; |
| Last := Parse_Index; |
| end if; |
| |
| -- Include the positions in the selection |
| |
| for J in First .. Last loop |
| T (J) := True; |
| end loop; |
| end; |
| |
| exit when L < N; |
| |
| if Argument (N) /= ',' then |
| raise Program_Error with "cannot read position argument"; |
| end if; |
| |
| N := N + 1; |
| end loop; |
| |
| -- Compute position selection length |
| |
| N := 0; |
| for J in T'Range loop |
| if T (J) then |
| N := N + 1; |
| end if; |
| end loop; |
| |
| -- Fill position selection |
| |
| Char_Pos_Set_Len := N; |
| Char_Pos_Set := Allocate (Char_Pos_Set_Len); |
| |
| N := 0; |
| for J in T'Range loop |
| if T (J) then |
| Set_Char_Pos (N, J); |
| N := N + 1; |
| end if; |
| end loop; |
| end if; |
| end Parse_Position_Selection; |
| |
| ------------- |
| -- Produce -- |
| ------------- |
| |
| procedure Produce |
| (Pkg_Name : String := Default_Pkg_Name; |
| Use_Stdout : Boolean := False) |
| is |
| File : File_Descriptor := Standout; |
| |
| Status : Boolean; |
| -- For call to Close |
| |
| function Array_Img (N, T, R1 : String; R2 : String := "") return String; |
| -- Return string "N : constant array (R1[, R2]) of T;" |
| |
| function Range_Img (F, L : Natural; T : String := "") return String; |
| -- Return string "[T range ]F .. L" |
| |
| function Type_Img (L : Natural) return String; |
| -- Return the larger unsigned type T such that T'Last < L |
| |
| --------------- |
| -- Array_Img -- |
| --------------- |
| |
| function Array_Img |
| (N, T, R1 : String; |
| R2 : String := "") return String |
| is |
| begin |
| Last := 0; |
| Add (" "); |
| Add (N); |
| Add (" : constant array ("); |
| Add (R1); |
| |
| if R2 /= "" then |
| Add (", "); |
| Add (R2); |
| end if; |
| |
| Add (") of "); |
| Add (T); |
| Add (" :="); |
| return Line (1 .. Last); |
| end Array_Img; |
| |
| --------------- |
| -- Range_Img -- |
| --------------- |
| |
| function Range_Img (F, L : Natural; T : String := "") return String is |
| FI : constant String := Image (F); |
| FL : constant Natural := FI'Length; |
| LI : constant String := Image (L); |
| LL : constant Natural := LI'Length; |
| TL : constant Natural := T'Length; |
| RI : String (1 .. TL + 7 + FL + 4 + LL); |
| Len : Natural := 0; |
| |
| begin |
| if TL /= 0 then |
| RI (Len + 1 .. Len + TL) := T; |
| Len := Len + TL; |
| RI (Len + 1 .. Len + 7) := " range "; |
| Len := Len + 7; |
| end if; |
| |
| RI (Len + 1 .. Len + FL) := FI; |
| Len := Len + FL; |
| RI (Len + 1 .. Len + 4) := " .. "; |
| Len := Len + 4; |
| RI (Len + 1 .. Len + LL) := LI; |
| Len := Len + LL; |
| return RI (1 .. Len); |
| end Range_Img; |
| |
| -------------- |
| -- Type_Img -- |
| -------------- |
| |
| function Type_Img (L : Natural) return String is |
| S : constant String := Image (Type_Size (L)); |
| U : String := "Unsigned_ "; |
| N : Natural := 9; |
| |
| begin |
| for J in S'Range loop |
| N := N + 1; |
| U (N) := S (J); |
| end loop; |
| |
| return U (1 .. N); |
| end Type_Img; |
| |
| F : Natural; |
| L : Natural; |
| P : Natural; |
| |
| FName : String := Ada_File_Base_Name (Pkg_Name) & ".ads"; |
| -- Initially, the name of the spec file, then modified to be the name of |
| -- the body file. Not used if Use_Stdout is True. |
| |
| -- Start of processing for Produce |
| |
| begin |
| |
| if Verbose and then not Use_Stdout then |
| Put (Output, |
| "Producing " & Ada.Directories.Current_Directory & "/" & FName); |
| New_Line (Output); |
| end if; |
| |
| if not Use_Stdout then |
| File := Create_File (FName, Binary); |
| |
| if File = Invalid_FD then |
| raise Program_Error with "cannot create: " & FName; |
| end if; |
| end if; |
| |
| Put (File, "package "); |
| Put (File, Pkg_Name); |
| Put (File, " is"); |
| New_Line (File); |
| Put (File, " function Hash (S : String) return Natural;"); |
| New_Line (File); |
| Put (File, "end "); |
| Put (File, Pkg_Name); |
| Put (File, ";"); |
| New_Line (File); |
| |
| if not Use_Stdout then |
| Close (File, Status); |
| |
| if not Status then |
| raise Device_Error; |
| end if; |
| end if; |
| |
| if not Use_Stdout then |
| |
| -- Set to body file name |
| |
| FName (FName'Last) := 'b'; |
| |
| File := Create_File (FName, Binary); |
| |
| if File = Invalid_FD then |
| raise Program_Error with "cannot create: " & FName; |
| end if; |
| end if; |
| |
| Put (File, "with Interfaces; use Interfaces;"); |
| New_Line (File); |
| New_Line (File); |
| Put (File, "package body "); |
| Put (File, Pkg_Name); |
| Put (File, " is"); |
| New_Line (File); |
| New_Line (File); |
| |
| if Opt = CPU_Time then |
| Put (File, Array_Img ("C", Type_Img (256), "Character")); |
| New_Line (File); |
| |
| F := Character'Pos (Character'First); |
| L := Character'Pos (Character'Last); |
| |
| for J in Character'Range loop |
| P := Get_Used_Char (J); |
| Put (File, Image (P), 1, 0, 1, F, L, Character'Pos (J)); |
| end loop; |
| |
| New_Line (File); |
| end if; |
| |
| F := 0; |
| L := Char_Pos_Set_Len - 1; |
| |
| Put (File, Array_Img ("P", "Natural", Range_Img (F, L))); |
| New_Line (File); |
| |
| for J in F .. L loop |
| Put (File, Image (Get_Char_Pos (J)), 1, 0, 1, F, L, J); |
| end loop; |
| |
| New_Line (File); |
| |
| case Opt is |
| when CPU_Time => |
| Put_Int_Matrix |
| (File, |
| Array_Img ("T1", Type_Img (NV), |
| Range_Img (0, T1_Len - 1), |
| Range_Img (0, T2_Len - 1, Type_Img (256))), |
| T1, T1_Len, T2_Len); |
| |
| when Memory_Space => |
| Put_Int_Matrix |
| (File, |
| Array_Img ("T1", Type_Img (NV), |
| Range_Img (0, T1_Len - 1)), |
| T1, T1_Len, 0); |
| end case; |
| |
| New_Line (File); |
| |
| case Opt is |
| when CPU_Time => |
| Put_Int_Matrix |
| (File, |
| Array_Img ("T2", Type_Img (NV), |
| Range_Img (0, T1_Len - 1), |
| Range_Img (0, T2_Len - 1, Type_Img (256))), |
| T2, T1_Len, T2_Len); |
| |
| when Memory_Space => |
| Put_Int_Matrix |
| (File, |
| Array_Img ("T2", Type_Img (NV), |
| Range_Img (0, T1_Len - 1)), |
| T2, T1_Len, 0); |
| end case; |
| |
| New_Line (File); |
| |
| Put_Int_Vector |
| (File, |
| Array_Img ("G", Type_Img (NK), |
| Range_Img (0, G_Len - 1)), |
| G, G_Len); |
| New_Line (File); |
| |
| Put (File, " function Hash (S : String) return Natural is"); |
| New_Line (File); |
| Put (File, " F : constant Natural := S'First - 1;"); |
| New_Line (File); |
| Put (File, " L : constant Natural := S'Length;"); |
| New_Line (File); |
| Put (File, " F1, F2 : Natural := 0;"); |
| New_Line (File); |
| |
| Put (File, " J : "); |
| |
| case Opt is |
| when CPU_Time => |
| Put (File, Type_Img (256)); |
| when Memory_Space => |
| Put (File, "Natural"); |
| end case; |
| |
| Put (File, ";"); |
| New_Line (File); |
| |
| Put (File, " begin"); |
| New_Line (File); |
| Put (File, " for K in P'Range loop"); |
| New_Line (File); |
| Put (File, " exit when L < P (K);"); |
| New_Line (File); |
| Put (File, " J := "); |
| |
| case Opt is |
| when CPU_Time => |
| Put (File, "C"); |
| when Memory_Space => |
| Put (File, "Character'Pos"); |
| end case; |
| |
| Put (File, " (S (P (K) + F));"); |
| New_Line (File); |
| |
| Put (File, " F1 := (F1 + Natural (T1 (K"); |
| |
| if Opt = CPU_Time then |
| Put (File, ", J"); |
| end if; |
| |
| Put (File, "))"); |
| |
| if Opt = Memory_Space then |
| Put (File, " * J"); |
| end if; |
| |
| Put (File, ") mod "); |
| Put (File, Image (NV)); |
| Put (File, ";"); |
| New_Line (File); |
| |
| Put (File, " F2 := (F2 + Natural (T2 (K"); |
| |
| if Opt = CPU_Time then |
| Put (File, ", J"); |
| end if; |
| |
| Put (File, "))"); |
| |
| if Opt = Memory_Space then |
| Put (File, " * J"); |
| end if; |
| |
| Put (File, ") mod "); |
| Put (File, Image (NV)); |
| Put (File, ";"); |
| New_Line (File); |
| |
| Put (File, " end loop;"); |
| New_Line (File); |
| |
| Put (File, |
| " return (Natural (G (F1)) + Natural (G (F2))) mod "); |
| |
| Put (File, Image (NK)); |
| Put (File, ";"); |
| New_Line (File); |
| Put (File, " end Hash;"); |
| New_Line (File); |
| New_Line (File); |
| Put (File, "end "); |
| Put (File, Pkg_Name); |
| Put (File, ";"); |
| New_Line (File); |
| |
| if not Use_Stdout then |
| Close (File, Status); |
| |
| if not Status then |
| raise Device_Error; |
| end if; |
| end if; |
| end Produce; |
| |
| --------- |
| -- Put -- |
| --------- |
| |
| procedure Put (File : File_Descriptor; Str : String) is |
| Len : constant Natural := Str'Length; |
| begin |
| for J in Str'Range loop |
| pragma Assert (Str (J) /= ASCII.NUL); |
| null; |
| end loop; |
| |
| if Write (File, Str'Address, Len) /= Len then |
| raise Program_Error; |
| end if; |
| end Put; |
| |
| --------- |
| -- Put -- |
| --------- |
| |
| procedure Put |
| (F : File_Descriptor; |
| S : String; |
| F1 : Natural; |
| L1 : Natural; |
| C1 : Natural; |
| F2 : Natural; |
| L2 : Natural; |
| C2 : Natural) |
| is |
| Len : constant Natural := S'Length; |
| |
| procedure Flush; |
| -- Write current line, followed by LF |
| |
| ----------- |
| -- Flush -- |
| ----------- |
| |
| procedure Flush is |
| begin |
| Put (F, Line (1 .. Last)); |
| New_Line (F); |
| Last := 0; |
| end Flush; |
| |
| -- Start of processing for Put |
| |
| begin |
| if C1 = F1 and then C2 = F2 then |
| Last := 0; |
| end if; |
| |
| if Last + Len + 3 >= Max then |
| Flush; |
| end if; |
| |
| if Last = 0 then |
| Add (" "); |
| |
| if F1 <= L1 then |
| if C1 = F1 and then C2 = F2 then |
| Add ('('); |
| |
| if F1 = L1 then |
| Add ("0 .. 0 => "); |
| end if; |
| |
| else |
| Add (' '); |
| end if; |
| end if; |
| end if; |
| |
| if C2 = F2 then |
| Add ('('); |
| |
| if F2 = L2 then |
| Add ("0 .. 0 => "); |
| end if; |
| |
| else |
| Add (' '); |
| end if; |
| |
| Add (S); |
| |
| if C2 = L2 then |
| Add (')'); |
| |
| if F1 > L1 then |
| Add (';'); |
| Flush; |
| |
| elsif C1 /= L1 then |
| Add (','); |
| Flush; |
| |
| else |
| Add (')'); |
| Add (';'); |
| Flush; |
| end if; |
| |
| else |
| Add (','); |
| end if; |
| end Put; |
| |
| --------------- |
| -- Put_Edges -- |
| --------------- |
| |
| procedure Put_Edges (File : File_Descriptor; Title : String) is |
| E : Edge_Type; |
| F1 : constant Natural := 1; |
| L1 : constant Natural := Edges_Len - 1; |
| M : constant Natural := Max / 5; |
| |
| begin |
| Put (File, Title); |
| New_Line (File); |
| |
| -- Edges valid range is 1 .. Edge_Len - 1 |
| |
| for J in F1 .. L1 loop |
| E := Get_Edges (J); |
| Put (File, Image (J, M), F1, L1, J, 1, 4, 1); |
| Put (File, Image (E.X, M), F1, L1, J, 1, 4, 2); |
| Put (File, Image (E.Y, M), F1, L1, J, 1, 4, 3); |
| Put (File, Image (E.Key, M), F1, L1, J, 1, 4, 4); |
| end loop; |
| end Put_Edges; |
| |
| ---------------------- |
| -- Put_Initial_Keys -- |
| ---------------------- |
| |
| procedure Put_Initial_Keys (File : File_Descriptor; Title : String) is |
| F1 : constant Natural := 0; |
| L1 : constant Natural := NK - 1; |
| M : constant Natural := Max / 5; |
| K : Key_Type; |
| |
| begin |
| Put (File, Title); |
| New_Line (File); |
| |
| for J in F1 .. L1 loop |
| K := Get_Key (J); |
| Put (File, Image (J, M), F1, L1, J, 1, 3, 1); |
| Put (File, Image (K.Edge, M), F1, L1, J, 1, 3, 2); |
| Put (File, Trim_Trailing_Nuls (WT.Table (Initial (J)).all), |
| F1, L1, J, 1, 3, 3); |
| end loop; |
| end Put_Initial_Keys; |
| |
| -------------------- |
| -- Put_Int_Matrix -- |
| -------------------- |
| |
| procedure Put_Int_Matrix |
| (File : File_Descriptor; |
| Title : String; |
| Table : Integer; |
| Len_1 : Natural; |
| Len_2 : Natural) |
| is |
| F1 : constant Integer := 0; |
| L1 : constant Integer := Len_1 - 1; |
| F2 : constant Integer := 0; |
| L2 : constant Integer := Len_2 - 1; |
| Ix : Natural; |
| |
| begin |
| Put (File, Title); |
| New_Line (File); |
| |
| if Len_2 = 0 then |
| for J in F1 .. L1 loop |
| Ix := IT.Table (Table + J); |
| Put (File, Image (Ix), 1, 0, 1, F1, L1, J); |
| end loop; |
| |
| else |
| for J in F1 .. L1 loop |
| for K in F2 .. L2 loop |
| Ix := IT.Table (Table + J + K * Len_1); |
| Put (File, Image (Ix), F1, L1, J, F2, L2, K); |
| end loop; |
| end loop; |
| end if; |
| end Put_Int_Matrix; |
| |
| -------------------- |
| -- Put_Int_Vector -- |
| -------------------- |
| |
| procedure Put_Int_Vector |
| (File : File_Descriptor; |
| Title : String; |
| Vector : Integer; |
| Length : Natural) |
| is |
| F2 : constant Natural := 0; |
| L2 : constant Natural := Length - 1; |
| |
| begin |
| Put (File, Title); |
| New_Line (File); |
| |
| for J in F2 .. L2 loop |
| Put (File, Image (IT.Table (Vector + J)), 1, 0, 1, F2, L2, J); |
| end loop; |
| end Put_Int_Vector; |
| |
| ---------------------- |
| -- Put_Reduced_Keys -- |
| ---------------------- |
| |
| procedure Put_Reduced_Keys (File : File_Descriptor; Title : String) is |
| F1 : constant Natural := 0; |
| L1 : constant Natural := NK - 1; |
| M : constant Natural := Max / 5; |
| K : Key_Type; |
| |
| begin |
| Put (File, Title); |
| New_Line (File); |
| |
| for J in F1 .. L1 loop |
| K := Get_Key (J); |
| Put (File, Image (J, M), F1, L1, J, 1, 3, 1); |
| Put (File, Image (K.Edge, M), F1, L1, J, 1, 3, 2); |
| Put (File, Trim_Trailing_Nuls (WT.Table (Reduced (J)).all), |
| F1, L1, J, 1, 3, 3); |
| end loop; |
| end Put_Reduced_Keys; |
| |
| ----------------------- |
| -- Put_Used_Char_Set -- |
| ----------------------- |
| |
| procedure Put_Used_Char_Set (File : File_Descriptor; Title : String) is |
| F : constant Natural := Character'Pos (Character'First); |
| L : constant Natural := Character'Pos (Character'Last); |
| |
| begin |
| Put (File, Title); |
| New_Line (File); |
| |
| for J in Character'Range loop |
| Put |
| (File, Image (Get_Used_Char (J)), 1, 0, 1, F, L, Character'Pos (J)); |
| end loop; |
| end Put_Used_Char_Set; |
| |
| ---------------------- |
| -- Put_Vertex_Table -- |
| ---------------------- |
| |
| procedure Put_Vertex_Table (File : File_Descriptor; Title : String) is |
| F1 : constant Natural := 0; |
| L1 : constant Natural := NV - 1; |
| M : constant Natural := Max / 4; |
| V : Vertex_Type; |
| |
| begin |
| Put (File, Title); |
| New_Line (File); |
| |
| for J in F1 .. L1 loop |
| V := Get_Vertices (J); |
| Put (File, Image (J, M), F1, L1, J, 1, 3, 1); |
| Put (File, Image (V.First, M), F1, L1, J, 1, 3, 2); |
| Put (File, Image (V.Last, M), F1, L1, J, 1, 3, 3); |
| end loop; |
| end Put_Vertex_Table; |
| |
| ------------ |
| -- Random -- |
| ------------ |
| |
| procedure Random (Seed : in out Natural) is |
| |
| -- Park & Miller Standard Minimal using Schrage's algorithm to avoid |
| -- overflow: Xn+1 = 16807 * Xn mod (2 ** 31 - 1) |
| |
| R : Natural; |
| Q : Natural; |
| X : Integer; |
| |
| begin |
| R := Seed mod 127773; |
| Q := Seed / 127773; |
| X := 16807 * R - 2836 * Q; |
| |
| Seed := (if X < 0 then X + 2147483647 else X); |
| end Random; |
| |
| ------------- |
| -- Reduced -- |
| ------------- |
| |
| function Reduced (K : Key_Id) return Word_Id is |
| begin |
| return K + NK + 1; |
| end Reduced; |
| |
| ----------------- |
| -- Resize_Word -- |
| ----------------- |
| |
| procedure Resize_Word (W : in out Word_Type; Len : Natural) is |
| S1 : constant String := W.all; |
| S2 : String (1 .. Len) := (others => ASCII.NUL); |
| L : constant Natural := S1'Length; |
| begin |
| if L /= Len then |
| Free_Word (W); |
| S2 (1 .. L) := S1; |
| W := New_Word (S2); |
| end if; |
| end Resize_Word; |
| |
| -------------------------- |
| -- Select_Char_Position -- |
| -------------------------- |
| |
| procedure Select_Char_Position is |
| |
| type Vertex_Table_Type is array (Natural range <>) of Vertex_Type; |
| |
| procedure Build_Identical_Keys_Sets |
| (Table : in out Vertex_Table_Type; |
| Last : in out Natural; |
| Pos : Natural); |
| -- Build a list of keys subsets that are identical with the current |
| -- position selection plus Pos. Once this routine is called, reduced |
| -- words are sorted by subsets and each item (First, Last) in Sets |
| -- defines the range of identical keys. |
| -- Need comment saying exactly what Last is ??? |
| |
| function Count_Different_Keys |
| (Table : Vertex_Table_Type; |
| Last : Natural; |
| Pos : Natural) return Natural; |
| -- For each subset in Sets, count the number of different keys if we add |
| -- Pos to the current position selection. |
| |
| Sel_Position : IT.Table_Type (1 .. Max_Key_Len); |
| Last_Sel_Pos : Natural := 0; |
| Max_Sel_Pos : Natural := 0; |
| |
| ------------------------------- |
| -- Build_Identical_Keys_Sets -- |
| ------------------------------- |
| |
| procedure Build_Identical_Keys_Sets |
| (Table : in out Vertex_Table_Type; |
| Last : in out Natural; |
| Pos : Natural) |
| is |
| S : constant Vertex_Table_Type := Table (Table'First .. Last); |
| C : constant Natural := Pos; |
| -- Shortcuts (why are these not renames ???) |
| |
| F : Integer; |
| L : Integer; |
| -- First and last words of a subset |
| |
| Offset : Natural; |
| -- GNAT.Heap_Sort assumes that the first array index is 1. Offset |
| -- defines the translation to operate. |
| |
| function Lt (L, R : Natural) return Boolean; |
| procedure Move (From : Natural; To : Natural); |
| -- Subprograms needed by GNAT.Heap_Sort_G |
| |
| -------- |
| -- Lt -- |
| -------- |
| |
| function Lt (L, R : Natural) return Boolean is |
| C : constant Natural := Pos; |
| Left : Natural; |
| Right : Natural; |
| |
| begin |
| if L = 0 then |
| Left := NK; |
| Right := Offset + R; |
| elsif R = 0 then |
| Left := Offset + L; |
| Right := NK; |
| else |
| Left := Offset + L; |
| Right := Offset + R; |
| end if; |
| |
| return WT.Table (Left)(C) < WT.Table (Right)(C); |
| end Lt; |
| |
| ---------- |
| -- Move -- |
| ---------- |
| |
| procedure Move (From : Natural; To : Natural) is |
| Target, Source : Natural; |
| |
| begin |
| if From = 0 then |
| Source := NK; |
| Target := Offset + To; |
| elsif To = 0 then |
| Source := Offset + From; |
| Target := NK; |
| else |
| Source := Offset + From; |
| Target := Offset + To; |
| end if; |
| |
| WT.Table (Target) := WT.Table (Source); |
| WT.Table (Source) := null; |
| end Move; |
| |
| package Sorting is new GNAT.Heap_Sort_G (Move, Lt); |
| |
| -- Start of processing for Build_Identical_Key_Sets |
| |
| begin |
| Last := 0; |
| |
| -- For each subset in S, extract the new subsets we have by adding C |
| -- in the position selection. |
| |
| for J in S'Range loop |
| if S (J).First = S (J).Last then |
| F := S (J).First; |
| L := S (J).Last; |
| Last := Last + 1; |
| Table (Last) := (F, L); |
| |
| else |
| Offset := Reduced (S (J).First) - 1; |
| Sorting.Sort (S (J).Last - S (J).First + 1); |
| |
| F := S (J).First; |
| L := F; |
| for N in S (J).First .. S (J).Last loop |
| |
| -- For the last item, close the last subset |
| |
| if N = S (J).Last then |
| Last := Last + 1; |
| Table (Last) := (F, N); |
| |
| -- Two contiguous words are identical when they have the |
| -- same Cth character. |
| |
| elsif WT.Table (Reduced (N))(C) = |
| WT.Table (Reduced (N + 1))(C) |
| then |
| L := N + 1; |
| |
| -- Find a new subset of identical keys. Store the current |
| -- one and create a new subset. |
| |
| else |
| Last := Last + 1; |
| Table (Last) := (F, L); |
| F := N + 1; |
| L := F; |
| end if; |
| end loop; |
| end if; |
| end loop; |
| end Build_Identical_Keys_Sets; |
| |
| -------------------------- |
| -- Count_Different_Keys -- |
| -------------------------- |
| |
| function Count_Different_Keys |
| (Table : Vertex_Table_Type; |
| Last : Natural; |
| Pos : Natural) return Natural |
| is |
| N : array (Character) of Natural; |
| C : Character; |
| T : Natural := 0; |
| |
| begin |
| -- For each subset, count the number of words that are still |
| -- different when we include Pos in the position selection. Only |
| -- focus on this position as the other positions already produce |
| -- identical keys. |
| |
| for S in 1 .. Last loop |
| |
| -- Count the occurrences of the different characters |
| |
| N := (others => 0); |
| for K in Table (S).First .. Table (S).Last loop |
| C := WT.Table (Reduced (K))(Pos); |
| N (C) := N (C) + 1; |
| end loop; |
| |
| -- Update the number of different keys. Each character used |
| -- denotes a different key. |
| |
| for J in N'Range loop |
| if N (J) > 0 then |
| T := T + 1; |
| end if; |
| end loop; |
| end loop; |
| |
| return T; |
| end Count_Different_Keys; |
| |
| -- Start of processing for Select_Char_Position |
| |
| begin |
| -- Initialize the reduced words set |
| |
| for K in 0 .. NK - 1 loop |
| WT.Table (Reduced (K)) := New_Word (WT.Table (Initial (K)).all); |
| end loop; |
| |
| declare |
| Differences : Natural; |
| Max_Differences : Natural := 0; |
| Old_Differences : Natural; |
| Max_Diff_Sel_Pos : Natural := 0; -- init to kill warning |
| Max_Diff_Sel_Pos_Idx : Natural := 0; -- init to kill warning |
| Same_Keys_Sets_Table : Vertex_Table_Type (1 .. NK); |
| Same_Keys_Sets_Last : Natural := 1; |
| |
| begin |
| for C in Sel_Position'Range loop |
| Sel_Position (C) := C; |
| end loop; |
| |
| Same_Keys_Sets_Table (1) := (0, NK - 1); |
| |
| loop |
| -- Preserve maximum number of different keys and check later on |
| -- that this value is strictly incrementing. Otherwise, it means |
| -- that two keys are strictly identical. |
| |
| Old_Differences := Max_Differences; |
| |
| -- The first position should not exceed the minimum key length. |
| -- Otherwise, we may end up with an empty word once reduced. |
| |
| Max_Sel_Pos := |
| (if Last_Sel_Pos = 0 then Min_Key_Len else Max_Key_Len); |
| |
| -- Find which position increases more the number of differences |
| |
| for J in Last_Sel_Pos + 1 .. Max_Sel_Pos loop |
| Differences := Count_Different_Keys |
| (Same_Keys_Sets_Table, |
| Same_Keys_Sets_Last, |
| Sel_Position (J)); |
| |
| if Verbose then |
| Put (Output, |
| "Selecting position" & Sel_Position (J)'Img & |
| " results in" & Differences'Img & |
| " differences"); |
| New_Line (Output); |
| end if; |
| |
| if Differences > Max_Differences then |
| Max_Differences := Differences; |
| Max_Diff_Sel_Pos := Sel_Position (J); |
| Max_Diff_Sel_Pos_Idx := J; |
| end if; |
| end loop; |
| |
| if Old_Differences = Max_Differences then |
| raise Program_Error with "some keys are identical"; |
| end if; |
| |
| -- Insert selected position and sort Sel_Position table |
| |
| Last_Sel_Pos := Last_Sel_Pos + 1; |
| Sel_Position (Last_Sel_Pos + 1 .. Max_Diff_Sel_Pos_Idx) := |
| Sel_Position (Last_Sel_Pos .. Max_Diff_Sel_Pos_Idx - 1); |
| Sel_Position (Last_Sel_Pos) := Max_Diff_Sel_Pos; |
| |
| for P in 1 .. Last_Sel_Pos - 1 loop |
| if Max_Diff_Sel_Pos < Sel_Position (P) then |
| Sel_Position (P + 1 .. Last_Sel_Pos) := |
| Sel_Position (P .. Last_Sel_Pos - 1); |
| Sel_Position (P) := Max_Diff_Sel_Pos; |
| exit; |
| end if; |
| end loop; |
| |
| exit when Max_Differences = NK; |
| |
| Build_Identical_Keys_Sets |
| (Same_Keys_Sets_Table, |
| Same_Keys_Sets_Last, |
| Max_Diff_Sel_Pos); |
| |
| if Verbose then |
| Put (Output, |
| "Selecting position" & Max_Diff_Sel_Pos'Img & |
| " results in" & Max_Differences'Img & |
| " differences"); |
| New_Line (Output); |
| Put (Output, "--"); |
| New_Line (Output); |
| for J in 1 .. Same_Keys_Sets_Last loop |
| for K in |
| Same_Keys_Sets_Table (J).First .. |
| Same_Keys_Sets_Table (J).Last |
| loop |
| Put (Output, |
| Trim_Trailing_Nuls (WT.Table (Reduced (K)).all)); |
| New_Line (Output); |
| end loop; |
| Put (Output, "--"); |
| New_Line (Output); |
| end loop; |
| end if; |
| end loop; |
| end; |
| |
| Char_Pos_Set_Len := Last_Sel_Pos; |
| Char_Pos_Set := Allocate (Char_Pos_Set_Len); |
| |
| for C in 1 .. Last_Sel_Pos loop |
| Set_Char_Pos (C - 1, Sel_Position (C)); |
| end loop; |
| end Select_Char_Position; |
| |
| -------------------------- |
| -- Select_Character_Set -- |
| -------------------------- |
| |
| procedure Select_Character_Set is |
| Last : Natural := 0; |
| Used : array (Character) of Boolean := (others => False); |
| Char : Character; |
| |
| begin |
| for J in 0 .. NK - 1 loop |
| for K in 0 .. Char_Pos_Set_Len - 1 loop |
| Char := WT.Table (Initial (J))(Get_Char_Pos (K)); |
| exit when Char = ASCII.NUL; |
| Used (Char) := True; |
| end loop; |
| end loop; |
| |
| Used_Char_Set_Len := 256; |
| Used_Char_Set := Allocate (Used_Char_Set_Len); |
| |
| for J in Used'Range loop |
| if Used (J) then |
| Set_Used_Char (J, Last); |
| Last := Last + 1; |
| else |
| Set_Used_Char (J, 0); |
| end if; |
| end loop; |
| end Select_Character_Set; |
| |
| ------------------ |
| -- Set_Char_Pos -- |
| ------------------ |
| |
| procedure Set_Char_Pos (P : Natural; Item : Natural) is |
| N : constant Natural := Char_Pos_Set + P; |
| begin |
| IT.Table (N) := Item; |
| end Set_Char_Pos; |
| |
| --------------- |
| -- Set_Edges -- |
| --------------- |
| |
| procedure Set_Edges (F : Natural; Item : Edge_Type) is |
| N : constant Natural := Edges + (F * Edge_Size); |
| begin |
| IT.Table (N) := Item.X; |
| IT.Table (N + 1) := Item.Y; |
| IT.Table (N + 2) := Item.Key; |
| end Set_Edges; |
| |
| --------------- |
| -- Set_Graph -- |
| --------------- |
| |
| procedure Set_Graph (N : Natural; Item : Integer) is |
| begin |
| IT.Table (G + N) := Item; |
| end Set_Graph; |
| |
| ------------- |
| -- Set_Key -- |
| ------------- |
| |
| procedure Set_Key (N : Key_Id; Item : Key_Type) is |
| begin |
| IT.Table (Keys + N) := Item.Edge; |
| end Set_Key; |
| |
| --------------- |
| -- Set_Table -- |
| --------------- |
| |
| procedure Set_Table (T : Integer; X, Y : Natural; Item : Natural) is |
| N : constant Natural := T + ((Y * T1_Len) + X); |
| begin |
| IT.Table (N) := Item; |
| end Set_Table; |
| |
| ------------------- |
| -- Set_Used_Char -- |
| ------------------- |
| |
| procedure Set_Used_Char (C : Character; Item : Natural) is |
| N : constant Natural := Used_Char_Set + Character'Pos (C); |
| begin |
| IT.Table (N) := Item; |
| end Set_Used_Char; |
| |
| ------------------ |
| -- Set_Vertices -- |
| ------------------ |
| |
| procedure Set_Vertices (F : Natural; Item : Vertex_Type) is |
| N : constant Natural := Vertices + (F * Vertex_Size); |
| begin |
| IT.Table (N) := Item.First; |
| IT.Table (N + 1) := Item.Last; |
| end Set_Vertices; |
| |
| --------- |
| -- Sum -- |
| --------- |
| |
| function Sum |
| (Word : Word_Type; |
| Table : Table_Id; |
| Opt : Optimization) return Natural |
| is |
| S : Natural := 0; |
| R : Natural; |
| |
| begin |
| case Opt is |
| when CPU_Time => |
| for J in 0 .. T1_Len - 1 loop |
| exit when Word (J + 1) = ASCII.NUL; |
| R := Get_Table (Table, J, Get_Used_Char (Word (J + 1))); |
| S := (S + R) mod NV; |
| end loop; |
| |
| when Memory_Space => |
| for J in 0 .. T1_Len - 1 loop |
| exit when Word (J + 1) = ASCII.NUL; |
| R := Get_Table (Table, J, 0); |
| S := (S + R * Character'Pos (Word (J + 1))) mod NV; |
| end loop; |
| end case; |
| |
| return S; |
| end Sum; |
| |
| ------------------------ |
| -- Trim_Trailing_Nuls -- |
| ------------------------ |
| |
| function Trim_Trailing_Nuls (Str : String) return String is |
| begin |
| for J in reverse Str'Range loop |
| if Str (J) /= ASCII.NUL then |
| return Str (Str'First .. J); |
| end if; |
| end loop; |
| |
| return Str; |
| end Trim_Trailing_Nuls; |
| |
| --------------- |
| -- Type_Size -- |
| --------------- |
| |
| function Type_Size (L : Natural) return Natural is |
| begin |
| if L <= 2 ** 8 then |
| return 8; |
| elsif L <= 2 ** 16 then |
| return 16; |
| else |
| return 32; |
| end if; |
| end Type_Size; |
| |
| ----------- |
| -- Value -- |
| ----------- |
| |
| function Value |
| (Name : Table_Name; |
| J : Natural; |
| K : Natural := 0) return Natural |
| is |
| begin |
| case Name is |
| when Character_Position => |
| return Get_Char_Pos (J); |
| |
| when Used_Character_Set => |
| return Get_Used_Char (Character'Val (J)); |
| |
| when Function_Table_1 => |
| return Get_Table (T1, J, K); |
| |
| when Function_Table_2 => |
| return Get_Table (T2, J, K); |
| |
| when Graph_Table => |
| return Get_Graph (J); |
| |
| end case; |
| end Value; |
| |
| end GNAT.Perfect_Hash_Generators; |
