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

⟦09e553ff1⟧ Ada Source

    Length: 7168 (0x1c00)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Liste_Des_Antecedents, seg_04824a, seg_048c41, seg_048caf, seg_048de0

Derivation

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

E3 Source Code



with Antecedent;
with Lex;
with Follow;
with Synchro;
with Error;
with Traduction_Scenario;

package body Liste_Des_Antecedents is

    procedure Une_Autre_Expression_Conditionnelle
                 (Ok : out Boolean; Value : in out Condition.T_Condition) is
        use Lex;
        Correct : Boolean;
        Val : Condition.T_Condition;
    begin
        Correct := False;
        case Lex.Get_Token is
            when L_Non =>
                if not (Lex.Next_Token = L_Left_Bracket) then
                    Synchro.Is_On (Error.Antecedent, Follow.Antecedent);
                else
                    Lex.Next;
                    Parse (Correct, Val);
                    Value := Condition.Make_Node
                                (Op => Condition.Non, Neg_Node => Val);
                    if Correct then
                        if not (Lex.Get_Token = L_Right_Bracket) then
                            Synchro.Is_On (Error.Antecedent, Follow.Antecedent);
                        else
                            Correct := True;
                            Lex.Next;
                        end if;
                    end if;
                end if;

            when L_Left_Bracket =>
                Lex.Next;
                Parse (Correct, Val);
                Value := Val;
                if Correct then
                    if not (Lex.Get_Token = L_Right_Bracket) then
                        Synchro.Is_On (Error.Antecedent, Follow.Antecedent);
                    else
                        Correct := True;
                        Lex.Next;
                    end if;
                end if;

            when others =>
                Antecedent.Parse (Correct);
                Value := Condition.Make_Node
                            (The_Expression =>
                                Traduction_Scenario.Get_Condition);
                if not Correct then
                    Synchro.Is_On (Error.Antecedent, Follow.Antecedent);
                end if;
        end case;
        Ok := Correct;
    end Une_Autre_Expression_Conditionnelle;


    procedure Expression_Conditionnelle_Bis
                 (Ok : out Boolean; Value : in out Condition.T_Condition) is
        use Lex;
        Correct : Boolean;
        Val, Val1, Val2 : Condition.T_Condition;
    begin
        Correct := True;
        Val1 := Value;
        case Lex.Get_Token is

            when L_Et =>
                while (Correct and (Lex.Get_Token = L_Et)) loop
                    Lex.Next;
                    Une_Autre_Expression_Conditionnelle (Correct, Val2);
                    Val := Condition.Make_Node (Op => Condition.Et,
                                                Left_Node => Val1,
                                                Right_Node => Val2);
                    Val1 := Val;
                end loop;
                Value := Val;
            when others =>
                Correct := True;

        end case;
        Ok := Correct;
    end Expression_Conditionnelle_Bis;


    procedure Expression_Conditionnelle
                 (Ok : out Boolean; Value : in out Condition.T_Condition) is
        Correct : Boolean;
    begin
        Une_Autre_Expression_Conditionnelle (Correct, Value);
        if Correct then  
            Expression_Conditionnelle_Bis (Correct, Value);
        end if;
        Ok := Correct;
    end Expression_Conditionnelle;

    procedure Liste_Des_Antecedents_Bis
                 (Ok : out Boolean; Value : in out Condition.T_Condition) is
        use Lex;
        Correct : Boolean;
        Val, Val1, Val2 : Condition.T_Condition;

    begin
        Correct := True;
        Val1 := Value;

        case Lex.Get_Token is

            when L_Ou =>
                while (Correct and (Lex.Get_Token = L_Ou)) loop
                    Lex.Next;
                    Expression_Conditionnelle (Correct, Val2);
                    Val := Condition.Make_Node (Op => Condition.Ou,
                                                Left_Node => Val1,
                                                Right_Node => Val2);
                    Val1 := Val;
                end loop;
                Value := Val;
            when others =>
                Correct := True;

        end case;
        Ok := Correct;
    end Liste_Des_Antecedents_Bis;


    procedure Parse (Ok : out Boolean; Value : in out Condition.T_Condition) is
        Correct : Boolean;
    begin
        Expression_Conditionnelle (Correct, Value);
        if Correct then
            Liste_Des_Antecedents_Bis (Correct, Value);  
        end if;
        Ok := Correct;
    end Parse;

end Liste_Des_Antecedents;





E3 Meta Data

    nblk1=6
    nid=0
    hdr6=c
        [0x00] rec0=1d rec1=00 rec2=01 rec3=092
        [0x01] rec0=00 rec1=00 rec2=06 rec3=006
        [0x02] rec0=1b rec1=00 rec2=04 rec3=04a
        [0x03] rec0=1b rec1=00 rec2=05 rec3=034
        [0x04] rec0=22 rec1=00 rec2=02 rec3=04c
        [0x05] rec0=1f rec1=00 rec2=03 rec3=000
    tail 0x2174c3a2e86587a9192a5 0x42a00088462060003