| // Copyright 2020 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #include "utils/grammar/semantics/evaluators/arithmetic-eval.h" |
| |
| #include <limits> |
| |
| namespace libtextclassifier3::grammar { |
| namespace { |
| |
| template <typename T> |
| StatusOr<const SemanticValue*> Reduce( |
| const SemanticExpressionEvaluator* composer, const EvalContext& context, |
| const ArithmeticExpression* expression, UnsafeArena* arena) { |
| T result; |
| switch (expression->op()) { |
| case ArithmeticExpression_::Operator_OP_ADD: { |
| result = 0; |
| break; |
| } |
| case ArithmeticExpression_::Operator_OP_MUL: { |
| result = 1; |
| break; |
| } |
| case ArithmeticExpression_::Operator_OP_MIN: { |
| result = std::numeric_limits<T>::max(); |
| break; |
| } |
| case ArithmeticExpression_::Operator_OP_MAX: { |
| result = std::numeric_limits<T>::min(); |
| break; |
| } |
| default: { |
| return Status(StatusCode::INVALID_ARGUMENT, |
| "Unexpected op: " + |
| std::string(ArithmeticExpression_::EnumNameOperator( |
| expression->op()))); |
| } |
| } |
| if (expression->values() != nullptr) { |
| for (const SemanticExpression* semantic_expression : |
| *expression->values()) { |
| TC3_ASSIGN_OR_RETURN( |
| const SemanticValue* value, |
| composer->Apply(context, semantic_expression, arena)); |
| if (value == nullptr) { |
| continue; |
| } |
| if (!value->Has<T>()) { |
| return Status( |
| StatusCode::INVALID_ARGUMENT, |
| "Argument didn't evaluate as expected type: " + |
| std::string(reflection::EnumNameBaseType(value->base_type()))); |
| } |
| const T scalar_value = value->Value<T>(); |
| switch (expression->op()) { |
| case ArithmeticExpression_::Operator_OP_ADD: { |
| result += scalar_value; |
| break; |
| } |
| case ArithmeticExpression_::Operator_OP_MUL: { |
| result *= scalar_value; |
| break; |
| } |
| case ArithmeticExpression_::Operator_OP_MIN: { |
| result = std::min(result, scalar_value); |
| break; |
| } |
| case ArithmeticExpression_::Operator_OP_MAX: { |
| result = std::max(result, scalar_value); |
| break; |
| } |
| default: { |
| break; |
| } |
| } |
| } |
| } |
| return SemanticValue::Create(result, arena); |
| } |
| |
| } // namespace |
| |
| StatusOr<const SemanticValue*> ArithmeticExpressionEvaluator::Apply( |
| const EvalContext& context, const SemanticExpression* expression, |
| UnsafeArena* arena) const { |
| TC3_DCHECK_EQ(expression->expression_type(), |
| SemanticExpression_::Expression_ArithmeticExpression); |
| const ArithmeticExpression* arithmetic_expression = |
| expression->expression_as_ArithmeticExpression(); |
| switch (arithmetic_expression->base_type()) { |
| case reflection::BaseType::Byte: |
| return Reduce<int8>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::UByte: |
| return Reduce<uint8>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::Short: |
| return Reduce<int16>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::UShort: |
| return Reduce<uint16>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::Int: |
| return Reduce<int32>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::UInt: |
| return Reduce<uint32>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::Long: |
| return Reduce<int64>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::ULong: |
| return Reduce<uint64>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::Float: |
| return Reduce<float>(composer_, context, arithmetic_expression, arena); |
| case reflection::BaseType::Double: |
| return Reduce<double>(composer_, context, arithmetic_expression, arena); |
| default: |
| return Status(StatusCode::INVALID_ARGUMENT, |
| "Unsupported for ArithmeticExpression: " + |
| std::string(reflection::EnumNameBaseType( |
| static_cast<reflection::BaseType>( |
| arithmetic_expression->base_type())))); |
| } |
| } |
| |
| } // namespace libtextclassifier3::grammar |