Class TExpression

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

FunctionAddr is the address of the function used to evaluate the TExpression.

VariablesForFunction is the argument passed to the function used to evaluate the TExpression.

See AllowConversionToConstant.

See Tag

StringVariableIndicies indicates which members of VariablesForFunction refer to strings.

StringVariableCount is the number of strings in VariablesForFunction.

FVariablesUsed is used to hold the result of VariablesUsed.

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

FPrototype is the prototype of the base TExpression without any hints about where it belongs in a hierarchy. FPrototype is used in MakeDiagram.

See also

Prototype

Prototype should give the names and arguments for a function as they should be shown on a GUI interface.

FNotifier is used to provide notification to components that used an instance of FNotifier when the instance is destroyed.

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.

MakeDiagram fills List with a diagram of itself. First, it adds a new line to List. The new line begins with Level number of tab characters. This is followed by its own name followed by another tab character and then Decompile. Finally it calls MakeDiagram for each of its children passing on List and Level+1.

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 TRbwParser.SpecialImplementorList. One such descendant is TSelectExpression which overrides Evaluate.

UsesVariable returns True if Variable is used by the TExpression.

Diagram fills List with a diagram of itself. Each line begins with N tab characters. The number of tab characters indicates the position of that line in a hierarchy of child TCustomValues. Next the line has the name of the TCustomValue, another tab character and then a Decompiled version of the TCustomValue.

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. The Objects properties holds the variables themselves. The TStringList is owned by the TExpression.

VariablesUsed is sorted, ignores duplicates, and is not case-sensitive;

Notifier is used to provide notification to components that used an instance of Notifier when the instance is destroyed.