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

⟦1faf09389⟧ Ada Source

    Length: 12288 (0x3000)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Scanner, seg_031701

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



-- table des symboles

with Text_Io;
with Fichier_Io;
with Bounded_String;
with Reserved_Word;

package body Scanner is
    procedure Open (Fichier_Source : in out Text_Io.File_Type) is
    begin  
        Fichier_Io.Open (Fichier_Source);
    end Open;

    procedure Close (Fichier_Source : in out Text_Io.File_Type) is
    begin
        Fichier_Io.Close (Fichier_Source);
    end Close;

    function At_End (Fichier_Source : in Text_Io.File_Type) return Boolean is
    begin
        return Fichier_Io.At_End (Fichier_Source);
    end At_End;

    function At_Line (Fichier_Source : in Text_Io.File_Type) return Boolean is
    begin
        return Fichier_Io.At_Line (Fichier_Source);
    end At_Line;

    procedure Next (Fichier_Source : in Text_Io.File_Type) is
        C : Character;
        State : Etat;

    begin  
        Bounded_String.Free (Current_Value);
        if At_End (Fichier_Source) then
            Current_Token := Token'(Eof);
        else
            State := Etat'(Normal);
            loop
                if At_End (Fichier_Source) then
                    C := Ascii.Eot;
                else
                    C := Fichier_Io.Get (Fichier_Source);
                end if;

                case State is
                    when Normal =>
                        case C is
                            when Ascii.Eot =>
                                Current_Token := Token'(Eof);
                                State := Etat'(Found);

                            when ' ' | Ascii.Cr | Ascii.Ht =>
                                null;

                            when '<' =>
                                Bounded_String.Append (Current_Value, C);
                                Current_Token := Token'(Less);
                                State := Etat'(Less);

                            when '>' =>
                                Bounded_String.Append (Current_Value, C);
                                Current_Token := Token'(Great);
                                State := Etat'(Great);

                            when '=' =>
                                Bounded_String.Append (Current_Value, C);
                                Current_Token := Token'(Equal);
                                State := Etat'(Found);

                            when '{' | '}' | '(' | ')' | '.' =>
                                Bounded_String.Append (Current_Value, C);
                                Current_Token := Token'(Special);
                                State := Etat'(Found);

                            when '+' | '-' | '*' | '/' =>
                                Bounded_String.Append (Current_Value, C);
                                Current_Token := Token'(Operator);
                                State := Etat'(Found);

                            when '"' =>
                                Bounded_String.Append (Current_Value, C);
                                State := Etat'(Word);

                            when others =>
                                if C in 'a' .. 'z' or else C in 'A' .. 'Z' then  
                                    Bounded_String.Append (Current_Value, C);
                                    State := Etat'(Identifier);
                                elsif C in '0' .. '9' then
                                    Bounded_String.Append (Current_Value, C);
                                    State := Etat'(Number);
                                else
                                    Bounded_String.Append (Current_Value, C);
                                    Current_Token := Token'(Unknown);
                                    State := Etat'(Found);
                                end if;

                        end case;

                    when Number =>
                        if C in '0' .. '9' then
                            Bounded_String.Append (Current_Value, C);
                        else
                            Fichier_Io.Unget (Fichier_Source);
                            Current_Token := Token'(Integer);
                            State := Etat'(Found);
                        end if;

                    when Identifier =>
                        if C in 'a' .. 'z' or else C in 'A' .. 'Z' then
                            Bounded_String.Append (Current_Value, C);
                        elsif C = ':' then
                            Current_Token := Token'(Keyword);
                            State := Etat'(Found);  
                        else
                            Fichier_Io.Unget (Fichier_Source);
                            Current_Token := Token'(Identifier);
                            Current_Token := Reserved_Word.Reserved_To_Token
                                                (Bounded_String.Image
                                                    (Current_Value));
                            State := Etat'(Found);
                        end if;

                    when Word =>
                        Bounded_String.Append (Current_Value, C);
                        if C /= '"' then
                            Current_Token := Token'(Word);
                        else
                            State := Etat'(Found_Word);
                        end if;

                    when Found_Word =>
                        if C /= '"' then
                            Current_Token := Token'(Word);
                            State := Etat'(Found);
                            Fichier_Io.Unget (Fichier_Source);
                        else
                            Current_Token := Token'(Word);
                            State := Etat'(Word);
                        end if;

                    when Great =>
                        if C = '=' then
                            Bounded_String.Append (Current_Value, C);
                            Current_Token := Token'(Great_Equal);
                        else
                            Fichier_Io.Unget (Fichier_Source);
                            State := Etat'(Found);
                        end if;

                    when Less =>
                        if C = '=' then
                            Bounded_String.Append (Current_Value, C);
                            Current_Token := Token'(Less_Equal);
                        else
                            Fichier_Io.Unget (Fichier_Source);
                            State := Etat'(Found);
                        end if;

                    when Found =>
                        null;
                end case;
                exit when (State = Found);
            end loop;
        end if;
    end Next;

    function Get_Value (Fichier_Source : in Text_Io.File_Type)
                       return Bounded_String.Variable_String is
    begin
        return Scanner.Current_Value;
    end Get_Value;

    function Get_Token (Fichier_Source : in Text_Io.File_Type) return Token is
    begin
        Next (Fichier_Source);
        return Scanner.Current_Token;
    end Get_Token;

end Scanner;


E3 Meta Data

    nblk1=b
    nid=2
    hdr6=12
        [0x00] rec0=24 rec1=00 rec2=01 rec3=036
        [0x01] rec0=1b rec1=00 rec2=06 rec3=024
        [0x02] rec0=04 rec1=00 rec2=08 rec3=022
        [0x03] rec0=14 rec1=00 rec2=03 rec3=042
        [0x04] rec0=13 rec1=00 rec2=09 rec3=034
        [0x05] rec0=0c rec1=00 rec2=0b rec3=004
        [0x06] rec0=15 rec1=00 rec2=05 rec3=018
        [0x07] rec0=18 rec1=00 rec2=0a rec3=00a
        [0x08] rec0=14 rec1=00 rec2=04 rec3=000
        [0x09] rec0=14 rec1=00 rec2=04 rec3=001
        [0x0a] rec0=72 rec1=31 rec2=c0 rec3=000
    tail 0x2172b830884bd57b94f75 0x42a00088462060003
Free Block Chain:
  0x2: 0000  00 07 00 53 80 0a 20 20 20 20 20 20 65 6c 73 65  ┆   S        else┆
  0x7: 0000  00 00 00 06 00 00 00 00 00 00 20 20 20 20 20 20  ┆                ┆