JP>
  > That's true. Given the choice between Metaware and VAC++, I would
  > hesitate. Metaware is much slower to compile than VAC++ and has a
  > proprietary preprocessor syntax which require you to
  > rewrite almost all definitions.
JP>

  Untrue.

  The preprocessor syntax is the same for *all* C++ compilers for OS/2.
  Preprocessor directives (#if, #endif, #define, #undef, #include) have
  been standardised for many years now, and you will find that they are
  the same on just about any C or C++ compiler on any platform that you
  care to try.

  If you are talking about #pragma, then you should read up a bit more on
  the C++ language.  #pragma is the "standard" means for introducing
  non-standard directives into source.  It is *supposed* to be
  non-portable.  If you are using it, then you should *expect* to be
  locked into one compiler.

  Speaking in practical terms, the only times that #pragma is important for
  IBM VisualAge C++ are for calling convention specifications and for
  DirectToSOM C++ directives.  Most of the remaining uses of #pragma are
  for frippery specific to VAC++ that doesn't apply to other C++ compilers.

  In the first case (calling convention specifications), you really
  shouldn't be using #pragma linkage anyway.  If you are going to claim
  that anything is proprietary, then that *certainly* is :  IBM
  proprietary.  Don't use #pragma linkage.  Use calling convention
  specifiers such as APIENTRY.  Not only does the compiler perform
  stronger syntax checking on them, but also they are available in *all*
  of the commercial C++ compilers for OS/2.

  In the second case (DirectToSOM C++ directives), you will find that
  MetaWare High C++ actually understands most of the DTS C++ #pragmas that
  IBM VisualAge C++ understands, in addition to its own DTS C++ #pragmas.
  ( The MetaWare ones are easier to use, but that's beside the point.  )

  > JdeBP <
___
 X MegaMail 2.10 #0:
--- Maximus/2 3.01