How to find in my program a "const char* + int" expression

Question

I'm in a source code migration and the converter program did not convert concatenation of embedded strings with integers. Now I have lots of code with this kind of expressions:

f("some text" + i);

Since C/C++ will interpret this as an array subscript, f will receive "some text", or "ome text", or "me text"...

My source language converts the concatenation of an string with an int as an string concatenation. Now I need to go line by line through the source code and change, by hand, the previous expression to:

f("some text" + std::to_string(i));

The conversion program managed to convert local "String" variables to "std::string", resulting in expressions:

std::string some_str = ...;
int i = ...;

f(some_str + i);

Those were easy to fix because with such expressions the C++ compiler outputs an error.

Is there any tool to find automatically such expressions on source code?

Answer 1

Easy! Just replace all the + with -&:

find . -name '*.cpp' -print0 | xargs -0 sed -i '' 's/+/-\&/g'

When trying to compile your project you will see, between other errors, something like this:

foo.cpp:9:16: error: 'const char *' and 'int *' are not pointers to compatible types
    return f(s -& i);
             ~ ^~~~

(I'm using clang, but other compilers should issue similar errors)

So you just have to filter the compiler output to keep only those errors:

clang++ foo.cpp 2>&1 | grep -F "error: 'const char *' and 'int *' are not pointers to compatible types"

And you get:

foo.cpp:9:16: error: 'const char *' and 'int *' are not pointers to compatible types
foo.cpp:18:10: error: 'const char *' and 'int *' are not pointers to compatible types

Answer 2

You can try flint, an open-source lint program for C++ developed and used at Facebook. It has blacklisted token sequences feature (checkBlacklistedSequences). You can add your token sequence to the checkBlacklistedSequences function and flint will report them.

in checkBlacklistedSequences function, I added the sequence string_literal + number

BlacklistEntry([tk!"string_literal", tk!"+", tk!"number"],
               "string_literal + number problem!\n",
                true),

then compile and test

$ cat -n test.cpp
 1  #include <iostream>
 2  #include <string>
 3  
 4  using namespace std;
 5  
 6  void f(string str)
 7  {
 8      cout << str << endl;
 9  }
10  
11  int main(int argc, char *argv[])
12  {
13      f("Hello World" + 2);
14  
15      f("Hello World" + std::to_string(2));
16  
17      f("Hello World" + 2);
18  
19      return 0;
20  }

$ ./flint test.cpp 
test.cpp(13): Warning: string_literal + number problem!
test.cpp(17): Warning: string_literal + number problem!

flint has two versions (old version developed in C++ and new version in D language), I made my changes in D version.

Answer 3

I'm not familiar with a lot of tools which can do that, but I think grep can be helpful in some measure.

In the root directory of your source code, try:

grep -rn '".\+"\s*+\s*' .

, which can find out all the files which containt a line like "xxxxx" +, hope this can help you find all the lines you need.

If all the integers are constant, you can alter the grep experssion as:

grep -rn '".\+"\s*+\s*[0-9]*' .

And you can also include the ( before the string constant:

grep -rn '(".\+"\s*+\s*[0-9]*' .

This may be not the "correct" answer, but I hope this can help you.

Answer 4

You may not need an external tool. Instead, you can take advantage of C++ one-user-defined-conversion rule. Basically, you need to change the argument of your f function from const char*/std::string to a type, that is implicitly convertible only from either a string literal (const char[size]) or an std::string instance (what you get when you add std::to_string in the expression).

#include <string>
#include <iostream>

struct string_proxy
{
    std::string value;

    string_proxy(const std::string& value) : value(value) {}

    string_proxy(std::string&& value) : value(std::move(value)) {}

    template <size_t size>
    string_proxy(const char (&str)[size]) : value(str) {}
};

void f(string_proxy proxy)
{
    std::cout << proxy.value << std::endl;
}

int main()
{
    f("this works"); // const char[size]
    f("this works too: " + std::to_string(10)); //  std::string
    f("compile error!" + 10); // const char*
    return 0;
}

Note that this is not going to work on MSVC, at least not in 2012 version; it's likely a bug, since there are no warning emitted either. It works perfectly fine in g++ and clang (you can quickly check it here).

Answer 5

I've found a very simple way to detect this issue. Regular expression nor a lint won't match more complex expressions like the following:

f("Hello " + g(i));

What I need is to somehow do type inference, so I'm letting the compiler to do it. Using an std::string instead of a literal string raises an error, so I wrote a simple source code converter to translate all the string literals to the wrapped std::string version, like this:

f(std::string("Hello ") + g(i));

Then, after recompiling the project, I'd see all the errors. The source code is on GitHub, in 48 lines of Python code:

https://gist.github.com/alejolp/3a700e1730e0328c68de

Answer 6

If your case is exactly as

"some text in quotations" + a_numeric_variable_or_constant

then Powergrep or similar programs will let you to scan all files for

("[^"]+")\s*\+\s*(\w+)

and replace with

\1 + std::to_string(\2)

This will bring the possible matches to you but i strongly recommend first preview what you are replacing. Because this will also replace the string variables.

Regular expressions cannot understand the semantics of your code so they cannot be sure that if they are integers. For that you need a program with a parser like CDT or static code analyzers. But unfortunately i do not know any that can do that. So to sum i hope regex helps :)

PS: For the worst case if the variables are not numeric then compiler will give you error because to_string function doesn't accept anything than numeric values. May be later then you can manually replace only them which i can only hope won't be more.

PS 2: Some may think that Powergrep is expensive. You can use trial for 15 day with full functionality.

Answer 7

You can have a try at the Map-Reduce Clang plugin. The tool was developped at Google to do just this kind of refactoring, mixing strong type-checking and regexp.

(see video presentation here ).

Answer 8

You can use C++ typecasting operator & create a new class which can overload the operator + to your need. You can replace the int to new class "Integer" & perform the required overloading. This requires no changes or word replacing in the main function invocation.

class Integer{
    long  i;
    std::string formatted;
public:
     Integer(int i){i = i;}
     operator char*(){
        return (char*)formatted.c_str();}
     friend Integer operator +( char* input, Integer t);
};
Integer operator +( char* input, Integer integer) {
    integer.formatted = input + std::to_string(integer.i);
    return integer;
}
Integer i = ....
f("test" + i); //executes the overloaded operator

Answer 9

i'm assuming for function f(some_str + i); your definition should be like this

 void f(std::string value)
 {
    // do something.
 }

if you declare some other class like AdvString to implement Operator + for intergers. if your declare your function like this below code. it will work like this implementation f(some_str + i);

 void f(AdvString value)
 {
   // do something.
 }

sample implementation is here https://github.com/prasaathviki/advstring