topic Re: aCC difference between preprocessor and compiler in Operating System - HP-UX

aCC difference between preprocessor and compiler

Gregory Kryltsov — Fri, 04 Feb 2005 19:07:55 GMT

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

Re: aCC difference between preprocessor and compiler

MAUCCI_2 — Sat, 05 Feb 2005 13:58:11 GMT

Greg,

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

What exactly do you want to do?

++Cyrille

Re: aCC difference between preprocessor and compiler

Daavid Turnbull — Sun, 06 Feb 2005 21:06:50 GMT

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.

Re: aCC difference between preprocessor and compiler

Gregory Kryltsov — Mon, 07 Feb 2005 02:20:40 GMT

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?

Re: aCC difference between preprocessor and compiler

MAUCCI_2 — Mon, 07 Feb 2005 02:28:35 GMT

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;
}

Re: aCC difference between preprocessor and compiler

MAUCCI_2 — Mon, 07 Feb 2005 02:34:38 GMT

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

Re: aCC difference between preprocessor and compiler

Gregory Kryltsov — Mon, 07 Feb 2005 12:58:01 GMT

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

Re: aCC difference between preprocessor and compiler

Stephen Keane — Wed, 09 Feb 2005 04:22:54 GMT

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;
}
#--------------------------------------

Re: aCC difference between preprocessor and compiler

Gregory Kryltsov — Wed, 09 Feb 2005 13:06:46 GMT

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.

Re: aCC difference between preprocessor and compiler

Stephen Keane — Thu, 10 Feb 2005 04:10:20 GMT

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!

Re: aCC difference between preprocessor and compiler

MAUCCI_2 — Thu, 10 Feb 2005 04:30:10 GMT

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

Re: aCC difference between preprocessor and compiler

MAUCCI_2 — Thu, 10 Feb 2005 04:31:57 GMT

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

also works

Re: aCC difference between preprocessor and compiler

Stephen Keane — Thu, 10 Feb 2005 05:11:09 GMT

#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"

Re: aCC difference between preprocessor and compiler

Gregory Kryltsov — Thu, 10 Feb 2005 12:49:41 GMT

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.

Re: aCC difference between preprocessor and compiler

Gregory Kryltsov — Thu, 10 Feb 2005 12:52:48 GMT

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.

Re: aCC difference between preprocessor and compiler

Gregory Kryltsov — Thu, 10 Feb 2005 12:55:05 GMT

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