Class TExpression

FOptionalArguments: integer; FOptionalArguments is the number of optional arguments in the function that will be evaluated.

FunctionAddr: Pointer; FunctionAddr is the address of the function used to evaluate the TExpression.

VariablesForFunction: array of Pointer; VariablesForFunction is the argument passed to the function used to evaluate the TExpression.

FAllowConversionToConstant: boolean; See AllowConversionToConstant.

FTag: integer; See Tag

StringVariableIndicies: array of integer; StringVariableIndicies indicates which members of VariablesForFunction refer to strings.

StringVariableCount: integer; StringVariableCount is the number of strings in VariablesForFunction.

FVariablesUsed: TStringList; FVariablesUsed is used to hold the result of VariablesUsed.

FTopLevel: boolean; FTopLevel is used in Decompile to determine whether or not to include parenthesis around the outermost item.

ShouldEvaluate: boolean;

ShouldEvaluate is set to false if a TExpression is equivalent to a TConstant. In such cases, the TExpression is evaluated when it is created and does not need to be reevaluated later. An example would be if the expression used to create the TExpression was "1 + 1". This would be converted to "2".

Data: array of TVariables; Data holds the arguments used to evaluate the TExpression.

Create a TExpression.

Create a TExpression.

Create a TExpression.

Initializes certain variables. Called by Create.

See Variables.

See Variables.

if the expression can be represented as a constant value, ConvertToConstant returns a TConstant that represents that value. Otherwise, it returns nil.

If optional arguments are used, ResetDataLength is used to resets the length of arrays to the correct length.

See AllowConversionToConstant.

FillVariables initializes VariablesForFunction and StringVariableIndicies

See VariablesUsed.

Create creates a TExpression based on a TFunctionClass. The values of any variables used by the TExpression must also be set before calling Evaluate.

Decompile converts the value stored in the TExpression to a string that can be compiled into an equivalent TExpression together with its arguments.

Destroy destroys the TExpression. Do not call Destroy directly. Call Free instead.

Evaluate evaluates the expression and sets the result which may then be read using BooleanResult, DoubleResult, IntegerResult, or StringResult depending on the ResultType.

Example:

      procedure TForm1.Button1Click(Sender: TObject);
      begin
        RbwParser1.Compile(Edit1.Text);
        RbwParser1.CurrentExpression.Evaluate;
        case RbwParser1.CurrentExpression.ResultType of
          rdtDouble:
            begin
              Label1.Caption := 'result: '
                + FloatToStr(RbwParser1.CurrentExpression.DoubleResult);
            end;
          rdtInteger:
            begin
              Label1.Caption := 'result: '
                + IntToStr(RbwParser1.CurrentExpression.IntegerResult);
            end;
          rdtBoolean:
            begin
              if RbwParser1.CurrentExpression.BooleanResult then
              begin
                Label1.Caption := 'result: ' + 'True';
              end
              else
              begin
                Label1.Caption := 'result: ' + 'False';
              end;
            end;
          rdtString:
            begin
              Label1.Caption := 'result: '
                + RbwParser1.CurrentExpression.StringResult;
            end;
        else Assert(False);
        end;
      end;
     

New usually calls Create to create a TExpression based on FunctionClass. However, in some cases, it creates a descendant of TExpression. Many of the descendents are declared in the implementation section of RBW_Parser.pas. Others can be generated via SpecialImplementorList. One such descendant is TSelectExpression which overrides Evaluate.

UsesVariable returns True if Variable is used by the TExpression.

AllowConversionToConstant defines whether the result of a function may be considered a constant value if all of the values passed to the function in the values array are constants.

Normally AllowConversionToConstant should be set to True but if the function makes reference to global variables that may change between one evaluation of the expression and the next, AllowConversionToConstant should be set to False.

Pi is an example of a function for which AllowConversionToConstant should be true.

AllowConversionToConstant is used when optimizing compiled expressions.

Variables define the data passed to the function when Evaluate is called. Any descendant of TConstant may be assigned to Variables.

Tag has no predefined meaning. The Tag property is provided for the convenience of developers. It can be used for storing an additional integer value or it can be typecast to any 32-bit value such as a component reference or a pointer.

VariablesUsed is a list of all the variables used by the TExpression.