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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
//===-- Shared/EnvironmentVar.h - Environment variable handling -*- 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
//
//===----------------------------------------------------------------------===//
//
//===----------------------------------------------------------------------===//
#ifndef OMPTARGET_SHARED_ENVIRONMENT_VAR_H
#define OMPTARGET_SHARED_ENVIRONMENT_VAR_H
#include "Debug.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Error.h"
#include <sstream>
#include <string>
/// Utility class for parsing strings to other types.
struct StringParser {
/// Parse a string to another type.
template <typename Ty> static bool parse(const char *Value, Ty &Result);
};
/// Class for reading and checking environment variables. Currently working with
/// integer, floats, std::string and bool types.
template <typename Ty> class Envar {
llvm::StringRef Name;
Ty Data;
bool IsPresent;
bool Initialized;
public:
/// Auxiliary function to safely create envars. This static function safely
/// creates envars using fallible constructors. See the constructors to know
/// more details about the creation parameters.
template <typename... ArgsTy>
static llvm::Expected<Envar> create(ArgsTy &&...Args) {
llvm::Error Err = llvm::Error::success();
Envar Envar(std::forward<ArgsTy>(Args)..., Err);
if (Err)
return std::move(Err);
return std::move(Envar);
}
/// Create an empty envar. Cannot be consulted. This constructor is merely
/// for convenience. This constructor is not fallible.
Envar() : Data(Ty()), IsPresent(false), Initialized(false) {}
/// Create an envar with a name and an optional default. The Envar object will
/// take the value read from the environment variable, or the default if it
/// was not set or not correct. This constructor is not fallible.
Envar(llvm::StringRef Name, Ty Default = Ty())
: Name(Name), Data(Default), IsPresent(false), Initialized(true) {
if (const char *EnvStr = getenv(Name.data())) {
// Check whether the envar is defined and valid.
IsPresent = StringParser::parse<Ty>(EnvStr, Data);
if (!IsPresent) {
DP("Ignoring invalid value %s for envar %s\n", EnvStr, Name.data());
Data = Default;
}
}
}
Envar<Ty> &operator=(const Ty &V) {
Data = V;
Initialized = true;
return *this;
}
/// Get the definitive value.
const Ty &get() const {
// Throw a runtime error in case this envar is not initialized.
if (!Initialized)
FATAL_MESSAGE0(1, "Consulting envar before initialization");
return Data;
}
/// Get the definitive value.
operator Ty() const { return get(); }
/// Return the environment variable name.
llvm::StringRef getName() const { return Name; }
/// Indicate whether the environment variable was defined and valid.
bool isPresent() const { return IsPresent; }
private:
/// This constructor should never fail but we provide it for convenience. This
/// way, the constructor can be used by the Envar::create() static function
/// to safely create this kind of envars.
Envar(llvm::StringRef Name, Ty Default, llvm::Error &Err)
: Envar(Name, Default) {
llvm::ErrorAsOutParameter EAO(&Err);
Err = llvm::Error::success();
}
/// Create an envar with a name, getter function and a setter function. The
/// Envar object will take the value read from the environment variable if
/// this value is accepted by the setter function. Otherwise, the getter
/// function will be executed to get the default value. The getter should be
/// of the form Error GetterFunctionTy(Ty &Value) and the setter should
/// be of the form Error SetterFunctionTy(Ty Value). This constructor has a
/// private visibility because is a fallible constructor. Please use the
/// Envar::create() static function to safely create this object instead.
template <typename GetterFunctor, typename SetterFunctor>
Envar(llvm::StringRef Name, GetterFunctor Getter, SetterFunctor Setter,
llvm::Error &Err)
: Data(Ty()), IsPresent(false), Initialized(true) {
llvm::ErrorAsOutParameter EAO(&Err);
Err = init(Name, Getter, Setter);
}
template <typename GetterFunctor, typename SetterFunctor>
llvm::Error init(llvm::StringRef Name, GetterFunctor Getter,
SetterFunctor Setter);
};
/// Define some common envar types.
using IntEnvar = Envar<int>;
using Int32Envar = Envar<int32_t>;
using Int64Envar = Envar<int64_t>;
using UInt32Envar = Envar<uint32_t>;
using UInt64Envar = Envar<uint64_t>;
using StringEnvar = Envar<std::string>;
using BoolEnvar = Envar<bool>;
template <>
inline bool StringParser::parse(const char *ValueStr, bool &Result) {
std::string Value(ValueStr);
// Convert the string to lowercase.
std::transform(Value.begin(), Value.end(), Value.begin(),
[](unsigned char c) { return std::tolower(c); });
// May be implemented with fancier C++ features, but let's keep it simple.
if (Value == "true" || Value == "yes" || Value == "on" || Value == "1")
Result = true;
else if (Value == "false" || Value == "no" || Value == "off" || Value == "0")
Result = false;
else
return false;
// Parsed correctly.
return true;
}
template <typename Ty>
inline bool StringParser::parse(const char *Value, Ty &Result) {
assert(Value && "Parsed value cannot be null");
std::istringstream Stream(Value);
Stream >> Result;
return !Stream.fail();
}
template <typename Ty>
template <typename GetterFunctor, typename SetterFunctor>
inline llvm::Error Envar<Ty>::init(llvm::StringRef Name, GetterFunctor Getter,
SetterFunctor Setter) {
// Get the default value.
Ty Default;
if (llvm::Error Err = Getter(Default))
return Err;
if (const char *EnvStr = getenv(Name.data())) {
IsPresent = StringParser::parse<Ty>(EnvStr, Data);
if (IsPresent) {
// Check whether the envar value is actually valid.
llvm::Error Err = Setter(Data);
if (Err) {
// The setter reported an invalid value. Mark the user-defined value as
// not present and reset to the getter value (default).
IsPresent = false;
Data = Default;
DP("Setter of envar %s failed, resetting to %s\n", Name.data(),
std::to_string(Data).data());
consumeError(std::move(Err));
}
} else {
DP("Ignoring invalid value %s for envar %s\n", EnvStr, Name.data());
Data = Default;
}
} else {
Data = Default;
}
return llvm::Error::success();
}
#endif // OMPTARGET_SHARED_ENVIRONMENT_VAR_H
|
