================ @@ -0,0 +1,459 @@ +//===-- DILAST.h ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_CORE_DILAST_H +#define LLDB_CORE_DILAST_H + +#include <memory> +#include <optional> +#include <string> +#include <variant> +#include <vector> + +#include "lldb/Core/ValueObject.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/TypeList.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/Utility/ConstString.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/TokenKinds.h" +#include "llvm/ADT/APFloat.h" +#include "llvm/ADT/APInt.h" +#include "llvm/Support/Casting.h" + +namespace lldb_private { + +namespace DIL { + +/// Struct to hold information about member fields. Used by the parser for the +/// Data Inspection Language (DIL). +struct MemberInfo { + std::optional<std::string> name; + CompilerType type; + std::optional<uint32_t> bitfield_size_in_bits; + bool is_synthetic; + bool is_dynamic; + lldb::ValueObjectSP val_obj_sp; +}; + +/// Get the appropriate ValueObjectSP, consulting the use_dynamic and +/// use_synthetic options passed, acquiring the process & target locks if +/// appropriate. +lldb::ValueObjectSP GetDynamicOrSyntheticValue( + lldb::ValueObjectSP valobj_sp, + lldb::DynamicValueType use_dynamic = lldb::eNoDynamicValues, + bool use_synthetic = false); + +/// The various types DIL AST nodes (used by the DIL parser). +enum class NodeKind { + eErrorNode, + eScalarLiteralNode, + eStringLiteralNode, + eIdentifierNode, + eCStyleCastNode, + eMemberOfNode, + eArraySubscriptNode, + eUnaryOpNode, + eSmartPtrToPtrDecayNode +}; + +/// The C-Style casts for type promotion allowed by DIL. +enum class TypePromotionCastKind { + eArithmetic, + ePointer, +}; + +/// The Unary operators recognized by DIL. +enum class UnaryOpKind { + AddrOf, // "&" + Deref, // "*" + Minus, // "-" +}; + +/// Given a string representing a type, returns the CompilerType corresponding +/// to the named type, if it exists. +CompilerType +ResolveTypeByName(const std::string &name, + std::shared_ptr<ExecutionContextScope> ctx_scope); + +/// Class used to store & manipulate information about identifiers. +class IdentifierInfo { +private: + using MemberPath = std::vector<uint32_t>; + using IdentifierInfoUP = std::unique_ptr<IdentifierInfo>; + +public: + enum class Kind { + eValue, + eContextArg, + eMemberPath, + eThisKeyword, + }; + + static IdentifierInfoUP FromValue(lldb::ValueObjectSP value_sp) { ---------------- cmtice wrote:
I went back and looked at this a little closer; when the user requests a nonexistent variable name (makes a mistake), this function can be passed an empty ValueObjectSP; the parser checks to see if the IdentifierInfo object that gets returned passes the IsValid check, and that's when the parser either continues parsing or tells the user they've made an invalid request. So no, I can't really change the parameter here on the assumption that the function always gets a valid object. https://github.com/llvm/llvm-project/pull/95738 _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
