clang-tools 8.0.0

RIFF.h
Go to the documentation of this file.
1 //===--- RIFF.h - Binary container file format -------------------*- C++-*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Tools for reading and writing data in RIFF containers.
11 //
12 // A chunk consists of:
13 // - ID : char[4]
14 // - Length : uint32
15 // - Data : byte[Length]
16 // - Padding : byte[Length % 2]
17 // The semantics of a chunk's Data are determined by its ID.
18 // The format makes it easy to skip over uninteresting or unknown chunks.
19 //
20 // A RIFF file is a single chunk with ID "RIFF". Its Data is:
21 // - Type : char[4]
22 // - Chunks : chunk[]
23 //
24 // This means that a RIFF file consists of:
25 // - "RIFF" : char[4]
26 // - File length - 8 : uint32
27 // - File type : char[4]
28 // - Chunks : chunk[]
29 //
30 //===----------------------------------------------------------------------===//
31 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_RIFF_H
32 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_RIFF_H
33 #include "llvm/ADT/StringRef.h"
34 #include "llvm/Support/Error.h"
35 #include "llvm/Support/ScopedPrinter.h"
36 #include <array>
37
38 namespace clang {
39 namespace clangd {
40 namespace riff {
41
42 // A FourCC identifies a chunk in a file, or the type of file itself.
43 using FourCC = std::array<char, 4>;
44 // Get a FourCC from a string literal, e.g. fourCC("RIFF").
45 inline constexpr FourCC fourCC(const char (&Literal)[5]) {
46 return FourCC{{Literal[0], Literal[1], Literal[2], Literal[3]}};
47 }
48 // A chunk is a section in a RIFF container.
49 struct Chunk {
50 FourCC ID;
51 llvm::StringRef Data;
52 };
53 inline bool operator==(const Chunk &L, const Chunk &R) {
54 return std::tie(L.ID, L.Data) == std::tie(R.ID, R.Data);
55 }
56 // A File is a RIFF container, which is a typed chunk sequence.
57 struct File {
58 FourCC Type;
59 std::vector<Chunk> Chunks;
60 };
61 inline bool operator==(const File &L, const File &R) {
62 return std::tie(L.Type, L.Chunks) == std::tie(R.Type, R.Chunks);
63 }
64
65 // Reads a single chunk from the start of Stream.
66 // Stream is updated to exclude the consumed chunk.
67 llvm::Expected<Chunk> readChunk(llvm::StringRef &Stream);
68
69 // Serialize a single chunk to OS.
70 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Chunk &);
71
72 // Parses a RIFF file consisting of a single RIFF chunk.
73 llvm::Expected<File> readFile(llvm::StringRef Stream);
74
75 // Serialize a RIFF file (i.e. a single RIFF chunk) to OS.
76 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const File &);
77
78 } // namespace riff
79 } // namespace clangd
80 } // namespace clang
81 #endif
clang::clangd::riff::Chunk::Data
llvm::StringRef Data
Definition: RIFF.h:51
clang::clangd::riff::Chunk::ID
FourCC ID
Definition: RIFF.h:50
clang::clangd::riff::fourCC
constexpr FourCC fourCC(const char(&Literal)[5])
Definition: RIFF.h:45
clang::clangd::riff::readFile
llvm::Expected< File > readFile(llvm::StringRef Stream)
Definition: RIFF.cpp:52
clang::clangd::riff::File::Chunks
std::vector< Chunk > Chunks
Definition: RIFF.h:59
clang::clangd::riff::File::Type
FourCC Type
Definition: RIFF.h:58
clang::clangd::riff::FourCC
std::array< char, 4 > FourCC
Definition: RIFF.h:43
clang::clangd::riff::readChunk
llvm::Expected< Chunk > readChunk(llvm::StringRef &Stream)
Definition: RIFF.cpp:21
clang::clangd::riff::Chunk
Definition: RIFF.h:49
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ChangeNamespace.cpp:18
clang::clangd::riff::operator<<
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const Chunk &C)
Definition: RIFF.cpp:41
clang::clangd::riff::operator==
bool operator==(const Chunk &L, const Chunk &R)
Definition: RIFF.h:53
clang::clangd::riff::File
Definition: RIFF.h:57