Annotations.cpp Source File (original) (raw)

15using namespace llvm;

20 if (!Assertion) {

21 llvm::errs() << "Annotated testcase: " << Msg << "\n" << Code << "\n";

23 }

24}

27 auto Require = [Text](bool Assertion, const char *Msg) {

28 require(Assertion, Msg, Text);

29 };

30 std::optionalllvm::StringRef Name;

31 std::optionalllvm::StringRef Payload;

34 Code.reserve(Text.size());

35 while (!Text.empty()) {

36 if (Text.consume_front("^")) {

37 All.push_back(

38 {Code.size(), size_t(-1), Name.value_or(""), Payload.value_or("")});

39 Points[Name.value_or("")].push_back(All.size() - 1);

40 Name = std::nullopt;

41 Payload = std::nullopt;

42 continue;

43 }

44 if (Text.consume_front("[[")) {

46 {Code.size(), size_t(-1), Name.value_or(""), Payload.value_or("")});

47 Name = std::nullopt;

48 Payload = std::nullopt;

49 continue;

50 }

51 Require(!Name, "$name should be followed by ^ or [[");

52 if (Text.consume_front("]]")) {

53 Require(!OpenRanges.empty(), "unmatched ]]");

55 const Annotation &NewRange = OpenRanges.back();

56 All.push_back(

57 {NewRange.Begin, Code.size(), NewRange.Name, NewRange.Payload});

58 Ranges[NewRange.Name].push_back(All.size() - 1);

61 continue;

62 }

63 if (Text.consume_front("$")) {

64 Name =

65 Text.take_while([](char C) { return llvm::isAlnum(C) || C == '_'; });

66 Text = Text.drop_front(Name->size());

68 if (Text.consume_front("(")) {

69 Payload = Text.take_while([](char C) { return C != ')'; });

70 Require(Text.size() > Payload->size(), "unterminated payload");

71 Text = Text.drop_front(Payload->size() + 1);

72 }

74 continue;

75 }

76 Code.push_back(Text.front());

77 Text = Text.drop_front();

78 }

79 Require(!Name, "unterminated $name");

80 Require(OpenRanges.empty(), "unmatched [[");

81}

87std::pair<size_t, llvm::StringRef>

89 auto I = Points.find(Name);

90 require(I != Points.end() && I->getValue().size() == 1,

91 "expected exactly one point", Code);

92 const Annotation &P = All[I->getValue()[0]];

93 return {P.Begin, P.Payload};

94}

98 std::vector<size_t> Positions;

99 Positions.reserve(Pts.size());

100 for (const auto &[Point, Payload] : Pts)

101 Positions.push_back(Point);

102 return Positions;

103}

104

105std::vector<std::pair<size_t, llvm::StringRef>>

107 auto Iter = Points.find(Name);

108 if (Iter == Points.end())

109 return {};

110

111 std::vector<std::pair<size_t, llvm::StringRef>> Res;

112 Res.reserve(Iter->getValue().size());

113 for (size_t I : Iter->getValue())

114 Res.push_back({All[I].Begin, All[I].Payload});

115

116 return Res;

117}

118

121 for (const auto &Name : Points.keys()) {

122 auto Pts = points(Name);

123 Result[Name] = {Pts.begin(), Pts.end()};

124 }

125 return Result;

126}

127

131

132std::pair<Annotations::Range, llvm::StringRef>

134 auto I = Ranges.find(Name);

135 require(I != Ranges.end() && I->getValue().size() == 1,

136 "expected exactly one range", Code);

137 const Annotation &R = All[I->getValue()[0]];

138 return {{R.Begin, R.End}, R.Payload};

139}

140

141std::vectorAnnotations::Range

144 std::vectorAnnotations::Range Res;

145 Res.reserve(WithPayload.size());

146 for (const auto &[Range, Payload] : WithPayload)

147 Res.push_back(Range);

148 return Res;

149}

150std::vector<std::pair<Annotations::Range, llvm::StringRef>>

152 auto Iter = Ranges.find(Name);

153 if (Iter == Ranges.end())

154 return {};

155

156 std::vector<std::pair<Annotations::Range, llvm::StringRef>> Res;

157 Res.reserve(Iter->getValue().size());

158 for (size_t I : Iter->getValue())

160 All[I].Payload);

161

162 return Res;

163}

164

169 auto R = ranges(Name);

170 Res[Name] = {R.begin(), R.end()};

171 }

172 return Res;

173}

174

177 return O << llvm::formatv("[{0}, {1})", R.Begin, R.End);

178}

static void require(bool Assertion, const char *Msg, llvm::StringRef Code)

Definition Annotations.cpp:19

Annotations(llvm::StringRef Text)

Parses the annotations from Text. Crashes if it's malformed.

Definition Annotations.cpp:26

std::vector< std::pair< size_t, llvm::StringRef > > pointsWithPayload(llvm::StringRef Name="") const

Returns the positions and payloads (if any) of all points named Name.

Definition Annotations.cpp:106

Range range(llvm::StringRef Name="") const

Returns the location of the range marked by [[ ]] (or $name[[ ]]).

Definition Annotations.cpp:128

size_t point(llvm::StringRef Name="") const

Returns the position of the point marked by ^ (or $name^) in the text.

Definition Annotations.cpp:83

std::pair< size_t, llvm::StringRef > pointWithPayload(llvm::StringRef Name="") const

Returns the position of the point with Name and its payload (if any).

Definition Annotations.cpp:88

llvm::StringMap< llvm::SmallVector< size_t, 1 > > all_points() const

Returns the mapping of all names of points marked in the text to their position.

Definition Annotations.cpp:119

std::pair< Range, llvm::StringRef > rangeWithPayload(llvm::StringRef Name="") const

Returns the location and payload of the range marked by [[ ]] (or $name(payload)[[ ]]).

Definition Annotations.cpp:133

std::vector< Range > ranges(llvm::StringRef Name="") const

Returns the location of all ranges marked by [[ ]] (or $name[[ ]]).

Definition Annotations.cpp:142

std::vector< std::pair< Range, llvm::StringRef > > rangesWithPayload(llvm::StringRef Name="") const

Returns the location of all ranges marked by [[ ]] (or $name(payload)[[ ]]).

Definition Annotations.cpp:151

llvm::StringMap< llvm::SmallVector< Range, 1 > > all_ranges() const

Returns the mapping of all names of ranges marked in the text to their location.

Definition Annotations.cpp:166

std::vector< size_t > points(llvm::StringRef Name="") const

Returns the position of all points marked by ^ (or $name^) in the text.

Definition Annotations.cpp:96

void reserve(size_type N)

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

StringRef - Represent a constant reference to a string, i.e.

This class implements an extremely fast bulk output stream that can only output to a stream.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)

bool isAlnum(char C)

Checks whether character C is either a decimal digit or an uppercase or lowercase letter as classifie...

LLVM_ABI raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)

Two offsets pointing to a continuous substring.