Function init

execution/execute_binary.go:74–197

()

}

func init() {
	binaryExpressionExecutors[lexer.Plus] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.Add(right)
	})
	binaryExpressionExecutors[lexer.Dash] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.Subtract(right)
	})
	binaryExpressionExecutors[lexer.Star] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.Multiply(right)
	})
	binaryExpressionExecutors[lexer.Slash] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.Divide(right)
	})
	binaryExpressionExecutors[lexer.Percent] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.Modulo(right)
	})
	binaryExpressionExecutors[lexer.GreaterThan] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.GreaterThan(right)
	})
	binaryExpressionExecutors[lexer.GreaterThanOrEqual] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.GreaterThanOrEqual(right)
	})
	binaryExpressionExecutors[lexer.LessThan] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.LessThan(right)
	})
	binaryExpressionExecutors[lexer.LessThanOrEqual] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.LessThanOrEqual(right)
	})
	binaryExpressionExecutors[lexer.Equal] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.Equal(right)
	})
	binaryExpressionExecutors[lexer.NotEqual] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		return left.NotEqual(right)
	})
	binaryExpressionExecutors[lexer.Equals] = func(ctx context.Context, expr ast.BinaryExpr, value *model.Value, options *Options) (*model.Value, error) {
		if leftVar, ok := expr.Left.(ast.VariableExpr); ok {
			// It is expected that the left side of an assignment may not exist yet.
			if _, ok := options.Vars[leftVar.Name]; !ok {
				options.Vars[leftVar.Name] = model.NewNullValue()
			}
		}
		return basicBinaryExpressionExecutorFn(executeAssign)(ctx, expr, value, options)
	}
	binaryExpressionExecutors[lexer.And] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		leftBool, err := left.BoolValue()
		if err != nil {
			return nil, fmt.Errorf("error getting left bool value: %w", err)
		}
		rightBool, err := right.BoolValue()
		if err != nil {
			return nil, fmt.Errorf("error getting right bool value: %w", err)
		}
		return model.NewBoolValue(leftBool && rightBool), nil
	})
	binaryExpressionExecutors[lexer.Or] = basicBinaryExpressionExecutorFn(func(ctx context.Context, left *model.Value, right *model.Value, _ ast.BinaryExpr) (*model.Value, error) {
		leftBool, err := left.BoolValue()
		if err != nil {
			return nil, fmt.Errorf("error getting left bool value: %w", err)