Replacing tokens inside string - c++

Question

What i am trying to do is to replace all the tokens with a similiar syntax [[VULKAN_SDK]] inside a string. I want to take the contents of the brackes(in this case VULKAN_SDK) and replace the entire token with a value i get from getenv by passing the contents of the brackets. Example [[VULKAN_SDK]] gets replaced by C:\VulkanSDK\1.2.148.1(a system enviroment variable).
If the enviroment variable does not exist then the token should not be replaced.
Here is my code:
void replaceSystemEnviromentTokens(std::string& var) {
static const char* tokenOpening = "[[";
static const char* tokenClosure = "]]";
auto getEnvVal = [](const char* var) {
char * val = std::getenv(var);
return val == NULL ? std::string() : std::string(val);
};
std::size_t temp = var.find(tokenOpening, 0);
while(temp != std::string::npos) {
const std::size_t beginning = temp;
const std::size_t end = var.find(tokenClosure, beginning);
temp = var.find(tokenOpening, beginning + 1);
if(end == std::string::npos)
break;
if(temp != std::string::npos)
if(end > temp)
continue;
const std::size_t tokenSize = end - (beginning + strlen(tokenOpening));
const std::string token = var.substr(beginning + strlen(tokenOpening), tokenSize);
const std::string translatedToken = getEnvVal(token.c_str());
if(!translatedToken.empty()) {
const std::size_t currentSize = var.length();
var.replace(beginning, end, translatedToken);
if(temp != std::string::npos) {
temp += currentSize - var.length();
if(temp > var.length())
temp = std::string::npos;
}
}
}
}
Testing:
int main(int argc, char** argv) {
std::string test = "this should be converted: [[VULKAN_SDK]] this should not be converted: VULKAN_SDK]] this: [[VULKAN_SDK]]";
replaceSystemEnviromentTokens(test);
std::cout << test << std::endl;
}
current behavior: this should be converted: C:\VulkanSDK\1.2.148.1erted: VULKAN_SDK]] this: [[VULKAN_SDK]]
expected behavior: this should be converted: C:\VulkanSDK\1.2.148.1 this should not be converted: VULKAN_SDK]] this: C:\VulkanSDK\1.2.148.1

Answer 1

Using the in-built replace() function in C++17, you can accomplish the above stated task with minimal code.
If the given string test = "abc [[vul [[hjh]] [[nj [[ hg[[gfgh]] ]]m ]]xyz" or "abc [[vul[[kan]] xyz" or of similar type then you can see this as a variation of the balanced parenthesis problem which is solved using stack.
void replaceSystemEnviromentTokens(std::string& var) {
static const char* tokenOpening = "[[";
static const char* tokenClosure = "]]";
auto getEnvVal = [](const char* var) {
char * val = std::getenv(var);
return val == NULL ? std::string() : std::string(val);
};
std::stack<int> s;
for(int i =0; i<var.size();i++){
if(var[i]=='[' && (i+1)<var.size() && var[i+1]=='['){
s.push(i);
i++;
}
if(var[i]==']' && (i+1)<var.size() && var[i+1]==']'){
if(!s.empty()){
// This means we have encountered a [[ before as well
// And using the stack, we would get the most recent [[
int a = s.top();
s.pop();
// A corner case of [[]] can be checked here i.e empty string
// The case of [[ ]] can also be checked but for now it is omitted
int beg = a + strlen(tokenOpening);
const std::size_t tokenSize = i - beg;
if(tokenSize > 0){
// Non-empty token enclosed between [[____]]
const std::string token = var.substr(beg, tokenSize);
const std::string translatedToken = getEnvVal(token.c_str());
if(!translatedToken.empty()) {
var.replace(a, tokenSize + strlen(tokenOpening) + strlen(tokenClosure), translatedToken);
/*
Here you need to decide what to initialize i with here
If the translatedToken itself would bring more [[___]] pairs
and you would want to replace their tokens as well
then i = a-1, if not then i = a + translatedToken.size()-1
*/
i = a + translatedToken.size()-1;
}
}
}
}
}
}

Answer 2

EDIT: risingStark found that the original version wasn't working! This is a fix which looks definitely uglier than the original one, but at least it works. I really hate the need to start over with the iterator, but I couldn't quickly find a better way. Try this out here: https://ideone.com/Hcb4BM
I wanted to do it with regular expressions, but it took me forever to understand how those work in C++. Anyway, this is the result:
void replaceSystemEnviromentTokens(std::string& var)
{
static std::string tokenOpening = "\\[\\[";
static std::string tokenClosure = "\\]\\]";
auto getEnvVal = [](const std::string& var) {
char* val = getenv(var.c_str());
return std::string(val ? val : "");
};
std::regex re(tokenOpening + "(\\S+)" + tokenClosure);
std::sregex_iterator it(var.begin(),var.end(),re);
std::sregex_iterator end;
while (it != end) {
auto& m = *it;
auto value = getEnvVal(m.str(1));
if (!value.empty()) {
std::regex re_replace(tokenOpening + m.str(1) + tokenClosure);
var = regex_replace(var, re_replace, value);
it = std::sregex_iterator(var.begin(), var.end(), re);
}
else {
++it;
}
}
}
I'm not so sure it's better than the accepted answer, but at least now I know how to use <regex>... I think there must be a better way to deal with the creation of a new regular expression for each token, but I can't see anything to solve the problem.