How to find in my program a "const char* + int" expression
c, c++, migration, vb6-migration
Solution
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
Problem
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?