mirror of
https://github.com/MaskRay/ccls.git
synced 2025-04-03 15:32:09 +00:00
854225bd30
Move using below #include to make preamble happy textDocument/references: if no references, first line or last line => list where this file is included malloc_trim() only if files have been indexed in last cycle Intern: use CachedHashStringRef
337 lines
11 KiB
C++
337 lines
11 KiB
C++
/* Copyright 2017-2018 ccls Authors
|
|
|
|
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
|
|
|
|
http://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.
|
|
==============================================================================*/
|
|
|
|
#pragma once
|
|
|
|
#include "maybe.h"
|
|
|
|
#include <llvm/Support/Compiler.h>
|
|
|
|
#include <macro_map.h>
|
|
|
|
#include <cassert>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
class CachedHashStringRef;
|
|
class StringRef;
|
|
}
|
|
|
|
enum class SerializeFormat { Binary, Json };
|
|
|
|
struct JsonNull {};
|
|
struct mandatory_optional_tag {};
|
|
|
|
class Reader {
|
|
public:
|
|
virtual ~Reader() {}
|
|
virtual SerializeFormat Format() const = 0;
|
|
|
|
virtual bool IsBool() = 0;
|
|
virtual bool IsNull() = 0;
|
|
virtual bool IsInt() = 0;
|
|
virtual bool IsInt64() = 0;
|
|
virtual bool IsUInt64() = 0;
|
|
virtual bool IsDouble() = 0;
|
|
virtual bool IsString() = 0;
|
|
|
|
virtual void GetNull() = 0;
|
|
virtual bool GetBool() = 0;
|
|
virtual uint8_t GetUInt8() = 0;
|
|
virtual int GetInt() = 0;
|
|
virtual uint32_t GetUInt32() = 0;
|
|
virtual int64_t GetInt64() = 0;
|
|
virtual uint64_t GetUInt64() = 0;
|
|
virtual double GetDouble() = 0;
|
|
virtual const char *GetString() = 0;
|
|
|
|
virtual bool HasMember(const char *x) = 0;
|
|
virtual std::unique_ptr<Reader> operator[](const char *x) = 0;
|
|
|
|
virtual void IterArray(std::function<void(Reader &)> fn) = 0;
|
|
virtual void Member(const char *name, std::function<void()> fn) = 0;
|
|
};
|
|
|
|
class Writer {
|
|
public:
|
|
virtual ~Writer() {}
|
|
virtual SerializeFormat Format() const = 0;
|
|
|
|
virtual void Null() = 0;
|
|
virtual void Bool(bool x) = 0;
|
|
virtual void Int(int x) = 0;
|
|
virtual void Int64(int64_t x) = 0;
|
|
virtual void UInt8(uint8_t x) = 0;
|
|
virtual void UInt32(uint32_t x) = 0;
|
|
virtual void UInt64(uint64_t x) = 0;
|
|
virtual void Double(double x) = 0;
|
|
virtual void String(const char *x) = 0;
|
|
virtual void String(const char *x, size_t len) = 0;
|
|
virtual void StartArray(size_t) = 0;
|
|
virtual void EndArray() = 0;
|
|
virtual void StartObject() = 0;
|
|
virtual void EndObject() = 0;
|
|
virtual void Key(const char *name) = 0;
|
|
};
|
|
|
|
struct IndexFile;
|
|
|
|
#define REFLECT_MEMBER_START() ReflectMemberStart(visitor)
|
|
#define REFLECT_MEMBER_END() ReflectMemberEnd(visitor);
|
|
#define REFLECT_MEMBER(name) ReflectMember(visitor, #name, value.name)
|
|
#define REFLECT_MEMBER_MANDATORY_OPTIONAL(name) \
|
|
ReflectMember(visitor, #name, value.name, mandatory_optional_tag{})
|
|
#define REFLECT_MEMBER2(name, value) ReflectMember(visitor, name, value)
|
|
|
|
#define MAKE_REFLECT_TYPE_PROXY(type_name) \
|
|
MAKE_REFLECT_TYPE_PROXY2(type_name, std::underlying_type_t<type_name>)
|
|
#define MAKE_REFLECT_TYPE_PROXY2(type, as_type) \
|
|
LLVM_ATTRIBUTE_UNUSED inline void Reflect(Reader &visitor, type &value) { \
|
|
as_type value0; \
|
|
::Reflect(visitor, value0); \
|
|
value = static_cast<type>(value0); \
|
|
} \
|
|
LLVM_ATTRIBUTE_UNUSED inline void Reflect(Writer &visitor, type &value) { \
|
|
auto value0 = static_cast<as_type>(value); \
|
|
::Reflect(visitor, value0); \
|
|
}
|
|
|
|
#define _MAPPABLE_REFLECT_MEMBER(name) REFLECT_MEMBER(name);
|
|
#define _MAPPABLE_REFLECT_MEMBER_MANDATORY_OPTIONAL(name) \
|
|
REFLECT_MEMBER_MANDATORY_OPTIONAL(name);
|
|
|
|
#define MAKE_REFLECT_EMPTY_STRUCT(type, ...) \
|
|
template <typename TVisitor> void Reflect(TVisitor &visitor, type &value) { \
|
|
REFLECT_MEMBER_START(); \
|
|
REFLECT_MEMBER_END(); \
|
|
}
|
|
|
|
#define MAKE_REFLECT_STRUCT(type, ...) \
|
|
template <typename TVisitor> void Reflect(TVisitor &visitor, type &value) { \
|
|
REFLECT_MEMBER_START(); \
|
|
MACRO_MAP(_MAPPABLE_REFLECT_MEMBER, __VA_ARGS__) \
|
|
REFLECT_MEMBER_END(); \
|
|
}
|
|
|
|
#define MAKE_REFLECT_STRUCT_MANDATORY_OPTIONAL(type, ...) \
|
|
template <typename TVisitor> void Reflect(TVisitor &visitor, type &value) { \
|
|
REFLECT_MEMBER_START(); \
|
|
MACRO_MAP(_MAPPABLE_REFLECT_MEMBER_MANDATORY_OPTIONAL, __VA_ARGS__) \
|
|
REFLECT_MEMBER_END(); \
|
|
}
|
|
|
|
// clang-format off
|
|
// Config has many fields, we need to support at least its number of fields.
|
|
#define NUM_VA_ARGS_IMPL(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,N,...) N
|
|
#define NUM_VA_ARGS(...) NUM_VA_ARGS_IMPL(__VA_ARGS__,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1)
|
|
// clang-format on
|
|
|
|
#define _MAPPABLE_REFLECT_ARRAY(name) Reflect(visitor, value.name);
|
|
|
|
// Reflects the struct so it is serialized as an array instead of an object.
|
|
// This currently only supports writers.
|
|
#define MAKE_REFLECT_STRUCT_WRITER_AS_ARRAY(type, ...) \
|
|
inline void Reflect(Writer &visitor, type &value) { \
|
|
visitor.StartArray(NUM_VA_ARGS(__VA_ARGS__)); \
|
|
MACRO_MAP(_MAPPABLE_REFLECT_ARRAY, __VA_ARGS__) \
|
|
visitor.EndArray(); \
|
|
}
|
|
|
|
//// Elementary types
|
|
|
|
void Reflect(Reader &visitor, uint8_t &value);
|
|
void Reflect(Writer &visitor, uint8_t &value);
|
|
|
|
void Reflect(Reader &visitor, short &value);
|
|
void Reflect(Writer &visitor, short &value);
|
|
|
|
void Reflect(Reader &visitor, unsigned short &value);
|
|
void Reflect(Writer &visitor, unsigned short &value);
|
|
|
|
void Reflect(Reader &visitor, int &value);
|
|
void Reflect(Writer &visitor, int &value);
|
|
|
|
void Reflect(Reader &visitor, unsigned &value);
|
|
void Reflect(Writer &visitor, unsigned &value);
|
|
|
|
void Reflect(Reader &visitor, long &value);
|
|
void Reflect(Writer &visitor, long &value);
|
|
|
|
void Reflect(Reader &visitor, unsigned long &value);
|
|
void Reflect(Writer &visitor, unsigned long &value);
|
|
|
|
void Reflect(Reader &visitor, long long &value);
|
|
void Reflect(Writer &visitor, long long &value);
|
|
|
|
void Reflect(Reader &visitor, unsigned long long &value);
|
|
void Reflect(Writer &visitor, unsigned long long &value);
|
|
|
|
void Reflect(Reader &visitor, double &value);
|
|
void Reflect(Writer &visitor, double &value);
|
|
|
|
void Reflect(Reader &visitor, bool &value);
|
|
void Reflect(Writer &visitor, bool &value);
|
|
|
|
void Reflect(Reader &visitor, std::string &value);
|
|
void Reflect(Writer &visitor, std::string &value);
|
|
|
|
void Reflect(Reader &visitor, std::string_view &view);
|
|
void Reflect(Writer &visitor, std::string_view &view);
|
|
|
|
void Reflect(Reader &vis, const char *&v);
|
|
void Reflect(Writer &vis, const char *&v);
|
|
|
|
void Reflect(Reader &visitor, JsonNull &value);
|
|
void Reflect(Writer &visitor, JsonNull &value);
|
|
|
|
void Reflect(Reader &visitor, SerializeFormat &value);
|
|
void Reflect(Writer &visitor, SerializeFormat &value);
|
|
|
|
//// Type constructors
|
|
|
|
// ReflectMember std::optional<T> is used to represent TypeScript optional
|
|
// properties (in `key: value` context). Reflect std::optional<T> is used for a
|
|
// different purpose, whether an object is nullable (possibly in `value`
|
|
// context).
|
|
template <typename T> void Reflect(Reader &visitor, std::optional<T> &value) {
|
|
if (visitor.IsNull()) {
|
|
visitor.GetNull();
|
|
return;
|
|
}
|
|
T real_value;
|
|
Reflect(visitor, real_value);
|
|
value = std::move(real_value);
|
|
}
|
|
template <typename T> void Reflect(Writer &visitor, std::optional<T> &value) {
|
|
if (value) {
|
|
if (visitor.Format() != SerializeFormat::Json)
|
|
visitor.UInt8(1);
|
|
Reflect(visitor, *value);
|
|
} else
|
|
visitor.Null();
|
|
}
|
|
|
|
// The same as std::optional
|
|
template <typename T> void Reflect(Reader &visitor, Maybe<T> &value) {
|
|
if (visitor.IsNull()) {
|
|
visitor.GetNull();
|
|
return;
|
|
}
|
|
T real_value;
|
|
Reflect(visitor, real_value);
|
|
value = std::move(real_value);
|
|
}
|
|
template <typename T> void Reflect(Writer &visitor, Maybe<T> &value) {
|
|
if (value) {
|
|
if (visitor.Format() != SerializeFormat::Json)
|
|
visitor.UInt8(1);
|
|
Reflect(visitor, *value);
|
|
} else
|
|
visitor.Null();
|
|
}
|
|
|
|
template <typename T>
|
|
void ReflectMember(Writer &visitor, const char *name, std::optional<T> &value) {
|
|
// For TypeScript std::optional property key?: value in the spec,
|
|
// We omit both key and value if value is std::nullopt (null) for JsonWriter
|
|
// to reduce output. But keep it for other serialization formats.
|
|
if (value || visitor.Format() != SerializeFormat::Json) {
|
|
visitor.Key(name);
|
|
Reflect(visitor, value);
|
|
}
|
|
}
|
|
|
|
// The same as std::optional
|
|
template <typename T>
|
|
void ReflectMember(Writer &visitor, const char *name, Maybe<T> &value) {
|
|
if (value.Valid() || visitor.Format() != SerializeFormat::Json) {
|
|
visitor.Key(name);
|
|
Reflect(visitor, value);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void ReflectMember(Writer &visitor, const char *name, T &value,
|
|
mandatory_optional_tag) {
|
|
visitor.Key(name);
|
|
Reflect(visitor, value);
|
|
}
|
|
|
|
template <typename L, typename R>
|
|
void Reflect(Reader &vis, std::pair<L, R> &v) {
|
|
vis.Member("L", [&]() { Reflect(vis, v.first); });
|
|
vis.Member("R", [&]() { Reflect(vis, v.second); });
|
|
}
|
|
template <typename L, typename R>
|
|
void Reflect(Writer &vis, std::pair<L, R> &v) {
|
|
vis.StartObject();
|
|
ReflectMember(vis, "L", v.first);
|
|
ReflectMember(vis, "R", v.second);
|
|
vis.EndObject();
|
|
}
|
|
|
|
// std::vector
|
|
template <typename T> void Reflect(Reader &visitor, std::vector<T> &values) {
|
|
visitor.IterArray([&](Reader &entry) {
|
|
T entry_value;
|
|
Reflect(entry, entry_value);
|
|
values.push_back(std::move(entry_value));
|
|
});
|
|
}
|
|
template <typename T> void Reflect(Writer &visitor, std::vector<T> &values) {
|
|
visitor.StartArray(values.size());
|
|
for (auto &value : values)
|
|
Reflect(visitor, value);
|
|
visitor.EndArray();
|
|
}
|
|
|
|
// ReflectMember
|
|
|
|
inline bool ReflectMemberStart(Reader &vis) { return false; }
|
|
inline bool ReflectMemberStart(Writer &vis) {
|
|
vis.StartObject();
|
|
return true;
|
|
}
|
|
|
|
inline void ReflectMemberEnd(Reader &vis) {}
|
|
inline void ReflectMemberEnd(Writer &vis) { vis.EndObject(); }
|
|
|
|
template <typename T> void ReflectMember(Reader &vis, const char *name, T &v) {
|
|
vis.Member(name, [&]() { Reflect(vis, v); });
|
|
}
|
|
template <typename T> void ReflectMember(Writer &vis, const char *name, T &v) {
|
|
vis.Key(name);
|
|
Reflect(vis, v);
|
|
}
|
|
|
|
// API
|
|
|
|
namespace ccls {
|
|
const char *Intern(llvm::StringRef str);
|
|
llvm::CachedHashStringRef InternH(llvm::StringRef str);
|
|
std::string Serialize(SerializeFormat format, IndexFile &file);
|
|
std::unique_ptr<IndexFile>
|
|
Deserialize(SerializeFormat format, const std::string &path,
|
|
const std::string &serialized_index_content,
|
|
const std::string &file_content,
|
|
std::optional<int> expected_version);
|
|
} // namespace ccls
|