LLVM: lib/Support/VersionTuple.cpp Source File

21 std::string VersionTuple::getAsString() const {

22 std::string Result;

23 {

24 llvm::raw_string_ostream Out(Result);

25 Out << *this;

26 }

27 return Result;

28}

30 raw_ostream &llvm::operator<<(raw_ostream &Out, const VersionTuple &V) {

31 Out << V.getMajor();

32 if (std::optional<unsigned> Minor = V.getMinor())

33 Out << '.' << *Minor;

34 if (std::optional<unsigned> Subminor = V.getSubminor())

35 Out << '.' << *Subminor;

36 if (std::optional<unsigned> Build = V.getBuild())

37 Out << '.' << *Build;

38 return Out;

39}

41 static bool parseInt(StringRef &input, unsigned &value) {

42 assert(value == 0);

43 if (input.empty())

44 return true;

45

46 char next = input[0];

47 input = input.substr(1);

48 if (next < '0' || next > '9')

49 return true;

50 value = (unsigned)(next - '0');

51

52 while (!input.empty()) {

53 next = input[0];

54 if (next < '0' || next > '9')

55 return false;

56 input = input.substr(1);

57 value = value * 10 + (unsigned)(next - '0');

58 }

59

60 return false;

61}

63 bool VersionTuple::tryParse(StringRef input) {

64 unsigned major = 0, minor = 0, micro = 0, build = 0;

65

66 // Parse the major version, [0-9]+

67 if (parseInt(input, major))

68 return true;

69

70 if (input.empty()) {

71 *this = VersionTuple(major);

72 return false;

73 }

74

75 // If we're not done, parse the minor version, \.[0-9]+

76 if (input[0] != '.')

77 return true;

78 input = input.substr(1);

79 if (parseInt(input, minor))

80 return true;

81

82 if (input.empty()) {

83 *this = VersionTuple(major, minor);

84 return false;

85 }

86

87 // If we're not done, parse the micro version, \.[0-9]+

88 if (!input.consume_front("."))

89 return true;

90 if (parseInt(input, micro))

91 return true;

92

93 if (input.empty()) {

94 *this = VersionTuple(major, minor, micro);

95 return false;

96 }

97

98 // If we're not done, parse the micro version, \.[0-9]+

99 if (!input.consume_front("."))

100 return true;

101 if (parseInt(input, build))

102 return true;

103

104 // If we have characters left over, it's an error.

105 if (!input.empty())

106 return true;

107

108 *this = VersionTuple(major, minor, micro, build);

109 return false;

110}

112 VersionTuple VersionTuple::withMajorReplaced(unsigned NewMajor) const {

113 if (HasBuild)

114 return VersionTuple(NewMajor, Minor, Subminor, Build);

115 if (HasSubminor)

116 return VersionTuple(NewMajor, Minor, Subminor);

117 if (HasMinor)

118 return VersionTuple(NewMajor, Minor);

119 return VersionTuple(NewMajor);

120}

assert

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

StringRef.h

parseInt

static bool parseInt(StringRef &input, unsigned &value)

Definition VersionTuple.cpp:41

VersionTuple.h

Defines the llvm::VersionTuple class, which represents a version in the form major[....

llvm::StringRef

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

Definition StringRef.h:55

llvm::StringRef::substr

constexpr StringRef substr(size_t Start, size_t N=npos) const

Return a reference to the substring from [Start, Start + N).

Definition StringRef.h:573

llvm::StringRef::empty

constexpr bool empty() const

empty - Check if the string is empty.

Definition StringRef.h:143

llvm::StringRef::consume_front

bool consume_front(StringRef Prefix)

Returns true if this StringRef has the given prefix and removes that prefix.

Definition StringRef.h:637

llvm::VersionTuple

Represents a version number in the form major[.minor[.subminor[.build]]].

Definition VersionTuple.h:30

llvm::VersionTuple::tryParse

LLVM_ABI bool tryParse(StringRef string)

Try to parse the given string as a version number.

Definition VersionTuple.cpp:63

llvm::VersionTuple::getAsString

LLVM_ABI std::string getAsString() const

Retrieve a string representation of the version number.

Definition VersionTuple.cpp:21

llvm::VersionTuple::withMajorReplaced

LLVM_ABI VersionTuple withMajorReplaced(unsigned NewMajor) const

Return a version tuple that contains a different major version but everything else is the same.

Definition VersionTuple.cpp:112

llvm::VersionTuple::VersionTuple

constexpr VersionTuple()

Definition VersionTuple.h:43

llvm::raw_ostream

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

Definition raw_ostream.h:53

llvm::raw_string_ostream

A raw_ostream that writes to an std::string.

Definition raw_ostream.h:662

unsigned

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition AddressRanges.h:18

llvm::operator<<

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

Definition APFixedPoint.h:312

raw_ostream.h