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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
| //===--- RIFF.h - Binary container file format -------------------*- 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
//
//===----------------------------------------------------------------------===//
//
// Tools for reading and writing data in RIFF containers.
//
// A chunk consists of:
// - ID : char[4]
// - Length : uint32
// - Data : byte[Length]
// - Padding : byte[Length % 2]
// The semantics of a chunk's Data are determined by its ID.
// The format makes it easy to skip over uninteresting or unknown chunks.
//
// A RIFF file is a single chunk with ID "RIFF". Its Data is:
// - Type : char[4]
// - Chunks : chunk[]
//
// This means that a RIFF file consists of:
// - "RIFF" : char[4]
// - File length - 8 : uint32
// - File type : char[4]
// - Chunks : chunk[]
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_RIFF_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_RIFF_H
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ScopedPrinter.h"
#include <array>
namespace clang {
namespace clangd {
namespace riff {
// A FourCC identifies a chunk in a file, or the type of file itself.
using FourCC = std::array<char, 4>;
// Get a FourCC from a string literal, e.g. fourCC("RIFF").
inline constexpr FourCC fourCC(const char (&Literal)[5]) {
return FourCC{{Literal[0], Literal[1], Literal[2], Literal[3]}};
}
// A chunk is a section in a RIFF container.
struct Chunk {
FourCC ID;
llvm::StringRef Data;
};
inline bool operator==(const Chunk &L, const Chunk &R) {
return std::tie(L.ID, L.Data) == std::tie(R.ID, R.Data);
}
// A File is a RIFF container, which is a typed chunk sequence.
struct File {
FourCC Type;
std::vector<Chunk> Chunks;
};
inline bool operator==(const File &L, const File &R) {
return std::tie(L.Type, L.Chunks) == std::tie(R.Type, R.Chunks);
}
// Reads a single chunk from the start of Stream.
// Stream is updated to exclude the consumed chunk.
llvm::Expected<Chunk> readChunk(llvm::StringRef &Stream);
// Serialize a single chunk to OS.
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Chunk &);
// Parses a RIFF file consisting of a single RIFF chunk.
llvm::Expected<File> readFile(llvm::StringRef Stream);
// Serialize a RIFF file (i.e. a single RIFF chunk) to OS.
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const File &);
} // namespace riff
} // namespace clangd
} // namespace clang
#endif
|