!standard 2.8(29)                                    05-05-18  AI95-00433/01
!standard 3.2.2(15)
!standard 3.3.1(27)
!standard 3.3.1(29)
!standard 3.3.1(31)
!standard 3.3.1(33)
!standard 3.6(30)
!standard 3.7(37)
!standard 3.9.2(14)
!standard 3.10(22)
!standard 3.10.1(19)
!standard 3.10.1(20)
!standard 3.10.1(21)
!standard 4.3.3(43)
!standard 6.5.1(9)
!standard 6.7(4)
!standard 9.1(24)
!standard 9.11(3)
!standard 9.11(6)
!standard 9.11(7)
!standard 9.11(8)
!standard 9.11(9)
!standard 9.11(10)
!standard 10.1.2(24)
!standard 11.3(6)
!standard 12.5.5(5)
!standard 12.6(18)
!standard 12.7(11)
!class amendment 05-05-18
!status Amendment 200Y 05-05-18
!status work item 05-05-18
!status received 05-05-18
!priority High
!difficulty Easy
!subject Examples in the RM

!summary

(See proposal.)

!problem

The examples in the RM must be updated to reflect the new language.

!proposal

Tuck did the examples in a stream-of-consciousness manner, and Pascal got the
short stick to write an AI.

!wording

(See corrigendum.)

!discussion

(See proposal.)

!example

An example for examples? Get real!

!corrigendum 2.8(29)

@drepl
@xcode<@b<pragma> List(Off); @ft<@i<-- turn off listing generation>>
@b<pragma> Optimize(Off); @ft<@i<-- turn off optional optimizations>>
@b<pragma> Inline(Set_Mask); @ft<@i<-- generate code for Set_Mask inline>>
@b<pragma> Suppress(Range_Check, On =@> Index); @ft<@i<-- turn off range checking on Index>>>

@dby
@xcode<@b<pragma> List(Off); @ft<@i<-- turn off listing generation>>
@b<pragma> Optimize(Off); @ft<@i<-- turn off optional optimizations>>
@b<pragma> Inline(Set_Mask); @ft<@i<-- generate code for Set_Mask inline>>
@b<pragma> Import(C, Put_Char, External_Name =@> "putchar"); @ft<@i<-- import C putchar function>>>


!corrigendum 3.2.2(15)

@drepl
@xcode<@b<subtype> Rainbow   @b<is> Color @b<range> Red .. Blue;        @ft<@i<--  see 3.2.1>>
@b<subtype> Red_Blue  @b<is> Rainbow;
@b<subtype> Int       @b<is> Integer;
@b<subtype> Small_Int @b<is> Integer @b<range> -10 .. 10;
@b<subtype> Up_To_K   @b<is> Column @b<range> 1 .. K;            @ft<@i<--  see 3.2.1>>
@b<subtype> Square    @b<is> Matrix(1 .. 10, 1 .. 10);       @ft<@i<--  see 3.6>>
@b<subtype> Male      @b<is> Person(Sex =@> M);               @ft<@i<--  see 3.10.1>>>

@dby
@xcode<@b<subtype> Rainbow   @b<is> Color @b<range> Red .. Blue;        @ft<@i<--  see 3.2.1>>
@b<subtype> Red_Blue  @b<is> Rainbow;
@b<subtype> Int       @b<is> Integer;
@b<subtype> Small_Int @b<is> Integer @b<range> -10 .. 10;
@b<subtype> Up_To_K   @b<is> Column @b<range> 1 .. K;            @ft<@i<--  see 3.2.1>>
@b<subtype> Square    @b<is> Matrix(1 .. 10, 1 .. 10);       @ft<@i<--  see 3.6>>
@b<subtype> Male      @b<is> Person(Sex =@> M);               @ft<@i<--  see 3.10.1>>
@b<subtype> Binop_Ref @b<is not null> Binop_Ptr;             @ft<@i<-- see 3.10>>>


!corrigendum 3.3.1(27)

@drepl
@xcode<John, Paul : Person_Name := @b<new> Person(Sex =@> M);  @ft<@i<--  see 3.10.1>>>

@dby
@xcode<John, Paul : @b<not null> Person_Name := @b<new> Person(Sex =@> M);  @ft<@i<--  see 3.10.1>>>


!corrigendum 3.3.1(29)

@drepl
@xcode<John : Person_Name := @b<new> Person(Sex =@> M);
Paul : Person_Name := @b<new> Person(Sex =@> M);>

@dby
@xcode<John : @b<not null> Person_Name := @b<new> Person(Sex =@> M);
Paul : @b<not null> Person_Name := @b<new> Person(Sex =@> M);>


!corrigendum 3.3.1(31)

@drepl
@xcode<Count, Sum  : Integer;
Size        : Integer @b<range> 0 .. 10_000 := 0;
Sorted      : Boolean := False;
Color_Table : @b<array>(1 .. Max) @b<of> Color;
Option      : Bit_Vector(1 .. 10) := (@b<others> =@> True);
Hello       : @b<constant> String := "Hi, world.";>

@dby
@xcode<Count, Sum  : Integer;
Size        : Integer @b<range> 0 .. 10_000 := 0;
Sorted      : Boolean := False;
Color_Table : @b<array>(1 .. Max) @b<of> Color;
Option      : Bit_Vector(1 .. 10) := (@b<others> =@> True);
Hello       : @b<aliased> String := "Hi, world.";>


!corrigendum 3.3.1(33)

@drepl
@xcode<Limit     : @b<constant> Integer := 10_000;
Low_Limit : @b<constant> Integer := Limit/10;
Tolerance : @b<constant> Real := Dispersion(1.15);>

@dby
@xcode<Limit     : @b<constant> Integer := 10_000;
Low_Limit : @b<constant> Integer := Limit/10;
Tolerance : @b<constant> Real := Dispersion(1.15);
Hello_Msg : @b<constant access> String := Hello'Access; @ft<@i<-- see 3.10.2>>>


!corrigendum 3.6(30)

@drepl
@xcode<Grid : @b<array>(1 .. 80, 1 .. 100) @b<of> Boolean;
Mix  : @b<array>(Color @b<range> Red .. Green) @b<of> Boolean;
Page : @b<array>(Positive @b<range> <@>) @b<of> Line :=  @ft<@i<--  an array of arrays>>
  (1 | 50  =@> Line'(1 | Line'Last =@> '+', @b<others> =@> '-'),  @ft<@i<-- see 4.3.3>>
   2 .. 49 =@> Line'(1 | Line'Last =@> '|', @b<others> =@> ' '));
    @ft<@i<-- Page is constrained by its initial value to (1..50)>>>

@dby
@xcode<Grid : @b<array>(1 .. 80, 1 .. 100) @b<of> Boolean;
Mix       : @b<array>(Color @b<range> Red .. Green) @b<of> Boolean;
Msg_Table : @b<constant array>(Error_Code) @b<of access constant> String :=
      (Too_Big =@> @b<new> String'("Result too big"), Too_Small =@> ...);
Page      : @b<array>(Positive @b<range> <@>) @b<of> Line :=  @ft<@i<--  an array of arrays>>
  (1 | 50  =@> Line'(1 | Line'Last =@> '+', @b<others> =@> '-'),  @ft<@i<-- see 4.3.3>>
   2 .. 49 =@> Line'(1 | Line'Last =@> '|', @b<others> =@> ' '));
    @ft<@i<-- Page is constrained by its initial value to (1..50)>>>


!corrigendum 3.7(37)

@drepl
@xcode<@b<type> Item(Number : Positive) @b<is
   record>
      Content : Integer;
      @ft<@i<--  no component depends on the discriminant>>
   @b<end record>;>

@dby
@xcode<@b<task type> Worker(Prio : System.Priority; Buf : @b<access> Buffer) @b<is>
   @ft<@i<-- discriminants used to parameterize the task type (see 9.1)>>
   @b<pragma> Priority(Prio);  @ft<@i<-- see D.1>>
   @b<entry> Fill;
   @b<entry> Drain;
@b<end> Worker;>


!corrigendum 3.9.2(14)

@dinsa
Nonlimited interface types have predefined nonabstract equality operators. These may be overridden with user-defined abstract equality operators. Such operators will then require an explicit overriding for any nonabstract descendant of the interface.

@dinss
@i<@s8<Examples>>

@i<Example of limited interface and synchronized interface extending it:>

@xcode<@b<type> Queue @b<is limited interface>;
@b<procedure> Append(Q : @b<in out> Queue; Elem : @b<in> Element) @b<is abstract>;
@b<procedure> Remove_First(Q : @b<in out> Queue; Elem : @b<out> Element) @b<is abstract>;
@b<function> Cur_Count(Q : @b<in> Queue) @b<return> Natural @b<is abstract>;
@b<function> Max_Count(Q : @b<in> Queue) @b<return> Natural @b<is abstract>;

Queue_Error : @b<exception>;
@ft<@i<-- Append raises Queue_Error if Count(Q) = Max_Count(Q)
-- Remove_First raises Queue_Error if Count(Q) = 0>>

@b<type> Synchronized_Queue @b<is synchronized interface and> Queue; @ft<@i<-- see 9.11>>
@b<procedure> Append_Wait(Q : @b<in out> Queue; Elem : @b<in> Element) @b<is abstract>;
@b<procedure> Remove_First_Wait(Q : @b<in out> Queue; Elem : @b<out> Element) @b<is abstract>;

...

@b<procedure> Transfer(From : @b<in out> Queue'Class;
                   To : @b<in out> Queue'Class;
                   Number : @b<in> Natural := 1) is
   Elem : Element;
@b<begin
   for> I @b<in> 1..Number @b<loop>
      Remove_First(From, Elem);
      Append(To, Elem);
   @b<end loop>;
@b<end> Transfer;>

The Queue interface has four dispatching operations, Append,
Remove_First, Cur_Count, and Max_Count.  The body of a class-wide
operation, Transfer is also shown.  Every non-abstract extension
of Queue must provide implementations for at least its four
dispatching operations.  Any object of a type derived from Queue
may be passed to Transfer, as either the From or the To operand.
The two operands need not be of the same type in any given call.

The Synchronized_Queue interface inherits the four dispatching
operations from Queue, and adds two additional dispatching
operations, which wait if necessary rather than raising the
Queue_Error exception.  This synchronized interface may only
be implemented by a task or protected type, and as such
ensures safe concurrent access.

@i<Example of task interface:>

@xcode<@b<type> Serial_Device @b<is task interface>;  @ft<@i<-- see 9.1>>
@b<procedure> Read (Dev : @b<in> Serial_Device; C : @b<out> Character) @b<is abstract>;
@b<procedure> Write(Dev : @b<in> Serial_Device; C : @b<in>  Character) @b<is abstract>;>

The Serial_Device interface has two dispatching operations
which are intended to be implemented using task entries (see 9.1).


!corrigendum 3.10(22)

@drepl
@xcode<@b<type> Peripheral_Ref @b<is access> Peripheral;  @ft<@i<--  see 3.8.1>>
@b<type> Binop_Ptr @b<is access all> Binary_Operation'Class;
                                           @ft<@i<-- general access-to-class-wide, see 3.9.1>>>

@dby
@xcode<@b<type> Peripheral_Ref @b<is not null access> Peripheral;  @ft<@i<--  see 3.8.1>>
@b<type> Binop_Ptr @b<is access all> Binary_Operation'Class;
                                           @ft<@i<-- general access-to-class-wide, see 3.9.1>>>


!corrigendum 3.10.1(19)

@drepl
@xcode<@b<type> Person(<@>);    @ft<@i<-- incomplete type declaration>>
@b<type> Car;           @ft<@i<-- incomplete type declaration>>>

@dby
@xcode<@b<type> Person(<@>);    @ft<@i<-- incomplete type declaration>>
@b<type> Car @b<is tagged>; @ft<@i<-- incomplete type declaration>>>


!corrigendum 3.10.1(20)

@drepl
@xcode<@b<type> Person_Name @b<is access> Person;
@b<type> Car_Name    @b<is access all> Car;>

@dby
@xcode<@b<type> Person_Name @b<is access> Person;
@b<type> Car_Name    @b<is access all> Car'Class;>


!corrigendum 3.10.1(21)

@drepl
@xcode<@b<type> Car @b<is>
   @b<record>
      Number  : Integer;
      Owner   : Person_Name;
   @b<end record>;>

@dby
@xcode<@b<type> Car @b<is tagged>
   @b<record>
      Number  : Integer;
      Owner   : Person_Name;
   @b<end record>;>


!corrigendum 4.3.3(43)

@dinsa
@xcode<D : Bit_Vector(M .. N) := (M .. N =@> True);         @ft<@i<-- see 3.6>>
E : Bit_Vector(M .. N) := (@b<others> =@> True);
F : String(1 .. 1) := (1 =@> 'F');  @ft<@i<-- a one component aggregate: same as "F">>>

@dinss
@i<Example of array aggregate with defaulted others choice, with applicable index constraint provided by an enclosing record aggregate:>

@xcode<Buffer'(Size =@> 50, Pos =@> 1, Value =@> String'('x', @b<others> =@> <@>))  @ft<@i<-- see 3.7>>>


!corrigendum 6.5.1(9)

@dinsa
If the body of a non-returning procedure completes normally, Program_Error is raised at the point of the call.

@dinss
@i<@s8<Example>>

@xcode<@b<procedure> Fail(Msg : String);  @ft<@i<-- raises Fatal_Error exception>>
@b<pragma> No_Return(Fail);
@ft<@i<-- Inform compiler and reader that procedure never returns normally>>>


!corrigendum 6.7(4)

@dinsa
The execution of a null procedure is invoked by a subprogram call. For the execution of a subprogram call on a null procedure, the execution of the @fa<subprogram_body> has no effect.

@dinst
@i<@s8<Example>>

@xcode<@b<procedure> Simplify(Expr : @b<in out> Expression) @b<is null>; @ft<@i<-- see 3.9
-- By default, Simplify does nothing, but it may be overridden in extensions of Expression>>>


!corrigendum 9.1(24)

@drepl
@xcode<@b<task type> Keyboard_Driver(ID : Keyboard_ID := New_ID) @b<is>
   @b<entry> Read (C : @b<out> Character);
   @b<entry> Write(C : @b<in>  Character);
@b<end> Keyboard_Driver;>

@dby
@xcode<@b<task type> Keyboard_Driver(ID : Keyboard_ID := New_ID) @b<is>
      @b<new> Serial_Device @b<with>  @ft<@i<-- see 3.9>>
   @b<entry> Read (C : @b<out> Character);
   @b<entry> Write(C : @b<in>  Character);
@b<end> Keyboard_Driver;>


!corrigendum 9.11(3)

@drepl
@xcode<@b<task body> Producer @b<is>
   Char : Character;
@b<begin
   loop>
      ... @ft<@i<--  produce the next character Char>>
      Buffer.Write(Char);
      @b<exit when> Char = ASCII.EOT;
   @b<end loop;
end> Producer;>

@dby
@xcode<@b<task body> Producer @b<is>
   Elem : Element;
@b<begin
   loop>
      ... @ft<@i<--  produce the next element>>
      Buffer.Append_Wait(Elem);
      @b<exit when> Elem = EOT_Elem;
   @b<end loop;
end> Producer;>


!corrigendum 9.11(6)

@drepl
@xcode<@b<task body> Consumer @b<is>
   Char : Character;
@b<begin
   loop>
      Buffer.Read(Char);
      @b<exit when> Char = ASCII.EOT;
      ... @ft<@i<--  consume the character Char>>
   @b<end loop;
end> Consumer;>

@dby
@xcode<@b<task body> Consumer @b<is>
   Elem : Element;
@b<begin
   loop>
      Buffer.Remove_First_Wait(Elem);
      @b<exit when> Elem = EOT_Elem;
      ... @ft<@i<--  consume the element>>
   @b<end loop;
end> Consumer;>


!corrigendum 9.11(7)

@drepl
The buffer object contains an internal pool of characters managed in a round-robin fashion. The pool has two indices, an In_Index denoting the space for the next input character and an Out_Index denoting the space for the next output character.

@dby
The buffer object contains an internal pool of elements managed in a round-robin fashion. The pool has two indices, an In_Index denoting the space for the next input element and an Out_Index denoting the space for the next output element.

The Buffer is defined as an extension of the Synchronized_Queue
interface (see 3.9.4), and as such, can be passed to the Transfer
class-wide operation defined for objects of a type covered by
Queue'Class.


!corrigendum 9.11(8)

@drepl
@xcode<@b<protected> Buffer @b<is
   entry> Read (C : @b<out> Character);
   @b<entry> Write(C : @b<in>  Character);
@b<private>
   Pool      : String(1 .. 100);
   Count     : Natural := 0;
   In_Index, Out_Index : Positive := 1;
@b<end> Buffer;>

@dby
@xcode<@b<protected> Buffer @b<is new> Synchronized_Queue @b<with>  @ft<@i<-- see 3.9.4>>
   @b<entry> Append_Wait (Elem : @b<in> Element);
   @b<entry> Remove_First_Wait (Elem : @b<out> Element);
   @b<function> Cur_Count @b<return> Natural;
   @b<function> Max_Count @b<return> Natural;
   @b<procedure> Append(Elem : @b<in> Element);
   @b<procedure> Remove_First(Elem : @b<out> Element);
@b<private>
   Pool      : Element_Array(1 .. 100);
   Count     : Natural := 0;
   In_Index, Out_Index : Positive := 1;
@b<end> Buffer;


!corrigendum 9.11(9)

@drepl
@xcode<@b<protected body> Buffer @b<is
   entry> Write(C : @b<in> Character)
      @b<when> Count < Pool'Length @b<is
   begin>
      Pool(In_Index) := C;
      In_Index := (In_Index @b<mod> Pool'Length) + 1;
      Count    := Count + 1;
   @b<end> Write;>

@dby
@xcode<@b<protected body> Buffer @b<is
   entry> Append_Wait (Elem : @b<in> Element)
      @b<when> Count < Pool'Length @b<is
   begin>
      Append(Elem);
   @b<end> Append_Wait;

   @b<procedure> Append(Elem : @b<in> Element) @b<is
   begin
      if> Count = Pool'Length @b<then
         raise> Queue_Error @b<with> "Buffer Full";  @ft<@i<-- see 11.3>>
      @b<end if>;
      Pool(In_Index) := Elem;
      In_Index := (In_Index @b<mod> Pool'Length) + 1;
      Count    := Count + 1;
   @b<end> Append;>


!corrigendum 9.11(10)

@drepl
@xcode<   @b<entry> Read(C : @b<out> Character)
      @b<when> Count @> 0 @b<is
   begin>
      C := Pool(Out_Index);
      Out_Index := (Out_Index @b<mod> Pool'Length) + 1;
      Count     := Count - 1;
   @b<end> Read;
@b<end> Buffer;>

@dby
@xcode<   @b<entry> Remove_First_Wait (Elem : @b<out> Element)
      @b<when> Count @> 0 @b<is
   begin>
      Remove_First(Elem);
   @b<end> Remove_First_Wait;

   @b<procedure> Remove_First(Elem : @b<out> Element) @b<is
   begin
      if> Count = 0 @b<then
         raise> Queue_Error @b<with> "Buffer Empty"; @ft<@i<-- see 11.3>>
      @b<end if>;
      Elem := Pool(Out_Index);
      Out_Index := (Out_Index @b<mod> Pool'Length) + 1;
      Count     := Count - 1;
   @b<end> Remove_First;

   @b<function> Cur_Count @b<return> Natural @b<is
   begin
       return> Buffer.Count;
   @b<end> Cur_Count;

   @b<function> Max_Count @b<return> Natural @b<is
   begin
       return> Pool'Length;
   @b<end> Max_Count;
@b<end> Buffer;>


!corrigendum 10.1.2(24)

@dinsa
@xbullet<in the scope of a @fa<use_clause> which names an entity declared
within the declarative region of the @fa<library_item>.>

@dinss
@i<@s8<Example>>

@xcode<@b<limited with> Office.Departments;  @ft<@i<-- types are incomplete>>
@b<private with> Office.Locations;    @ft<@i<-- only visible in private part>>
@b<package> Office.Employees @b<is>
   @b<type> Employee @b<is private>;

   @b<function> Dept_Of(Emp : Employee) @b<return access> Departments.Department;
   @b<procedure> Assign_Dept(Emp  : @b<in out> Employee;
                         Dept : @b<access> Departments.Department);
   ...
@b<private
   type> Employee @b<is
      record>
         Dept : @b<access> Departments.Department;
         Loc : Locations.Location;
         ...
      @b<end record>;
@b<end> Office.Employees;

@b<limited with> Office.Employees;
@b<package> Office.Departments @b<is>
   @b<type> Department @b<is private>;

   @b<function> Manager_Of(Dept : Department) @b<return access> Employees.Employee;
   @b<procedure> Assign_Manager(Dept : @b<in out> Department;
                            Mgr  : @b<access> Employees.Employee);
   ...
@b<end> Office.Departments;>

The @fa<limited_with_clause> may be used to support mutually dependent
abstractions that are split across multiple packages.  In this
case, an employee is assigned to a department, and a department has
a manager who is an employee.  If a @fa<with_clause> with the reserved
word @b<private> appears on one library unit and mentions a second
library unit, it provides visibility to the second library unit, but
restricts that visibility to the private part and body of the first
unit. The compiler checks that no use is made of the second unit in
the visible part of the first unit.


!corrigendum 11.3(6)

@drepl
@xcode<@b<raise> Ada.IO_Exceptions.Name_Error;   @ft<@i<-- see A.13>>>

@dby
@xcode<@b<raise> Ada.IO_Exceptions.Name_Error;    @ft<@i<-- see A.13>>
@b<raise> Queue_Error @b<with> "Buffer Full";  @ft<@i<-- see 9.11>>>


!corrigendum 12.5.5(5)

@dinsa
The actual type shall be a limited, task, protected, or synchronized interface if and only if the formal type is also, respectively, a limited, task, protected, or synchronized interface.

@dinss
@i<@s8<Example>>

@xcode<@b<generic
   type> Managed_Task @b<is task interface>;
   @b<type> Work_Item(<@>) @b<is new> Root_Work_Item @b<with private>;
@b<package> Server_Manager @b<is
   task type> Server @b<is new> Managed_Task @b<with
      entry> Start(Data : @b<access> Work_Item);
   @b<end> Server;
@b<end> Server_Manager;>

This generic allows an application to establish a standard interface
that all tasks need to implement so they can be managed appropriately
by an application-specific scheduler.


!corrigendum 12.6(18)

@drepl
@xcode<@b<with function> "+"(X, Y : Item) @b<return> Item @b<is> <@>;
@b<with function> Image(X : Enum) @b<return> String @b<is> Enum'Image;
@b<with procedure> Update @b<is> Default_Update;>

@dby
@xcode<@b<with function> "+"(X, Y : Item) @b<return> Item @b<is> <@>;
@b<with function> Image(X : Enum) @b<return> String @b<is> Enum'Image;
@b<with procedure> Update @b<is> Default_Update;
@b<with procedure> Pre_Action(X : in Item) @b<is null>;  @ft<@i<-- defaults to no action>>
@b<with procedure> Write(S    : @b<access> Root_Stream_Type'Class;
                     Desc : Descriptor)
                     @b<is abstract> Descriptor'Write;  @ft<@i<-- see 13.13.2>>
@ft<@i<-- Dispatching operation on Descriptor with default>>>


!corrigendum 12.7(11)

@dinsa
For the purposes of matching, if the actual instance @i<A> is itself a
formal package, then the actual parameters of @i<A> are those specified
explicitly or implicitly in the @fa<formal_package_actual_part> for @i<A>, plus,
for those not specified, the copies of the formal parameters of the
template included in the visible part of @i<A>.

@dinss
@i<@s8<Examples>>

@i<Example of generic package with formal package parameters:>

@xcode<@b<generic
   with package> Mapping_1 @b<is new> Generic_Mapping(<@>);
   @b<with package> Mapping_2 @b<is new> Generic_Mapping
                                    (Key_Type =@> Mapping_1.Element_Type,
                                     @b<others> =@> <@>);
@b<package> Generic_Join @b<is>
   @ft<@i<-- Provide a "join" between two mappings>>

   @b<subtype> Key_Type @b<is> Mapping_1.Key_Type;
   @b<subtype> Element_Type @b<is> Mapping_2.Element_Type;

   @b<function> Lookup(Key : Key_Type) @b<return> Element_Type;

   ...
@b<end> Generic_Join;>

@i<Example of instantiation of package with formal packages:>

@xcode<@b<package> String_Table @b<is new> Generic_Mapping(Key_Type =@> String,
                                            Element_Type =@> String_ID);

@b<package> Symbol_Table @b<is new> Generic_Mapping(Key_Type =@> String_ID,
                                            Element_Type =@> Symbol_Info);

@b<package> String_Info @b<is new> Generic_Join(Mapping_1 =@> String_Table,
                                        Mapping_2 =@> Symbol_Table);

Apple_Info : @b<constant> Symbol_Info := String_Info.Lookup("Apple");>

!ACATS test

This one is going to be hard to test!

!appendix

****************************************************************