In the previous articles, we described how we built the expression tree as we parsed a UCL expression. In this article, we will evaluate the tree and come up with a result from the expression.

function Get_Expression( var Err : integer ; var Context : string ) : string ;

var Root : tExpression_Node ;
    I : int64 ;
    _Err : integer ;

begin // Get_Expression
    Result := '' ;
    Err := 0 ;
    Context := '' ;
    Root := Parse_Expression( _Err, Context ) ; // Parse and validate the expression
    if( Root = nil ) then // Error
    begin
        exit ;
    end ;

    // Process expression tree...
    Result := Process( Root ) ;
    if( Valid_Int( Result, I ) ) then
    begin
        Result := inttostr( I ) ;
    end ;
end ; // Get_Expression

Before we examine the code for the Process function, we need to look at a couple of helper functions.

    function String_From_Boolean( B : boolean ) : string ;

    begin
        if( B ) then
        begin
            Result := '1' ;
        end else
        begin
            Result := '0' ;
        end ;
    end ;


    function Boolean_From_String( S : string ) : boolean ;

    begin
        Result := odd( Strtoint64( UCL_Strtoint( S ) ) ) ;
    end ;

    function Process( Current : tExpression_Node ) : string ;

    var L, R : string ;
        Ln, Rn : int64 ;
        Unary : boolean ;

    begin
        Result := '' ;
        if( Current = nil ) then
        begin
            exit ;
        end ;
        if( Current.Operator = 0 ) then // Terminal node on tree
        begin
            Result := Current.Value ;
            exit ;
        end ;

        Unary := Current.Left = nil ;
        if( Unary ) then // Unary operator
        begin
            L := '' ;
            if( Current.Right = nil ) then
            begin
                Err := UCL_EXPSYN ;
                exit ;
            end ;
        end else
        begin
            L := Process( Current.Left ) ;
            if( Err <> 0 ) then // Some error happened
            begin
                exit ;
            end ;
        end ;

        R := Process( Current.Right ) ;
        if( Err <> 0 ) then // Some error happened
        begin
            exit ;
        end ;
        Ln := strtoint64( UCL_Strtoint( L ) ) ;
        Rn := strtoint64( UCL_Strtoint( R ) ) ;

        case Current.Operator of
            Op_EQ : Result := String_From_Boolean( Ln = Rn ) ;
            Op_EQS : Result := String_From_Boolean( L = R ) ;
            Op_NE : Result := String_From_Boolean( Ln <> Rn ) ;
            Op_NES : Result := String_From_Boolean( L <> R ) ;
            Op_GE : Result := String_From_Boolean( Ln >= Rn ) ;
            Op_GES : Result := String_From_Boolean( L >= R ) ;
            Op_LE : Result := String_From_Boolean( Ln <= Rn ) ;
            Op_LES : Result := String_From_Boolean( L <= R ) ;
            Op_GT : Result := String_From_Boolean( Ln > Rn ) ;
            Op_GTS : Result := String_From_Boolean( L > R ) ;
            Op_LT : Result := String_From_Boolean( Ln < Rn ) ;
            Op_LTS : Result := String_From_Boolean( L < R ) ;
            Op_NOT : begin
                         if( not Unary ) then
                         begin
                             Err := UCL_EXPSYN ;
                             exit ;
                         end ;
                         Result := String_From_Boolean( Boolean_From_String( inttostr( not Rn ) ) ) ;
                     end ;
            Op_OR : Result := String_From_Boolean( Boolean_From_String( L ) or Boolean_From_String( R ) ) ;
            Op_AND : Result := String_From_Boolean( Boolean_From_String( L ) and Boolean_From_String( R ) ) ;
            Op_Multiply :
                begin
                    Result := inttostr( Ln * Rn ) ;
                end ;
            Op_Divide :
                begin
                    if( Rn = 0 ) then
                    begin
                        Result := '0' ;
                    end else
                    begin
                        Result := inttostr( Ln div Rn ) ;
                    end ;
                end ;
            Op_Add :
                begin
                    if( Unary ) then
                    begin
                        Result := R ; // Unary + (does nothing)
                    end else
                    begin
                        Result := inttostr( Ln + Rn ) ;
                    end ;
                end ;
            Op_Subtract :
                begin
                    if( Unary ) then
                    begin
                        Result := inttostr( -Rn ) ; // Unary minus
                    end else
                    begin
                        Result := inttostr( Ln - Rn ) ;
                    end ;
                end ;
        end ; // case Current.Operator
    end ; // Get_Expression.Process

To summarize, the function recursively calls itself to process the left and right subtrees, and then evaluate them according to the operator. When done, we will have a single value representing the evaluated expression, which we then return.

In the next several articles, we will be looking at the UCL lexical functions. We will start with a look at a new system call.