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

⟦fd5a06509⟧ Ada Source

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

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 Create_Null_Complement
                 (Dyn_Node_Complement : in out Dynamic_Node.Object) is
        Dyn_Val_Default : Dynamic_Value.Object;
        Dyn_Node_Default : Dynamic_Node.Object;
    begin
        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_Complement, Dynamic_Node.Complement);
        Dynamic_Node.Set_Argument (Dyn_Node_Complement, Dyn_Node_Default);  
    end Create_Null_Complement;


    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, Dyn_Node_Complement :
           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); -- epsilon peut etre parse

            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 -- liste mots voca a parse epsilon (= pas de complements)
                 -- inherited venant de expression_simple.parse doit donc etre un verbe
                 -- car seul une expression du type si 'aller' alors .. est autorisee

                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);
                    Create_Null_Complement (Dyn_Node_Complement);
                    Dynamic_Node.Set_Argument (Inherited1, Dyn_Node_Complement,
                                               Dynamic_Node.Cplt1_Position);
                    Dynamic_Node.Set_Argument (Inherited1, Dyn_Node_Complement,
                                               Dynamic_Node.Cplt2_Position);  
                    Dynamic_Node.Disconnect (Dyn_Node_Complement);

                    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=b
    nid=3
    hdr6=12
        [0x00] rec0=19 rec1=00 rec2=01 rec3=050
        [0x01] rec0=0e rec1=00 rec2=06 rec3=056
        [0x02] rec0=16 rec1=00 rec2=07 rec3=01c
        [0x03] rec0=19 rec1=00 rec2=0a rec3=04e
        [0x04] rec0=17 rec1=00 rec2=02 rec3=064
        [0x05] rec0=07 rec1=00 rec2=05 rec3=018
        [0x06] rec0=13 rec1=00 rec2=09 rec3=07e
        [0x07] rec0=14 rec1=00 rec2=04 rec3=01e
        [0x08] rec0=18 rec1=00 rec2=08 rec3=000
        [0x09] rec0=0d rec1=00 rec2=04 rec3=000
        [0x0a] rec0=23 rec1=47 rec2=50 rec3=000
    tail 0x21544f60e865778a7a7c1 0x42a00088462060003
Free Block Chain:
  0x3: 0000  00 0b 00 04 80 01 79 01 65 64 31 2c 20 44 79 6e  ┆      y ed1, Dyn┆
  0xb: 0000  00 00 01 44 80 0f 6e 5f 56 61 6c 5f 44 65 66 61  ┆   D  n_Val_Defa┆