depuydt@imec.be (Francis Depuydt) (02/09/90)
I would like to use the X11 library functions in my C++ environment. However, some keywords of C++ seem to be used for X11 variables. Are there other incompatibilities? Did some of you experience the same sort of problem, and what is the 'cheapest' solution? Francis Depuydt IMEC/VSDM Kapeldreef 75 - B3030 Belgium email: depuydt@imec.be
rfg@ics.uci.edu (Ronald Guilmette) (02/14/90)
In article <943@imec.UUCP> depuydt@imec.be (Francis Depuydt) writes: >I would like to use the X11 library functions in my C++ environment. >However, some keywords of C++ seem to be used for X11 variables. >Are there other incompatibilities? Did some of you experience the same >sort of problem, and what is the 'cheapest' solution? I have been encouraging the folks at MIT Project Athena and at the X Consortium to use my protoize and unprotoize tools to whip X11 into condition so that individual end-users could easily generate their own fully-prototyped versions of X11 (and especially its include files). There seems to some interest in doing this at both places, but that interest is tempered by resource (i.e. manpower) limitations. Regardless of that, I hope that we will all someday enjoy an "easily protoizable" version of X11. // rfg
jlv@cs.brown.edu (Jeff Vogel) (02/14/90)
In article <25D887FF.273@paris.ics.uci.edu> rfg@ics.uci.edu (Ronald Guilmette) writes: >In article <943@imec.UUCP> depuydt@imec.be (Francis Depuydt) writes: >>I would like to use the X11 library functions in my C++ environment. >>However, some keywords of C++ seem to be used for X11 variables. >>Are there other incompatibilities? Did some of you experience the same >>sort of problem, and what is the 'cheapest' solution? > I am all for some tools to let X11 compile with C++. Incidentally, how did you solve the type checking problem? Did you create your own header files with all of the X extern declarations and their parameters (or ...). Jeff Vogel | PO Box 5173 jlv@cs.brown.edu | Brown University uunet!brunix!jlv | Providence, RI 02912 jlv@browncs.bitnet | 401-863-7637, 401-421-6496
sdm@cs.brown.edu (Scott Meyers) (02/14/90)
The X11R4 header files come with C++ declarations already in them. For
example, this is from Xlib.h:
#ifdef __cplusplus /* do not leave open across includes */
extern "C" { /* for C++ V2.0 */
#endif
I don't do X programming myself, so I can't vouch for how well the new
include files work with C++ (the distribution documentation says the
support isn't part of the official standard yet), but I know at least one
person doing X programming who's used the headers with cfront 2.0 without
any problems.
Scott
sdm@cs.brown.edurfg@ics.uci.edu (Ronald Guilmette) (02/15/90)
In article <29158@brunix.UUCP> jlv@cs.brown.edu (Jeff Vogel) writes: >In article <25D887FF.273@paris.ics.uci.edu> rfg@ics.uci.edu (Ronald Guilmette) writes: >>In article <943@imec.UUCP> depuydt@imec.be (Francis Depuydt) writes: >>>I would like to use the X11 library functions in my C++ environment. >>>However, some keywords of C++ seem to be used for X11 variables. >>>Are there other incompatibilities? Did some of you experience the same >>>sort of problem, and what is the 'cheapest' solution? >> > >I am all for some tools to let X11 compile with C++. >Incidentally, how did you solve the type checking problem? >Did you create your own header files with all of the >X extern declarations and their parameters (or ...). I guess that I should have been posting my announcements of protoize & unprotoize tools to the comp.windows.x newsgroup also! Some people have obviously missed them! Let me now SHOUT so that ****** EVERYONE ON THE NET CAN HEAR ME ******* There are free tools available (called protoize & unprotoize) which are ultra intelligent tools that use information from your C code source files (that is, both "base" files *and* include files) to convert entire *large* system of K&R C source code (e.g. X11) from good old K&R C code to fully prototyped ANSI C code (or to C++ code). The protoize tool cannot possibly do a full-fledged conversion (too many nit-picking details) but it will do all necessary conversion of function declarations and definitions (in both base files and include files) to prototype format. This work constitutes the bulk of the conversion effort. Other tweeking must be done manually, but protoize can typically do better than 90% of the editing work. A critically important feature of protoize is that it obtains information to do its job from *all* of the files in a given program before it even starts its work. This allows it to do intelligent conversion of function declarations and definitions even across multiple files (and in particular into include files). For example, assume the following files: foo.h: ----------------------------------------------------------------- extern int bar (); ----------------------------------------------------------------- foo.c: ----------------------------------------------------------------- int bar (); typedef struct tricky_case *tricky_p; int bar (i, p) int i; tricky_p p; { ... } ----------------------------------------------------------------- After running protoize over these files, they come out looking like this: foo.h: ----------------------------------------------------------------- extern int bar (int i, tricky_p p); ----------------------------------------------------------------- foo.c: ----------------------------------------------------------------- int bar (int i, tricky_p p); typedef struct tricky_case *tricky_p; int bar (int i, tricky_p p) { ... } ----------------------------------------------------------------- Now you must manually move the typedef for `tricky_p' up into the include file, but there are some people (me included) who would say that good software engineering practices would make you want to do this anyway. After all, if there is a declaration of `bar' in the include file (where it is presumably needed because other files may need to make references to `bar') then by all rights, these other files will probably also need to know about the type called `tricky_p'. Anyway, as you should see from the above example, protoize is capable of automatically generating a fully prototyped set of include files for any large system of old-style (K&R) C code (e.g. X11). Of course, as I have said, there may be a bit of tweeking required afterwards to get these files back into a "legal" form. Protoize/Unprotoize use the GNU C compiler as a "front-end" information gathering tool. (Thus I didn't have to build a whole darn parser!) You must have GCC to make use of protoize/unprotoize. Protoize/Unprotoize (v1.07) are available via anonymous FTP from ics.uci.edu. look for the file protoize-1.07.Z in the ~ftp/pub directory. This is a compressed *patch* file (not a tar file). It must be applied to GCC 1.36. You then must rebuild GCC and read the supplied man pages for protoize/unprotoize. Protoize/Unprotoize 1.07 is also available via anonymous UUCP from osu-cis. I case it ain't obvious, I hope that everyone will convert to using prototypes someday real soon. // rfg