DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download

⟦d6ca49f02⟧ Ada Source

    Length: 18432 (0x4800)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Automate, seg_02eed0, separate Lex

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

E3 Source Code



separate (Lex)
package body Automate is
    The_String : Standard_String.Object;


    function Get return Standard_String.Object is
    begin
        return The_String;
    end Get;



    function Double_Point_State return Token is
        C : Character;
    begin
        C := Get_Next_Character (The_File);
        case C is
            when '=' =>
                return Token'(Let);
            when others =>  
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Double_Point_State;



    function Greater_State return Token is
        C : Character;
    begin
        C := Get_Next_Character (The_File);
        case C is
            when '=' =>
                return Token'(Geq);
            when others =>  
                Look_Ahead.Set (To => C);
                return Token'(Great);
        end case;  
    end Greater_State;



    function Less_State return Token is
        C : Character;
    begin
        C := Get_Next_Character (The_File);
        case C is  
            when '>' =>
                return Token'(Neq);
            when '=' =>
                return Token'(Leq);
            when others =>  
                Look_Ahead.Set (To => C);
                return Token'(Less);
        end case;  
    end Less_State;



    function Comment_State return Token;


    function End_Of_Comment_State return Token is
        C : Character;
    begin
        C := Get_Next_Character (The_File);
        case C is
            when '/' =>
                return Start;
            when others =>
                return Comment_State;
        end case;  
    end End_Of_Comment_State;



    function Comment_State return Token is
        C : Character;
    begin
        C := Get_Next_Character (The_File);
        case C is
            when '*' =>
                return End_Of_Comment_State;
            when others =>
                return Comment_State;
        end case;  
    end Comment_State;



    function Start_Comment_State return Token is
        C : Character;
    begin
        C := Get_Next_Character (The_File);
        case C is
            when '*' =>
                return Comment_State;
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Start_Comment_State;





    function Based_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' | 'a' .. 'z' | 'A' .. 'Z' =>
                return Based_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Based);
        end case;  
    end Based_State;



    function Based_Number_Value_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' | 'a' .. 'z' | 'A' .. 'Z' =>
                return Based_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Based_Number_Value_State;



    function The_Base_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return The_Base_State (C);
            when '#' =>
                return Based_Number_Value_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end The_Base_State;



    function Start_Of_Based_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return The_Base_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Start_Of_Based_State;



    function Hour_With_S_State (In_Character : Character) return Token is
    begin
        Standard_String.Append (In_Character, To => The_String);
        return Token'(Hour);
    end Hour_With_S_State;



    function Tenth_Of_Second_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when 's' | 'S' =>
                return Hour_With_S_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Tenth_Of_Second_State;



    function Point_Of_Second_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return Tenth_Of_Second_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Point_Of_Second_State;



    function Second_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return Second_State (C);
            when '.' =>
                return Point_Of_Second_State (C);
            when 's' | 'S' =>
                return Hour_With_S_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Second_State;



    function Hour_With_M_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return Second_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Hour);
        end case;  
    end Hour_With_M_State;



    function Minute_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return Minute_State (C);
            when '.' =>
                return Point_Of_Second_State (C);
            when 'm' | 'M' =>
                return Hour_With_M_State (C);
            when 's' | 'S' =>
                return Hour_With_S_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Minute_State;



    function Hour_With_H_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return Minute_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Hour);
        end case;  
    end Hour_With_H_State;



    function Int_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when '0' .. '9' =>
                return Int_State (C);
            when 'h' | 'H' =>
                return Hour_With_H_State (C);
            when 'm' | 'M' =>
                return Hour_With_M_State (C);
            when '.' =>
                return Point_Of_Second_State (C);
            when 's' | 'S' =>
                return Hour_With_S_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Int);
        end case;  
    end Int_State;


    function Identifier_State (In_Character : Character) return Token is
        C : Character;
    begin
        Standard_String.Append (In_Character, To => The_String);
        C := Get_Next_Character (The_File);
        case C is
            when 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' =>
                return Identifier_State (C);
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Id);
        end case;  
    end Identifier_State;


    function Start return Token is
        C : Character;
    begin
        Standard_String.Clear (The_String);
        C := Get_Next_Character (The_File);
        case C is
            when Ascii.Eot =>
                return Token'(Eof);
            when ' ' | Ascii.Cr =>
                return Start;
            when '0' .. '9' =>
                return Int_State (C);
            when '#' =>
                return Start_Of_Based_State (C);
            when 'a' .. 'z' | 'A' .. 'Z' =>
                return Identifier_State (C);
            when '/' =>
                return Start_Comment_State;  
            when '{' =>
                return Token'('{');  
            when '}' =>
                return Token'('}');  
            when '(' =>
                return Token'('(');  
            when ')' =>
                return Token'(')');  
            when '*' =>
                return Token'('{');  
            when '+' =>
                return Token'('+');
            when '-' =>
                return Token'('-');
            when '=' =>
                return Token'(Eq);
            when ':' =>
                return Double_Point_State;
            when '<' =>
                return Less_State;
            when '>' =>
                return Greater_State;
            when others =>
                Look_Ahead.Set (To => C);
                return Token'(Unk);
        end case;  
    end Start;

end Automate;

E3 Meta Data

    nblk1=11
    nid=a
    hdr6=18
        [0x00] rec0=2c rec1=00 rec2=01 rec3=03c
        [0x01] rec0=28 rec1=00 rec2=11 rec3=04a
        [0x02] rec0=25 rec1=00 rec2=0e rec3=00e
        [0x03] rec0=1f rec1=00 rec2=06 rec3=03a
        [0x04] rec0=22 rec1=00 rec2=0c rec3=080
        [0x05] rec0=21 rec1=00 rec2=04 rec3=016
        [0x06] rec0=00 rec1=00 rec2=08 rec3=03c
        [0x07] rec0=22 rec1=00 rec2=05 rec3=004
        [0x08] rec0=1d rec1=00 rec2=03 rec3=052
        [0x09] rec0=21 rec1=00 rec2=0b rec3=022
        [0x0a] rec0=1d rec1=00 rec2=0d rec3=03a
        [0x0b] rec0=1e rec1=00 rec2=09 rec3=000
        [0x0c] rec0=12 rec1=00 rec2=06 rec3=000
        [0x0d] rec0=08 rec1=00 rec2=0c rec3=000
        [0x0e] rec0=00 rec1=00 rec2=00 rec3=019
        [0x0f] rec0=00 rec1=00 rec2=00 rec3=000
        [0x10] rec0=00 rec1=00 rec2=00 rec3=000
    tail 0x21727839084857dec9756 0x42a00088462060003
Free Block Chain:
  0xa: 0000  00 02 01 99 80 07 20 20 62 65 67 69 6e 07 00 40  ┆        begin  @┆
  0x2: 0000  00 0f 00 18 80 15 74 5f 43 68 61 72 61 63 74 65  ┆      t_Characte┆
  0xf: 0000  00 07 00 0b 80 08 20 20 20 20 20 20 20 43 08 09  ┆             C  ┆
  0x7: 0000  00 10 03 eb 80 09 20 54 6f 6b 65 6e 20 69 73 09  ┆       Token is ┆
  0x10: 0000  00 00 02 05 80 06 28 27 2b 27 29 3b 06 00 17 20  ┆      ('+');    ┆