aCC difference between preprocessor and compiler

[Gregory Kryltsov]

Version aCC A.03.56
Example:
file test.cpp
#--------------------------------------
#define A2U(x) L#x
int main(int argc, char* argv[])
{
wchar_t* p = A2U(TEST);
return 0;
}
#--------------------------------------

Run: aCC -P test.cpp
Preprocessor result (test.i):
#--------------------------------------
int main(int argc, char* argv[])
{
wchar_t* p = L"TEST" ;
return 0;
}
#--------------------------------------
No error if this result is compiling.

Run: aCC test.cpp
Result: 2 errors
#--------------------------------------
Error 172: "test.cpp", line 5 # Undeclared variable 'L'.
wchar_t* p = A2U(TEST);
^^^
Error 20: "test.cpp", line 5 # ';' expected before '"TEST"'.
wchar_t* p = A2U(TEST);
^^^
#--------------------------------------

It looks like the result of preprocessor and compiler is different. Can anybody help me to avoid this problem?

In previous aCC releases (3.27) there was problem in preprocessor also. For above example the result was

wchar_t* p = L “TEST” ;
// There is 1 space symbol between L and “TEST”.

Now the preprocessor is seems to be working correctly. What about compiler? Is that correct behav

[MAUCCI_2]

Greg,

aCC -P does NOT compile but only preprocesses...

What exactly do you want to do?

++Cyrille

[Daavid Turnbull]

You may find it useful to preprocess the source to a file. This will probably make it easier to determine what the compiler is complaining about.

[Gregory Kryltsov]

That is what I'm talking about. The result of preprocessor differs from what compiler uses for compilation. When preprocessor gives correct result (the source code outputted by preprocessor is compiled successfully) compiler complains on some errors. The example: try to use L macro in define (see example above). Preprocessor outputs correct result where A2U(TEST) is converted to L"TEST". But compiler complains on "undeclared variable L". I noticed such problem when I started work with aCC 3.27. The preprocessor on this version outputs A2U(TEST) as L "TEST" (L plus SPACE plus "TEST"). And the error of "undeclared variable L" is obvious. So, I suppose this is not correct behavior. And it was fixed in preprocessor of 3.56 but not in compiler. My question is : is there any workaround to pass it over?

[MAUCCI_2]

Do you really believe this pre-processed code to be valid c++ code?

-Cyrille

int main(int argc, char* argv[])
{
wchar_t* p = L"TEST" ;
return 0;
}

[MAUCCI_2]

OK, I don't know if your code is valid or not, but I know see your point, and you may have expressed it this way to be more clear:


[08:37:57]:attend:/home/pack
cmaucci> aCC -E -.i a.cpp
[08:37:59]:attend:/home/pack
cmaucci> cat a.i
#line 1 "a.cpp"

#line 2 "a.cpp"
int main(int argc, char* argv[])
{
wchar_t* p = L"TEST" ;
return 0;
}
[08:38:03]:attend:/home/pack
cmaucci> aCC a.i
Warning 829: "a.cpp", line 4 # Implicit conversion of string literal to 'wchar_t *' is deprecated.
wchar_t* p = L"TEST" ;
^^^^^^^


IN 2 STEPS THIS HAS COMPILED!




[08:38:06]:attend:/home/pack
cmaucci> aCC a.cpp
Error 172: "a.cpp", line 4 # Undeclared variable 'L'.
wchar_t* p = A2U(TEST);
^^^
Error 20: "a.cpp", line 4 # ';' expected before '"TEST"'.
wchar_t* p = A2U(TEST);
^^^
[08:38:11]:attend:/home/pack
cmaucci>


IN 1 STEP THIS HAS NOT COMPILED

[Gregory Kryltsov]

Yes, this is some kind of workaround I tried to use but it doesn't work for me. Thank you anyway.

[Stephen Keane]

What about the following slightly amended version?

#--------------------------------------
#define A2U(x) L ## #x
int main(int argc, char* argv[])
{
wchar_t* p = A2U(TEST);
return 0;
}
#--------------------------------------

[Gregory Kryltsov]

Stephen,

This example can not be compiled. Compiler returns 4 errors...
Also preprocessor returns result as
wchar_t* p = L#TEST ;
It seems like preprocessor can not make one more step - to substitute "TEST" instead of #TEST.

[Stephen Keane · Accepted solution]

I'm assuming that the '#--------' lines aren't actually in the C code?

If you are sure that the macro definition reads

#defineA2U(x)L###x

then your compiler is definitely wrong! There is nothing wrong with the syntax. I've checked it on 3 different compilers and they are all happy with it. Is your aCC patched to the latest level?

One kludge you might also try is:

#define CONCAT(x,y) x ## y
#define A2U(x) CONCAT(L,#x)

int main(int argc, char* argv[])
{
wchar_t* p = A2U(TEST);
return 0;
}

Worth a try!

[MAUCCI_2]

Now that I know what you wanna do

#define A2U(x) L##x
int main(int argc, char* argv[])
{
wchar_t* p = A2U("TEST");
return 0;
}


perfectly compiles on aCC 3.60

Cyrille

[MAUCCI_2]

#define A2U(x) L##"x"
int main(int argc, char* argv[])
{
wchar_t* p = A2U(TEST);
return 0;
}

also works

[Stephen Keane]

#define A2U(x) L##"x"
int main(int argc, char* argv[])
{
wchar_t* p = A2U(TEST);
return 0;
}

Doesn't work on all compilers. You end up (on some compilers) with

wchar_t* p = L"x"

[Gregory Kryltsov]

Stephen,

Your variant

#define CONCAT(x,y) x ## y
#define A2U(x) CONCAT(L,#x)

int main(int argc, char* argv[])
{
wchar_t* p = A2U(TEST);
return 0;
}

works perfect. Thank you very much.

[Gregory Kryltsov]

Cyrille,

wchar_t* p = A2U("TEST"); would not work in all cases because sometime you may want to use x in macro to create variable assosiated with it. Somethink like m_x = L"x". Thank you anyway.

[Gregory Kryltsov]

The final solution:

#define CONCAT(x,y) x ## y
#define A2U(x) CONCAT(L,#x)

int main(int argc, char* argv[])
{
wchar_t* p = A2U(TEST);
return 0;
}

Provided by Stephen Keane