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

⟦42186c461⟧ Ada Source

    Length: 11264 (0x2c00)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Expression, seg_046869

Derivation

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

E3 Source Code



with Error, Expression_Simple, Liste_Mots_Voca, Dynamic_Value, Nom_Variable;

package body Expression is


    procedure Parse (Dyn_Node : in out Dynamic_Node.Object) is
        use Lexical_Analyzer;
        subtype Operateur_Compare is
           Lexical_Analyzer.Tokens range Less .. More_Equal;
        Inherited, Inherited1, Local_Node_Right : Dynamic_Node.Object;
        Dyn_Val_Default : Dynamic_Value.Object;
        Dyn_Node_Default, Dyn_Node_Complement1 : Dynamic_Node.Object;
    begin
        Expression_Simple.Parse (Inherited);

        if (Lexical_Analyzer.Get_Token in Operateur_Compare) then
            while (Lexical_Analyzer.Get_Token in Operateur_Compare) loop

                case Lexical_Analyzer.Get_Token is

                    when Less =>  
                        Dynamic_Node.Create_Binary_Operator
                           (Inherited1, Dynamic_Node.Less);
                        Lexical_Analyzer.Next;
                        Expression_Simple.Parse (Local_Node_Right);

                    when Less_Equal =>  
                        Dynamic_Node.Create_Binary_Operator
                           (Inherited1, Dynamic_Node.Less_Equal);
                        Lexical_Analyzer.Next;
                        Expression_Simple.Parse (Local_Node_Right);

                    when More =>
                        Dynamic_Node.Create_Binary_Operator
                           (Inherited1, Dynamic_Node.More);
                        Lexical_Analyzer.Next;
                        Expression_Simple.Parse (Local_Node_Right);

                    when More_Equal =>  
                        Dynamic_Node.Create_Binary_Operator
                           (Inherited1, Dynamic_Node.More_Equal);
                        Lexical_Analyzer.Next;
                        Expression_Simple.Parse (Local_Node_Right);

                    when Different =>
                        Dynamic_Node.Create_Binary_Operator
                           (Inherited1, Dynamic_Node.Different);
                        Lexical_Analyzer.Next;
                        Expression_Simple.Parse (Local_Node_Right);

                    when Equal =>
                        Dynamic_Node.Create_Binary_Operator
                           (Inherited1, Dynamic_Node.Equal);
                        Lexical_Analyzer.Next;
                        Expression_Simple.Parse (Local_Node_Right);

                    when others =>
                        null;
                end case;

                Dynamic_Node.Set_Argument
                   (Inherited1, Inherited, Dynamic_Node.Left);
                Dynamic_Node.Set_Argument
                   (Inherited1, Local_Node_Right, Dynamic_Node.Right);

                Inherited := Inherited1;
                Dynamic_Node.Disconnect (Inherited1);
                Dynamic_Node.Disconnect (Local_Node_Right);

            end loop;

        elsif Lexical_Analyzer.Get_Token = Dans then  
            if ((Dynamic_Node.Get_Operator (Inherited) /= "VERB") and
                (Dynamic_Node.Get_Operator (Inherited) /= "COMPLEMENT")) then
                Error.Set_Type_Error (Error.Word_Was_Expected);
                raise Error.Excep_Semantic_Error;
            end if;  
            Lexical_Analyzer.Next;
            Dynamic_Node.Create_Binary_Operator
               (Inherited1, Dynamic_Node.In_Set);
            Dynamic_Node.Set_Argument
               (Inherited1, Inherited, Dynamic_Node.Left);
            Nom_Variable.Parse (Local_Node_Right);
            Dynamic_Node.Set_Argument
               (Inherited1, Local_Node_Right, Dynamic_Node.Right);
            Inherited := Inherited1;
            Dynamic_Node.Disconnect (Inherited1);
            Dynamic_Node.Disconnect (Local_Node_Right);



        else  
            Liste_Mots_Voca.Parse (Inherited1);

            if Dynamic_Node.Does_Exists (Inherited1) then

                if Dynamic_Node.Get_Operator (Inherited) /= "VERB" then
                    Error.Set_Type_Error
                       (Error.Verb_Was_Expected_At_Beginning_Of_Expression);
                    raise Error.Excep_Semantic_Error;
                end if;
                Dynamic_Node.Set_Argument (Inherited1, Inherited,
                                           Dynamic_Node.Verb_Position);
                Inherited := Inherited1;

            else --soit il y a un verbe ou un complement venant de inherited
                 -- soit epsilon

                if Dynamic_Node.Get_Operator (Inherited) = "VERB" or
                   Dynamic_Node.Get_Operator (Inherited) = "COMPLEMENT" then

                    -- seul si 'aller' alors .. est autorise
                    if Dynamic_Node.Get_Operator (Inherited) /= "VERB" then
                        Error.Set_Type_Error
                           (Error.Verb_Was_Expected_At_Beginning_Of_Expression);
                        raise Error.Excep_Semantic_Error;
                    end if;

                    --create_ternary_default_operator car inherited1 n'existe pas
                    -- auquel on accroche le verb (inherited) et des complements null

                    Dynamic_Node.Create_Ternary_Operator
                       (Inherited1, Dynamic_Node.Sentence);

                    --creation d'un complement1 et 2 contenant la chaine null par defaut
                    Dynamic_Value.Set_Value (Dyn_Val_Default, "",
                                             Dynamic_Value.Voca_Value);
                    Dynamic_Node.Create_Value (Dyn_Node_Default);
                    Dynamic_Node.Set_Value (Dyn_Node_Default, Dyn_Val_Default);
                    Dynamic_Node.Create_Unary_Operator
                       (Dyn_Node_Complement1, Dynamic_Node.Complement);
                    Dynamic_Node.Set_Argument
                       (Dyn_Node_Complement1, Dyn_Node_Default);
                    Dynamic_Node.Set_Argument (Inherited1, Dyn_Node_Complement1,
                                               Dynamic_Node.Cplt1_Position);
                    Dynamic_Node.Set_Argument (Inherited1, Dyn_Node_Complement1,
                                               Dynamic_Node.Cplt2_Position);
                    Dynamic_Node.Disconnect (Dyn_Node_Complement1);

                    Dynamic_Node.Set_Argument (Inherited1, Inherited,
                                               Dynamic_Node.Verb_Position);
                    Inherited := Inherited1;
                end if;  
            end if;  
        end if;

        Dyn_Node := Inherited;

    exception  
        when Lexical_Analyzer.Excep_Eof =>
            Error.Set_Type_Error (Error.Unexpected_Eof);
            Error.Treat;
            raise Error.Excep_Syntaxe_Aborded;
    end Parse;



    function Is_First (Un_Token : Lexical_Analyzer.Tokens) return Boolean is  
        use Lexical_Analyzer;
    begin
        return ((Un_Token = Plus) or (Un_Token = Minus) or
                (Un_Token = Left_Bracket) or (Un_Token = Non) or
                (Un_Token = Integer_Number) or (Un_Token = Identifier) or
                (Un_Token = String_Of_Characters) or
                (Un_Token = Complement_Or_Verbe) or
                (Un_Token = Complement1) or (Un_Token = Complement2));  
    end Is_First;




end Expression;

E3 Meta Data

    nblk1=a
    nid=0
    hdr6=14
        [0x00] rec0=1a rec1=00 rec2=01 rec3=03a
        [0x01] rec0=00 rec1=00 rec2=02 rec3=01c
        [0x02] rec0=16 rec1=00 rec2=07 rec3=01c
        [0x03] rec0=19 rec1=00 rec2=0a rec3=04e
        [0x04] rec0=19 rec1=00 rec2=05 rec3=018
        [0x05] rec0=00 rec1=00 rec2=06 rec3=012
        [0x06] rec0=13 rec1=00 rec2=09 rec3=03e
        [0x07] rec0=12 rec1=00 rec2=08 rec3=036
        [0x08] rec0=1a rec1=00 rec2=03 rec3=008
        [0x09] rec0=0d rec1=00 rec2=04 rec3=000
    tail 0x215433ba486515becc432 0x42a00088462060003