mittens 0.1.0

data/vendor/snowball/README.rst

@@ -0,0 +1,37 @@
+Snowball is a small string processing language for creating stemming algorithms
+for use in Information Retrieval, plus a collection of stemming algorithms
+implemented using it.
+
+Snowball was originally designed and built by Martin Porter.  Martin retired
+from development in 2014 and Snowball is now maintained as a community project.
+Martin originally chose the name Snowball as a tribute to SNOBOL, the excellent
+string handling language from the 1960s.  It now also serves as a metaphor for
+how the project grows by gathering contributions over time.
+
+The Snowball compiler translates a Snowball program into source code in another
+language - currently Ada, ISO C, C#, Go, Java, Javascript, Object Pascal,
+Python and Rust are supported.
+
+This repository contains the source code for the snowball compiler and the
+stemming algorithms.  The snowball compiler is written in ISO C - you'll need
+a C compiler which support C99 to build it (but the C code it generates should
+work with any ISO C compiler).
+
+See https://snowballstem.org/ for more information about Snowball.
+
+What is Stemming?
+=================
+
+Stemming maps different forms of the same word to a common "stem" - for
+example, the English stemmer maps *connection*, *connections*, *connective*,
+*connected*, and *connecting* to *connect*.  So a searching for *connected*
+would also find documents which only have the other forms.
+
+This stem form is often a word itself, but this is not always the case as this
+is not a requirement for text search systems, which are the intended field of
+use.  We also aim to conflate words with the same meaning, rather than all
+words with a common linguistic root (so *awe* and *awful* don't have the same
+stem), and over-stemming is more problematic than under-stemming so we tend not
+to stem in cases that are hard to resolve.  If you want to always reduce words
+to a root form and/or get a root form which is itself a word then Snowball's
+stemming algorithms likely aren't the right answer.

data/vendor/snowball/ada/README.md

@@ -0,0 +1,74 @@
+# Ada Target for Snowball
+
+The Ada Snowball generator generates an Ada child package for each Snowball algorithm.
+The parent package is named `Stemmer` and it provides various operations used by the generated code.
+The `Stemmer` package contains the Ada Snowball runtime available either in `ada/src` directory
+or from https://github.com/stcarrez/ada-stemmer.
+
+The generated child package declares the `Context_Type` tagged type and the `Stem` procedure:
+
+```Ada
+package Stemmer.<Algorithm-name> is
+   type Context_Type is new Stemmer.Context_Type with private;
+   procedure Stem (Z : in out Context_Type; Result : out Boolean);
+private
+   type Context_Type is new Stemmer.Context_Type with record
+      ...
+   end record;
+end Stemmer.<Algorithm-name>;
+```
+
+It is possible to use directly the generated operation or use it through the `Stemmer.Factory` package.
+
+## Usage
+
+To generate Ada source for a Snowball algorithm:
+```
+$ snowball path/to/algorithm.sbl -ada -P <algorithm-name> -o src/stemmer-<algorithm>
+```
+
+### Ada specific options
+
+`-P <Algorithm-name>` the child package name used in the generated Ada file (defaults to `snowball`).
+It must be a valid Ada identifier.
+
+## Code Organization
+
+`compiler/generator_ada.c` has the Ada code generation logic
+
+`ada/src` contains the default Ada Snowball runtime support which is also
+available at https://github.com/stcarrez/ada-stemmer
+
+`ada/algorithms` location where the makefile generated code will end up
+
+## Using the Generated Stemmers
+
+To use the generated stemmer, import the Ada generated package, declare an instance
+of the generated `Context_Type` and call the `Stem_Word` procedure.
+
+```
+with Stemmer.English;
+
+  Ctx : Stemmer.English.Context_Type;
+  Result : Boolean;
+
+  Ctx.Stem_Word ("zealously", Result);
+  if Result then
+     Ada.Text_IO.Put_Line (Ctx.Get_Result);
+  end if;
+```
+
+You can use the context as many times as you want.
+
+## Testing
+
+To run the tests, you will need an Ada compiler such as GNAT as well as the `gprbuild` build tool.
+
+Only the existing Snowball algorithms have been used for testing.  This does not exercise all features of the language.
+
+Run:
+
+```
+$ make check_ada
+```
+

data/vendor/snowball/ada/generate/generate.adb

@@ -0,0 +1,83 @@
+with Ada.Characters.Handling;
+with Ada.Text_IO;
+with Ada.Command_Line;
+with Ada.Containers.Indefinite_Vectors;
+procedure Generate is
+
+   use Ada.Characters.Handling;
+   use Ada.Text_IO;
+
+   package String_Vectors is new Ada.Containers.Indefinite_Vectors
+     (Element_Type => String,
+      Index_Type   => Positive);
+
+   Languages : String_Vectors.Vector;
+
+   function Capitalize (S : in String) return String is
+      (To_Upper (S (S'First)) & S (S'First + 1 .. S'Last));
+
+   procedure Write_Spec is
+      File : File_Type;
+      I    : Natural := 0;
+   begin
+      Create (File, Out_File, "stemmer-factory.ads");
+      Put_Line (File, "package Stemmer.Factory with SPARK_Mode is");
+      New_Line (File);
+      Put (File, "   type Language_Type is (");
+      for Lang of Languages loop
+         Put (File, "L_" & To_Upper (Lang));
+         I := I + 1;
+         if I < Natural (Languages.Length) then
+            Put_Line (File, ",");
+            Put (File, "                          ");
+         end if;
+      end loop;
+      Put_Line (File, ");");
+      New_Line (File);
+      Put_Line (File, "   function Stem (Language : in Language_Type;");
+      Put_Line (File, "                  Word     : in String) return String;");
+      New_Line (File);
+      Put_Line (File, "end Stemmer.Factory;");
+      Close (File);
+   end Write_Spec;
+
+   procedure Write_Body is
+      File : File_Type;
+   begin
+      Create (File, Out_File, "stemmer-factory.adb");
+      for Lang of Languages loop
+         Put_Line (File, "with Stemmer." & Capitalize (Lang) & ";");
+      end loop;
+      Put_Line (File, "package body Stemmer.Factory with SPARK_Mode is");
+      New_Line (File);
+      Put_Line (File, "   function Stem (Language : in Language_Type;");
+      Put_Line (File, "                  Word     : in String) return String is");
+      Put_Line (File, "      Result : Boolean := False;");
+      Put_Line (File, "   begin");
+      Put_Line (File, "      case Language is");
+      for Lang of Languages loop
+         Put_Line (File, "      when L_" & To_Upper (Lang) & " =>");
+         Put_Line (File, "         declare");
+         Put_Line (File, "            C : Stemmer." & Capitalize (Lang) & ".Context_Type;");
+         Put_Line (File, "         begin");
+         Put_Line (File, "            C.Stem_Word (Word, Result);");
+         Put_Line (File, "            return Get_Result (C);");
+         Put_Line (File, "         end;");
+         New_Line (File);
+      end loop;
+      Put_Line (File, "      end case;");
+      Put_Line (File, "   end Stem;");
+      New_Line (File);
+      Put_Line (File, "end Stemmer.Factory;");
+      Close (File);
+   end Write_Body;
+
+   Count  : constant Natural := Ada.Command_Line.Argument_Count;
+
+begin
+   for I in 1 .. Count loop
+      Languages.Append (To_Lower (Ada.Command_Line.Argument (I)));
+   end loop;
+   Write_Spec;
+   Write_Body;
+end Generate;

data/vendor/snowball/ada/generate.gpr

@@ -0,0 +1,21 @@
+with "stemmer_config";
+project Generate is
+
+   Mains := ("generate.adb");
+
+   for Main use Mains;
+
+   for Source_Dirs use ("generate");
+
+   for Object_Dir use "./" & Stemmer_Config'Object_Dir & "/obj";
+   for Exec_Dir use "./" & Stemmer_Config'Exec_Dir & "/bin";
+
+   package Binder renames Stemmer_Config.Binder;
+
+   package Builder renames Stemmer_Config.Builder;
+
+   package Compiler renames Stemmer_Config.Compiler;
+
+   package Linker renames Stemmer_Config.Linker;
+
+end Generate;