| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #pragma once |
| |
| #include "lib/fxl/memory/ref_ptr.h" |
| |
| namespace zxdb { |
| |
| class Err; |
| class ExprValue; |
| class Type; |
| class ExprValueSource; |
| |
| enum class CastType { |
| kImplicit, // Things like double d = (float)f; |
| kC, // C-style cast: (int)foo; |
| kReinterpret, |
| kStatic |
| // We don't bother implementing const_cast and dynamic_cast yet because |
| // they're less useful in a debugger. |
| }; |
| |
| const char* CastTypeToString(CastType); |
| |
| // TODO(brettw) replace the other cast calls with calls to this one: |
| Err CastExprValue(CastType cast_type, const ExprValue& source, |
| const fxl::RefPtr<Type>& dest_type, ExprValue* result); |
| |
| // Attempts to convert the "source" value to the given type. This attempts |
| // to be as permissive as possible. In a debugger context, people want to be |
| // able to make arbitrary binary assignments without being told to do an |
| // explicit cast. |
| // |
| // Any number can be converted to any other number, even if the sign is |
| // different, it is truncated, or there is a float/integer mismatch. Pointers |
| // can be converted back-and-forth to integers as long as the sizes match. |
| // Composite types can be copied if the type *names* and sizes match (the |
| // type objects don't necessarily need to point to the same thing). |
| // |
| // This does not implement static-cast-like conversions of derived classes |
| // where the cast involves adjusting the value of the pointer. |
| // |
| // The dest_source will be set as the "source" of the result ExprValue. When |
| // generating temporaries, this should be a default-constructed |
| // ExprValueSource, but this is useful when doing implicit casts for assignment |
| // where the destination location is given. |
| // |
| // TODO(brettw) this should be renamed "ImplicitCast". |
| Err CoerceValueTo(const ExprValue& source, const fxl::RefPtr<Type>& dest_type, |
| const ExprValueSource& dest_source, ExprValue* result); |
| |
| // Executes a C++-style reinterpret_cast. The first version takes a known type |
| // to convert to, while the second attempts to find the correct type that |
| // matches the string. |
| // |
| // The source type should not be a reference type since this function is |
| // synchronous and will not follow references to get the referenced value. |
| // Calling code should use ExprNode::EvalFollowReferences() to compute the |
| // value or have called EnsureResolveReference(). |
| // |
| // This implementation is more lax than C++, allowing any conversion that can |
| // be reasonable executed. C++ will, for example, prohibit conversion of a |
| // 32-bit integer to a 64-bit pointer, but if the user types |
| // "reinterpret_cast<char*>(0x12343567)" we want the debugger to be able to |
| // execute. |
| Err ReinterpretCast(const ExprValue& source, const fxl::RefPtr<Type>& dest_type, |
| ExprValue* result); |
| Err ReinterpretCast(const ExprValue& source, const std::string& dest_type, |
| ExprValue* result); |
| |
| } // namespace zxdb |