Comeau C++ 4.2.x for Windows 95+!!

Comeau C++ 4.2.x Front-End
Additional information for MS-Windows 95+ customers

Comeau C/C++ is available for use with MS-Windows 95 in a so-called "DOS box". As with all ports since 4.0, Comeau C++ for MS-Windows costs $50. It is also available for use with MS-Windows NT, MS-Windows 98 and MS-Windows 2000.
The generally available version of Comeau C/C++ for MS-Windows currently requires MSVC++. That is, currently, although Comeau C++ can be tailored to generate native object code, all currently available ports generate C as their object code. As such, one or more C compilers have been extensively tested with each operating system it is available for. Under MS-Windows, Comeau C++ has been extensively tested with the C part of MS Visual C++ ("Good old" Microsoft C may work too, but we have not tested it). Support for additional C compilers will be added in the future. In the meantime, if you need to use Comeau C++ with another C compiler under MS-Windows, then you need to contact us about a custom port as you will not be able to do it yourself.
libcomo is now available for use with Comeau C++ under Windows. See http://www.comeaucomputing.com/libcomo for details.
Debugging? Comeau C/C++ can be used with the Microsoft debugger. It will display your C++ source code (or your C source in the case that you're using a C mode of Comeau C/C++). Note however that the Comeau and Microsoft name mangling formulas are different, therefore, if you want to set a breakpoint manually, then you will need to use the mangled Comeau name. On the other hand, you can set breakpoints graphically, by right clicking your mouse, just like the way you would do it with any app. As well, you can manually breakpoint on a particular line, by entering something such as:
```
{,YourFile.c,} .99
```
(where 99 is the line number) into the breakpoint window box input field. Note that name mangling is not an issue in C mode, or with extern "C"'d functions, so you can use those names directly, if you want, in addition to the above choices.
To invoke Comeau C++, you will use the como command. Please use it to compile your source files. Note that you must also use como when link'ing your object files.
Note that under Windows, the default mode is not strict mode, instead --microsoft is the default mode. This allows compatibility with the MS header files. For most platforms, when you invoke Comeau C++, it will tell you what mode it is in. Note that to use Comeau C++ in strict mode with VC++, you may have success in invoking it with these options:
```
-A --no_microsoft -D_WCHAR_T_DEFINED -D_MSC_VER -D__cdecl=
```
As well, see below about changing <assert.h>. We're curious on your feedback on how successful these settings are for your projects if you need strict mode under Windows.
In order to effectively use como, which is found in \<YourComeauDir>\bin\como.exe, you will need to set the following environment variables (Note: Each of the below is one line, however, your browser may line wrap them giving the appearance that an environment variable is on a line by itself -- it isn't):

COMO_BASE=Drive:\<YourComeauDir> COMO_MS_INCLUDE=Drive:\<YourMSVC++IncludeDir> COMO_INCLUDE=Drive:\Dir1;Drive:\DirN TMPDIR=Drive:\SomeWriteableTemporaryDirectory

Additionally, note:
- COMO_MS_INCLUDE can only contain one directory while COMO_INCLUDE can contain multiple directories (separated by a semicolon).
- The order of includes is -I's, COMO_INCLUDE, COMO_BASE\include, COMO_MS_INCLUDE
- You will also need to add Drive:\<YourComeauDir>\bin to your PATH environment variable.
- Also, since como invokes MSVC++, you will need cls directory in your PATH too.
- You will need to set your MSVC++ LIB environment variable appropriately too.
- See below if you need an alternative <winnt.h> for use with VC++ 6.0
To compile only, without linking, use the -c command line option:
```
como xyz.c    Compile and link
como -c xyz.c Compile only, results in xyz.obj
link xyz.obj  Don't do this, this is an error
como xyz.obj  Compile xyz.obj into aout.exe
```
Do not confuse this with the --c (note two dashes not one) option which specificies C90 mode. So if you want to compile and link a C90 source you'd write:
```
como -c --c c.c
```
The default name of the resulting executable produced by como is aout.exe. To override this, use the -o option. For instance:

como xyz.c aout <Output here> como -o abc xyz.c abc <Output here>

Do not use a file extension with -o:

como -o abc.exe xyz.c Don't do this

And do note that there is whitespace after -o, so this is not allowed:

como -oabc xyz.c

Note as well that -o is only use to specify an executable file name, not an object file name. (We expect a fix for this shortly.)
As with when you use Microsoft VC++'s cl by itself, your compile using Comeau C++ may produce the following linker diagnostic:

LINK : fatal error LNK1561: entry point must be defined

This means that you are missing a main()
Do note that Comeau C++ makes every effort to support the language features of Standard C++. Depending upon which source you are compiling, you may or may not have to enable or disable exception handling (-x, --no_exceptions), the bool data type (--bool, --no_bool), or wide-characters (--wchar_t, --no_wchar_t), etc. That said, Comeau C/C++ for Windows is in its "microsoft mode" by default.
Sometimes is it desirable to capture the output of a command. This is often done with I/O redirection, for instance:

como xyz.c > output

Here, only standard output is sent to the file named output. The problem here is that command.com does not allow redirection of standard error. In order to allow this, you may specify the -% option to como, whereas standard error is sent to wherever standard output is being sent to. Consider:

como -% xyz.c > output

In this case, all diagnostics are sent to the file named output. We should also note that NT's command processor cmd.exe does allow redirection of standard error. As well, note that in a .BAT file that % is a special character, therefore in a .bat file you need to use -%%.
Some source files may produce warnings that you may want to silence. To get rid of a specific diagnostic specify these to como:
1. First, do a run and specify --display_error_number. On a respective diagnostic, it might show #123-D, so the error number would be 123.
2. Then, use that number to suppress the diagnostic, using --diag_suppress, for instance, --diag_suppress=123
For older versions of Comeau C++, the plnm4238.exe file found in the \YourComeauDir\bin should be renamed to pnm4238.exe.
As with when you use Microsoft VC++'s cl by itself, your compile using Comeau C++ may produce the following linker diagnostic:

LINK : fatal error LNK1104: cannot open file "LIBC.lib"

This means that you need to provide a definition for your MSVC++ LIB environment variable, which is needed to point at the MSVC++ library path. This is necessary for using a routine from Standard C, such as printf.
If you have MSVC++ 6.0 you will probably have problems with <winnt.h>, so we would like to describe a procedure to circumvent that:
- Copy winnt.h into the include directory of your Comeau installation.
- cd into the include directory of your Comeau installation.
- Edit the copy (make sure you don't edit the original!) and look for the line which says "re-enable below", it should be a comment on a pragma.
- Note three routines: Int64ShllMod32, Int64ShraMod32 and Int64shrlMod32 that MS provices as asm inline function definitions.
- Note also that at the end of the three function definitions is another pragma.
- Change that block of code to this:
```
#ifdef __COMO__

#define Int64ShllMod32(v, s) ((DWORDLONG)(v) << (s))
#define Int64ShraMod32(v, s) ((LONGLONG)(v) >> (s))
#define Int64ShrlMod32(v, s) ((DWORDLONG)(v) >> (s))

#else

/* The original code block here, from the pragma to the pragma */

#endif
```
- Save the file
This essentially hijacks the real winnt.h and replaces it with a "shadow" version which will get seen instead of the real one. This effect only take place when using como, as when using VC++, the real one is still used.
Use of the assert macro ends up internally requiring void * arguments, which isn't right in strict mode, so you may also want to copy <assert.h> into the include directory of your Comeau installation. The modification here would be to change the declaration of _assert to look like this:
```
_CRTIMP void __cdecl _assert(const char *, const char *, unsigned);
```
Some additions to como.exe are enumerated below:
- November 12 additions:
  - Appropriate diagnostics when a process cannot be executed.
- November 17 additions:
  - For transparent compatibility, if certain environment variable's values starts with a double quote, then that quote, and a possibly matching ending double quote, are removed from the value (this occurs within como only).
  - For transparent compatibility, if certain environment variable's values is used in a path name of a command to be executed, and it contains so-called forward slashes, then they are changed into backward slashes (this occurs within como only).
- May 16 additions:
  - The full path names of files being compiled may now be used on the command line. The previous version required you to be in the same directory as the file.
- July 2001 additions (version 4.2.45.2b)
  - An enhancement to template instantiation, fixing an instantiation loop
  - A fix to re-allow debugging using the MS debugger (recognizing /Zi etc)
  - A fix in the code that allows spaces in environment variables and command line options
  - Environment variables may now end in a \
  - Recognizing environment variables beginning with COMO_
Have you found a glitch in Comeau C++? No matter how small, please contact us at support@comeaucomputing.com.

Comeau Computing
91-34 120th Street
Richmond Hill, NY, 11418-3214
http://www.comeaucomputing.com
support@comeaucomputing.com

Last updated August 15, 2001
(c) © 1992-2001 Comeau Computing. All Rights Reserved.