Added Ada source, FSF licensing, README.md.

Author: simonjwright

COPYING.RUNTIME

@@ -0,0 +1,73 @@
+GCC RUNTIME LIBRARY EXCEPTION
+
+Version 3.1, 31 March 2009
+
+Copyright (C) 2009 Free Software Foundation, Inc. <http://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This GCC Runtime Library Exception ("Exception") is an additional
+permission under section 7 of the GNU General Public License, version
+3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
+bears a notice placed by the copyright holder of the file stating that
+the file is governed by GPLv3 along with this Exception.
+
+When you use GCC to compile a program, GCC may combine portions of
+certain GCC header files and runtime libraries with the compiled
+program. The purpose of this Exception is to allow compilation of
+non-GPL (including proprietary) programs to use, in this way, the
+header files and runtime libraries covered by this Exception.
+
+0. Definitions.
+
+A file is an "Independent Module" if it either requires the Runtime
+Library for execution after a Compilation Process, or makes use of an
+interface provided by the Runtime Library, but is not otherwise based
+on the Runtime Library.
+
+"GCC" means a version of the GNU Compiler Collection, with or without
+modifications, governed by version 3 (or a specified later version) of
+the GNU General Public License (GPL) with the option of using any
+subsequent versions published by the FSF.
+
+"GPL-compatible Software" is software whose conditions of propagation,
+modification and use would permit combination with GCC in accord with
+the license of GCC.
+
+"Target Code" refers to output from any compiler for a real or virtual
+target processor architecture, in executable form or suitable for
+input to an assembler, loader, linker and/or execution
+phase. Notwithstanding that, Target Code does not include data in any
+format that is used as a compiler intermediate representation, or used
+for producing a compiler intermediate representation.
+
+The "Compilation Process" transforms code entirely represented in
+non-intermediate languages designed for human-written code, and/or in
+Java Virtual Machine byte code, into Target Code. Thus, for example,
+use of source code generators and preprocessors need not be considered
+part of the Compilation Process, since the Compilation Process can be
+understood as starting with the output of the generators or
+preprocessors.
+
+A Compilation Process is "Eligible" if it is done using GCC, alone or
+with other GPL-compatible software, or if it is done without using any
+work based on GCC. For example, using non-GPL-compatible Software to
+optimize any GCC intermediate representations would not qualify as an
+Eligible Compilation Process.
+
+1. Grant of Additional Permission.
+
+You have permission to propagate a work of Target Code formed by
+combining the Runtime Library with Independent Modules, even if such
+propagation would otherwise violate the terms of GPLv3, provided that
+all Target Code was generated by Eligible Compilation Processes. You
+may then convey such a combination under terms of your choice,
+consistent with the licensing of the Independent Modules.
+
+2. No Weakening of GCC Copyleft.
+
+The availability of this Exception does not imply any general
+presumption that third-party software is unaffected by the copyleft
+requirements of the license of GCC.
+

COPYING3

@@ -0,0 +1,58 @@
+# Analytical Engine Emulator
+
+This is an Ada translation of the Java emulator at
+[Fourmilab](http://www.fourmilab.ch/babbage/).
+
+In due course, it is hoped to create a web-based emulator (using
+[Gnoga](http://www.gnoga.com)). In the mean time, there is a command
+line based version.
+
+## Copying
+
+The Java source of the Fourmilab emulator is included in this
+repository for reference (in the <tt>java/</tt> subdirectory); the
+Analytical Engine code's author states _Emulator source code is
+intended for experienced Java developers, and is utterly
+unsupported. The program is in the public domain and you can do
+anything you like with it, but you're entirely on your own._, while
+<tt>BigInt.java</tt> is copyrighted by the Massachusetts Institute of
+Technology.
+
+The Ada source is licensed under the
+[GNU General Public License (version 3)][] with the
+[GCC Runtime Library exception][].
+
+[GNU General Public License (version 3)]: http://www.gnu.org/licenses/gpl.html
+[GCC Runtime Library exception]: http://www.gnu.org/licenses/gcc-exception-faq.html
+
+## Building
+
+The Ada emulator is written using [Ada2012][], and uses the
+[GNU Multiple Precision Arithmetic library][], via the
+[GMP binding in GNATCOLL][] (note, the actual binding used was that in
+AdaCore's GPL 2015 version, for reasons).
+
+If you have the [FSF GCC 6.1.0 binary for OS X][] a suitable library
+is provided. GMP and GNATCOLL (at least the 2015 version) are
+reasonably straightforward to build.
+
+[Ada2012]: http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-TOC.html
+
+[GNU Multiple Precision Arithmetic library]: https://gmplib.org
+
+[GMP binding in GNATCOLL]: https://github.com/AdaCore/gnatcoll/blob/master/src/gmp/gnatcoll-gmp-integers.ads
+
+[FSF GCC 6.1.0 binary for OS X]: https://sourceforge.net/projects/gnuada/files/GNAT_GCC%20Mac%20OS%20X/6.1.0/
+
+## Programming Cards
+
+The implementation here is as in the
+[Fourmilab Java implementation][]. To date only the card types up to
+and including Comment Cards have been implemented.
+
+As a minor change, lower case can be used: <tt>n001 42</tt> is acceptable.
+
+Multiplication and division can only be indicated by the <tt>*</tt>
+and <tt>/</tt> symbols (× and ÷ aren't supported).
+
+[Fourmilab Java implementation]: https://www.fourmilab.ch/babbage/cards.html

README.md

@@ -0,0 +1,27 @@
+with "gnatcoll_gmp";
+
+project Aes is
+
+   for Source_Dirs use ("src");
+   for Object_Dir use ".build";
+   for Exec_Dir use ".";
+
+   for Main use ("aes.adb");
+
+   package Builder is
+      for Default_Switches ("ada") use ("-g", "-O0");
+   end Builder;
+
+   package Compiler is
+   for Default_Switches ("ada") use
+     (
+      "-gnatwa",
+      "-gnatqQafoy"
+     );
+   end Compiler;
+
+   package Binder is
+      for Default_Switches ("ada") use ("-E");
+   end Binder;
+
+end Aes;

aes.gpr

@@ -0,0 +1,59 @@
+with Ada.Exceptions;
+with Ada.IO_Exceptions;
+with Ada.Text_IO; use Ada.Text_IO;
+with GNAT.Command_Line;
+
+with Analytical_Engine.Annunciator_Panel.Command_Line;
+with Analytical_Engine.Card_Reader;
+with Analytical_Engine.Framework;
+with Analytical_Engine.Output.Printer;
+
+use Analytical_Engine;
+
+procedure Aes is
+
+   Command_Line_Config : GNAT.Command_Line.Command_Line_Configuration;
+
+   Panel : constant Annunciator_Panel.Class_P
+     := new Annunciator_Panel.Command_Line.Instance;
+   F : Framework.Instance
+     := Framework.Create
+       (With_Panel => Panel,
+        With_Output => new Output.Printer.Instance (Panel));
+   R : constant Card_Reader.Instance_P := F.Card_Reader;
+
+begin
+
+   GNAT.Command_Line.Set_Usage (Command_Line_Config,
+                                Usage => "card-file",
+                                Help  => "Run the chain of cards");
+   --  There are no specific switches as yet, and there's a bug in
+   --  Getopt.
+   --  GNAT.Command_Line.Getopt (Command_Line_Config);
+
+   declare
+      Chain_File_Name : constant String := GNAT.Command_Line.Get_Argument;
+   begin
+      if Chain_File_Name = "" then
+         R.Add_Cards (Ada.Text_IO.Standard_Input);
+      else
+         declare
+            Chain_File : Ada.Text_IO.File_Type;
+         begin
+            Ada.Text_IO.Open (Chain_File,
+                              Name => Chain_File_Name,
+                              Mode => Ada.Text_IO.In_File);
+            R.Add_Cards (Chain_File);
+            Ada.Text_IO.Close (Chain_File);
+         exception
+            when E :
+              Ada.IO_Exceptions.Name_Error | Ada.IO_Exceptions.Use_Error =>
+               Ada.Text_IO.Put_Line
+                 (Ada.Text_IO.Standard_Error,
+                  "Couldn't open " & Ada.Exceptions.Exception_Message (E));
+               return;
+         end;
+      end if;
+      F.Run;
+   end;
+end Aes;

src/aes.adb

@@ -0,0 +1,25 @@
+with Ada.Text_IO; use Ada.Text_IO;
+package body Analytical_Engine.Annunciator_Panel.Command_Line is
+
+   procedure Log_Attendant_Message (Panel : Instance; Msg : String)
+   is
+      pragma Unreferenced (Panel);
+   begin
+      Put_Line (Msg);
+   end Log_Attendant_Message;
+
+   procedure Log_Trace_Message (Panel : Instance; Msg : String)
+   is
+      pragma Unreferenced (Panel);
+   begin
+      Put_Line (Msg);
+   end Log_Trace_Message;
+
+   procedure Initialize (This : in out Instance)
+   is
+      pragma Unreferenced (This);
+   begin
+      Put_Line ("annunciator_panel.command_line initialized");
+   end Initialize;
+
+end Analytical_Engine.Annunciator_Panel.Command_Line;

src/analytical_engine-annunciator_panel-command_line.adb

@@ -0,0 +1,18 @@
+package Analytical_Engine.Annunciator_Panel.Command_Line is
+
+   type Instance is new Annunciator_Panel.Instance with private;
+
+   overriding
+   procedure Log_Attendant_Message (Panel : Instance; Msg : String);
+
+   overriding
+   procedure Log_Trace_Message (Panel : Instance; Msg : String);
+
+private
+
+   type Instance is new Annunciator_Panel.Instance with null record;
+
+   overriding
+   procedure Initialize (This : in out Instance);
+
+end Analytical_Engine.Annunciator_Panel.Command_Line;

src/analytical_engine-annunciator_panel-command_line.ads

@@ -0,0 +1,8 @@
+package body Analytical_Engine.Annunciator_Panel is
+
+   procedure Set_Tracing (This : in out Instance; To : Boolean) is
+   begin
+      This.Tracing := To;
+   end Set_Tracing;
+
+end Analytical_Engine.Annunciator_Panel;

src/analytical_engine-annunciator_panel.adb

@@ -0,0 +1,26 @@
+private with Ada.Finalization;
+package Analytical_Engine.Annunciator_Panel is
+
+   type Instance is abstract tagged limited private;
+   type Class_P is access all Instance'Class;
+
+   procedure Log_Attendant_Message
+     (This : Instance; Msg : String) is abstract;
+
+   procedure Log_Trace_Message
+     (This : Instance; Msg : String) is abstract;
+
+   procedure Set_Tracing (This : in out Instance; To : Boolean);
+
+   function Tracing (This : Instance) return Boolean;
+
+private
+
+   type Instance
+     is abstract new Ada.Finalization.Limited_Controlled with record
+        Tracing : Boolean := False;
+     end record;
+
+   function Tracing (This : Instance) return Boolean is (This.Tracing);
+
+end Analytical_Engine.Annunciator_Panel;

src/analytical_engine-annunciator_panel.ads

@@ -0,0 +1,9 @@
+package body Analytical_Engine.Attendant is
+
+   procedure Initialize (This : in out Instance)
+   is
+   begin
+      This.Panel.Log_Attendant_Message ("attendant initialized");
+   end Initialize;
+
+end Analytical_Engine.Attendant;

src/analytical_engine-attendant.adb

@@ -0,0 +1,18 @@
+with Analytical_Engine.Annunciator_Panel;
+private with Ada.Finalization;
+package Analytical_Engine.Attendant is
+
+   type Instance (Panel : not null Annunciator_Panel.Class_P)
+   is tagged limited private;
+
+   type Instance_P is access all Instance;
+
+private
+
+   type Instance (Panel : not null Annunciator_Panel.Class_P)
+     is new Ada.Finalization.Limited_Controlled with null record;
+
+   overriding
+   procedure Initialize (This : in out Instance);
+
+end Analytical_Engine.Attendant;