Ben Wing <ben(a)666.com&gt; writes: Hi! reinterpret_cast would be the one, I guess. Eg, have a look at http://www.cs.rpi.edu/~wiseb/xrds/ovp3-1.html norbert.

Ben> What I don't want is to be able to pass one of them to a Ben> function expecting the other -- but it *should* be possible Ben> with an explicit cast, e.g. (Bytecount) x. Problem is, the Ben> "cast operator" that can be defined on a class seems to Ben> define implicit casts, not explicit. Is there any way to do Ben> what I want? I think this just wins as long as you make "just enough" effort. Make user-defined conversions between ints and *counts, back and forth, but _not_ between Bytecount and Charcount. This program does what you want under g++ 2.95.4: ------------------------------- cut ------------------------------- typedef long int EMACSINT; // I don't think these can be typedefs of instances of a common template // class (they'd be the same class, then). Too lazy to try. But you could // get the effect you want with a macro, of course. class Charcount { EMACSINT data; public: Charcount (EMACSINT i) { data = i; } operator EMACSINT () { return data; } }; class Bytecount { EMACSINT data; public: Bytecount (EMACSINT i) { data = i; } operator EMACSINT () { return data; } }; extern void f (Bytecount b); int main () { Charcount c = 1; f (Bytecount (c)); // wins, but ... f (c); // *loses* } ------------------------------- cut ------------------------------- The second call to f() loses because the interpretation must be f (Bytecount (Charcount::operator int (c))); which is rejected because both user-defined conversions are implicit. The error is test.cc:22: conversion from `Charcount' to non-scalar type `Bytecount' requested There is an arbitrary restriction to at most one *implicit* user-defined conversion in a conversion chain. The first call f (Bytecount (c)); however, *wins* because now only the call to Charcount::operator int is implicit. Note, I don't have anything more recent than about 10 years old at hand, either (Stroustrup and Ellis, 1e, and it's at home, to boot, so everything above is ISTR). So you should check with a more recent version of the standard (eg, Buchholz [2002] :^) to be sure. Not to mention the compiler ;-) -- Institute of Policy and Planning Sciences http://turnbull.sk.tsukuba.ac.jp University of Tsukuba Tennodai 1-1-1 Tsukuba 305-8573 JAPAN Don't ask how you can "do" free software business; ask what your business can "do for" free software.

Ben Wing wrote: There's also a 3rd edition, which is not just newer but IMHO generally better... AFAIK that's a language-pushing C++ problem which appears quite often; I don't think there's any "best" solution (which is also typical :-) ), but you can get close... OK, the following should do it: === cut === #include <iostream> class Charcount; class Bytecount { public: Bytecount(int v):value(v) { } explicit Bytecount(Charcount cc); int toInt() { return value; } private: int value; }; class Charcount { public: Charcount(int v) { value = v ;} explicit Charcount(Bytecount bc):value(bc.toInt()) { } int toInt() { return value; } private: int value; }; Bytecount::Bytecount(Charcount cc): value(cc.toInt()) { } void f(Bytecount bc) { std::cout << bc.toInt() << std::endl; } void g(Charcount cc) { std::cout << cc.toInt() << std::endl; } int main() { Bytecount bc = 1; Charcount cc(2); f(3); g(4); f(bc); // f(cc); will not compile f((Bytecount)cc); g(cc); // g(bc); will not compile g((Charcount)bc); } === end cut === You don't use cast operators, but conversion constructors (or whatever they're called), which *can* be made explicit. Bye Vasek

thanks everybody. i got the stuff working, but with a lot of hassle. the biggest problem is that C++ doesn't clearly differentiate bool from int. Thus, a statement like while (len--) requires an operator bool(), but that really just introduces implicit conversions to int, which leads to huge numbers of ambiguities, major yuck. to avoid all the ambiguities and other problems, i had to end up declaring both the operations i wanted allowed [as public], and those i wanted disallowed [as private] -- and i mean *ALL* of them -- short, unsigned short, int, unsigned int, long, unsigned long, etc. etc. etc. to avoid these dreaded ambiguities. what a major hassle -- and clearly this needs to be rethought somewhat in the C++ design so that things like this are easier to create. Jan Vroonhof wrote:

Neal D. Becker wrote: #if !defined (__cplusplus) || !defined (CPLUSPLUS_INTEGRAL_CLASSES_NOT_YET) /* Counts of bytes or chars */ typedef EMACS_INT Bytecount; typedef EMACS_INT Charcount; /* Different ways of referring to a position in a buffer. We use the typedefs in preference to 'EMACS_INT' to make it clearer what sort of position is being used. See text.c for a description of the different positions. Note that buffer positions are 1-based, and there's a gap in the middle of a buffer; that's why we have separate typedefs. For Lisp strings and other strings of text, we just use Bytecount and Charcount. */ typedef EMACS_INT Charbpos; typedef EMACS_INT Bytebpos; typedef EMACS_INT Membpos; /* Different ways of referring to a position that can be either in a buffer or string; used when passing around an object that can be either a buffer or string, and an associated position. Conceptually, they resolve as follows: Typedef Buffer String ------------------------------------------------------ Charxpos Charbpos Charcount Bytexpos Bytebpos Bytecount Memxpos Membpos Bytecount */ typedef EMACS_INT Charxpos; typedef EMACS_INT Bytexpos; typedef EMACS_INT Memxpos; #else /* __cplusplus */ /* Implement strong type-checking of the above integral types by declaring them to be classes and using operator overloading. Unfortunately this is a huge pain in the ass because C++ doesn't strongly distinguish "bool" and "size_t" from int. The problem is especially bad with "bool" -- if you want to be able to say 'if (len--)' where len is e.g. a Bytecount, you need to declare a conversion operator to bool(); and since bool is just an alias for int, you suddenly get tons and tons of ambiguities, which need to be resolved by lots of laborious declarations for every single possible type combination. Hence the multitude of declarations in DECLARE_INTCLASS_ARITH_COMPARE(). The bool/int equivalence also means that we have to forcibly block the combinations we don't want by creating overloaded versions of them and declaring them private. */ #undef class #undef this class Bytecount; class Bytebpos; class Bytexpos; class Charcount; class Charbpos; class Charxpos; class Membpos; class Memxpos; /* Declare the arithmetic and comparison operations for an integral class, i.e. one of the above classes. If this is a "position" class, where the difference between two positions is a different class (a "count" class), then use POSCL for the position class and COUNTCL for the count class. If this is a simple class, where all operations yield the same class, substitute the same class for POSCL and COUNTCL. */ #define DECLARE_INTCLASS_ARITH_COMPARE(poscl, countcl) \ poscl operator += (const countcl& l) { data += l.data; return *this; } \ poscl operator -= (const countcl& l) { data -= l.data; return *this; } \ poscl operator + (const countcl& l) const { return poscl (data + l.data); } \ poscl operator - (const countcl& l) const { return poscl (data - l.data); } \ poscl operator += (const int& l) { data += l; return *this; } \ poscl operator -= (const int& l) { data -= l; return *this; } \ poscl operator + (const int& l) const { return poscl (data + l); } \ poscl operator - (const int& l) const { return poscl (data - l); } \ poscl operator += (const unsigned int& l) { data += l; return *this; } \ poscl operator -= (const unsigned int& l) { data -= l; return *this; } \ poscl operator + (const unsigned int& l) const \ { return poscl (data + l); } \ poscl operator - (const unsigned int& l) const \ { return poscl (data - l); } \ poscl operator += (const long& l) { data += l; return *this; } \ poscl operator -= (const long& l) { data -= l; return *this; } \ poscl operator + (const long& l) const { return poscl (data + l); } \ poscl operator - (const long& l) const { return poscl (data - l); } \ poscl operator += (const unsigned long& l) { data += l; return *this; } \ poscl operator -= (const unsigned long& l) { data -= l; return *this; } \ poscl operator + (const unsigned long& l) const \ { return poscl (data + l); } \ poscl operator - (const unsigned long& l) const \ { return poscl (data - l); } \ poscl operator += (const short& l) { data += l; return *this; } \ poscl operator -= (const short& l) { data -= l; return *this; } \ poscl operator + (const short& l) const { return poscl (data + l); } \ poscl operator - (const short& l) const { return poscl (data - l); } \ poscl operator += (const unsigned short& l) { data += l; return *this; } \ poscl operator -= (const unsigned short& l) { data -= l; return *this; } \ poscl operator + (const unsigned short& l) const \ { return poscl (data + l); } \ poscl operator - (const unsigned short& l) const \ { return poscl (data - l); } \ \ poscl operator *= (const countcl& l) { data *= l.data; return *this; } \ poscl operator /= (const countcl& l) { data /= l.data; return *this; } \ poscl operator * (const countcl& l) const { return poscl (data * l.data); } \ poscl operator / (const countcl& l) const { return poscl (data / l.data); } \ poscl operator *= (const int& l) { data *= l; return *this; } \ poscl operator /= (const int& l) { data /= l; return *this; } \ poscl operator * (const int& l) const { return poscl (data * l); } \ poscl operator / (const int& l) const { return poscl (data / l); } \ poscl operator *= (const unsigned int& l) { data *= l; return *this; } \ poscl operator /= (const unsigned int& l) { data /= l; return *this; } \ poscl operator * (const unsigned int& l) const { return poscl (data * l); } \ poscl operator / (const unsigned int& l) const { return poscl (data / l); } \ poscl operator *= (const long& l) { data *= l; return *this; } \ poscl operator /= (const long& l) { data /= l; return *this; } \ poscl operator * (const long& l) const { return poscl (data * l); } \ poscl operator / (const long& l) const { return poscl (data / l); } \ poscl operator *= (const unsigned long& l) { data *= l; return *this; } \ poscl operator /= (const unsigned long& l) { data /= l; return *this; } \ poscl operator * (const unsigned long& l) const \ { return poscl (data * l); } \ poscl operator / (const unsigned long& l) const \ { return poscl (data / l); } \ poscl operator *= (const short& l) { data *= l; return *this; } \ poscl operator /= (const short& l) { data /= l; return *this; } \ poscl operator * (const short& l) const { return poscl (data * l); } \ poscl operator / (const short& l) const { return poscl (data / l); } \ poscl operator *= (const unsigned short& l) { data *= l; return *this; } \ poscl operator /= (const unsigned short& l) { data /= l; return *this; } \ poscl operator * (const unsigned short& l) const \ { return poscl (data * l); } \ poscl operator / (const unsigned short& l) const \ { return poscl (data / l); } \ \ poscl operator &= (const countcl& l) { data &= l.data; return *this; } \ poscl operator |= (const countcl& l) { data |= l.data; return *this; } \ poscl operator & (const countcl& l) const { return poscl (data & l.data); } \ poscl operator | (const countcl& l) const { return poscl (data | l.data); } \ poscl operator &= (const int& l) { data &= l; return *this; } \ poscl operator |= (const int& l) { data |= l; return *this; } \ poscl operator & (const int& l) const { return poscl (data & l); } \ poscl operator | (const int& l) const { return poscl (data | l); } \ poscl operator &= (const unsigned int& l) { data &= l; return *this; } \ poscl operator |= (const unsigned int& l) { data |= l; return *this; } \ poscl operator & (const unsigned int& l) const { return poscl (data & l); } \ poscl operator | (const unsigned int& l) const { return poscl (data | l); } \ poscl operator &= (const long& l) { data &= l; return *this; } \ poscl operator |= (const long& l) { data |= l; return *this; } \ poscl operator & (const long& l) const { return poscl (data & l); } \ poscl operator | (const long& l) const { return poscl (data | l); } \ poscl operator &= (const unsigned long& l) { data &= l; return *this; } \ poscl operator |= (const unsigned long& l) { data |= l; return *this; } \ poscl operator & (const unsigned long& l) const \ { return poscl (data & l); } \ poscl operator | (const unsigned long& l) const \ { return poscl (data | l); } \ poscl operator &= (const short& l) { data &= l; return *this; } \ poscl operator |= (const short& l) { data |= l; return *this; } \ poscl operator & (const short& l) const { return poscl (data & l); } \ poscl operator | (const short& l) const { return poscl (data | l); } \ poscl operator &= (const unsigned short& l) { data &= l; return *this; } \ poscl operator |= (const unsigned short& l) { data |= l; return *this; } \ poscl operator & (const unsigned short& l) const \ { return poscl (data & l); } \ poscl operator | (const unsigned short& l) const \ { return poscl (data | l); } \ \ poscl operator - () { return poscl (-data); } \ poscl operator-- () { data--; return *this; } \ poscl operator-- (int) { data--; return poscl (data + 1); } \ poscl operator++ () { data++; return *this; } \ poscl operator++ (int) { data++; return poscl (data - 1); } \ \ bool operator < (const poscl& l) const { return data < l.data; } \ bool operator <= (const poscl& l) const { return data <= l.data; } \ bool operator > (const poscl& l) const { return data > l.data; } \ bool operator >= (const poscl& l) const { return data >= l.data; } \ bool operator == (const poscl& l) const { return data == l.data; } \ bool operator != (const poscl& l) const { return data != l.data; } \ bool operator < (const int& l) const { return data < (EMACS_INT) l; } \ bool operator <= (const int& l) const { return data <= (EMACS_INT) l; } \ bool operator > (const int& l) const { return data > (EMACS_INT) l; } \ bool operator >= (const int& l) const { return data >= (EMACS_INT) l; } \ bool operator == (const int& l) const { return data == (EMACS_INT) l; } \ bool operator != (const int& l) const { return data != (EMACS_INT) l; } \ bool operator < (const unsigned int& l) const \ { return data < (EMACS_INT) l; } \ bool operator <= (const unsigned int& l) const \ { return data <= (EMACS_INT) l; } \ bool operator > (const unsigned int& l) const \ { return data > (EMACS_INT) l; } \ bool operator >= (const unsigned int& l) const \ { return data >= (EMACS_INT) l; } \ bool operator == (const unsigned int& l) const \ { return data == (EMACS_INT) l; } \ bool operator != (const unsigned int& l) const \ { return data != (EMACS_INT) l; } \ bool operator < (const long& l) const { return data < (EMACS_INT) l; } \ bool operator <= (const long& l) const { return data <= (EMACS_INT) l; } \ bool operator > (const long& l) const { return data > (EMACS_INT) l; } \ bool operator >= (const long& l) const { return data >= (EMACS_INT) l; } \ bool operator == (const long& l) const { return data == (EMACS_INT) l; } \ bool operator != (const long& l) const { return data != (EMACS_INT) l; } \ bool operator < (const unsigned long& l) const \ { return data < (EMACS_INT) l; } \ bool operator <= (const unsigned long& l) const \ { return data <= (EMACS_INT) l; } \ bool operator > (const unsigned long& l) const \ { return data > (EMACS_INT) l; } \ bool operator >= (const unsigned long& l) const \ { return data >= (EMACS_INT) l; } \ bool operator == (const unsigned long& l) const \ { return data == (EMACS_INT) l; } \ bool operator != (const unsigned long& l) const \ { return data != (EMACS_INT) l; } \ bool operator < (const short& l) const { return data < (EMACS_INT) l; } \ bool operator <= (const short& l) const { return data <= (EMACS_INT) l; } \ bool operator > (const short& l) const { return data > (EMACS_INT) l; } \ bool operator >= (const short& l) const { return data >= (EMACS_INT) l; } \ bool operator == (const short& l) const { return data == (EMACS_INT) l; } \ bool operator != (const short& l) const { return data != (EMACS_INT) l; } \ bool operator < (const unsigned short& l) const \ { return data < (EMACS_INT) l; } \ bool operator <= (const unsigned short& l) const \ { return data <= (EMACS_INT) l; } \ bool operator > (const unsigned short& l) const \ { return data > (EMACS_INT) l; } \ bool operator >= (const unsigned short& l) const \ { return data >= (EMACS_INT) l; } \ bool operator == (const unsigned short& l) const \ { return data == (EMACS_INT) l; } \ bool operator != (const unsigned short& l) const \ { return data != (EMACS_INT) l; } \ bool operator ! () const { return !data; } /* Declare the "bad" or disallowed arithmetic and comparion operations between class GOOD and class BAD. Meant to go inside the private section of class GOOD. */ #define DECLARE_BAD_INTCLASS_ARITH_COMPARE(good, bad) \ good operator += (const bad& l) { return badret; } \ good operator -= (const bad& l) { return badret; } \ good operator *= (const bad& l) { return badret; } \ good operator /= (const bad& l) { return badret; } \ good operator + (const bad& l) { return badret; } \ good operator - (const bad& l) { return badret; } \ good operator * (const bad& l) { return badret; } \ good operator / (const bad& l) { return badret; } \ \ bool operator < (const bad& l) { return 0; } \ bool operator <= (const bad& l) { return 0; } \ bool operator > (const bad& l) { return 0; } \ bool operator >= (const bad& l) { return 0; } \ bool operator == (const bad& l) { return 0; } \ bool operator != (const bad& l) { return 0; } /* Declare the "bad" or disallowed arithmetic operations between class GOOD and another of the same class, for a position class. Meant to go inside the private section of class GOOD. */ #define DECLARE_BAD_POS_CLASS_ARITH(good) \ good operator += (const good& l) { return badret; } \ good operator -= (const good& l) { return badret; } \ good operator *= (const good& l) { return badret; } \ good operator /= (const good& l) { return badret; } \ good operator + (const good& l) { return badret; } \ good operator * (const good& l) { return badret; } \ good operator / (const good& l) { return badret; } /* Basic declaration at the top of all integral classes. Don't call directly, use one of the more specific versions below. */ #define DECLARE_INTCLASS(cl) \ public: \ EMACS_INT data; \ cl () { data = 0xCDCDCDCD; } \ cl (int i) { data = i; } \ cl (unsigned int i) { data = i; } \ cl (long i) { data = i; } \ cl (unsigned long i) { data = i; } \ cl (short i) { data = i; } \ cl (unsigned short i) { data = i; } \ operator EMACS_INT () const { return data; } /* Basic declaration at the top of all count classes. */ #define DECLARE_COUNT_CLASS(cl) \ DECLARE_INTCLASS (cl) \ DECLARE_INTCLASS_ARITH_COMPARE (cl, cl) \ private: \ static cl badret; /* Basic declaration at the bottom of the prelude of all position classes. Don't call directly. */ #define DECLARE_POS_CLASS_SECOND_HALF(cl, countcl) \ DECLARE_INTCLASS_ARITH_COMPARE (cl, countcl) \ countcl operator - (const cl& l) const { return countcl (data - l.data); } \ private: \ static cl badret; \ DECLARE_BAD_POS_INTCLASS_ARITH (cl) /* Basic declaration at the top of all buffer position classes. */ #define DECLARE_BPOS_CLASS(cl, countcl) \ DECLARE_INTCLASS (cl) \ DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) /* Basic declaration at the top of all X-position classes (that can refer to buffers or strings). CL1 and CL2 are the equivalent more specific classes referring only to buffers or strings, respefitvely. */ #define DECLARE_XPOS_CLASS(cl, countcl, cl1, cl2) \ DECLARE_INTCLASS (cl) \ cl (const cl1& x) { data = x.data; } \ cl (const cl2& x) { data = x.data; } \ operator cl1 () const { return cl1 (data); } \ operator cl2 () const { return cl2 (data); } \ DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) /* Declare the "bad" or disallowed arithmetic and comparion operations between class CHARCL (a character class) and various non-character classes. Meant to go inside the private section of class GOOD. */ #define DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE(charcl) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytecount) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytebpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytexpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Membpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Memxpos) /* Declare the "bad" or disallowed arithmetic and comparion operations between class BYTECL (a byte class) and various non-byte classes. Meant to go inside the private section of class GOOD. */ #define DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE(bytecl) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Membpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Memxpos) /* Declare the "bad" or disallowed arithmetic and comparion operations between class BYTECL (a mem class) and various non-mem classes. Meant to go inside the private section of class GOOD. */ #define DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE(bytecl) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytebpos) \ DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytexpos) class Charcount { DECLARE_COUNT_CLASS (Charcount) DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charcount) }; class Charbpos { DECLARE_BPOS_CLASS (Charbpos, Charcount) DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charbpos) }; class Charxpos { DECLARE_XPOS_CLASS (Charxpos, Charcount, Charbpos, Charcount) DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charxpos) }; class Bytecount { DECLARE_COUNT_CLASS (Bytecount) DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytecount) }; class Bytebpos { DECLARE_BPOS_CLASS (Bytebpos, Bytecount) DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytebpos) }; class Bytexpos { DECLARE_XPOS_CLASS (Bytexpos, Bytecount, Bytebpos, Bytecount) DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytexpos) }; class Membpos { DECLARE_BPOS_CLASS (Membpos, Bytecount) DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Membpos) }; class Memxpos { DECLARE_XPOS_CLASS (Memxpos, Bytecount, Membpos, Bytecount) DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Memxpos) }; #define DECLARE_POINTER_TYPE_ARITH_COUNT(pointer, countcl) \ inline pointer operator += (const pointer & x, const countcl& y) \ { x += y.data; return x; } \ inline pointer operator -= (const pointer & x, const countcl& y) \ { x -= y.data; return x; } \ inline pointer operator + (const pointer x, const countcl& y) \ { return x + y.data; } \ inline pointer operator - (const pointer x, const countcl& y) \ { return x - y.data; } #define DECLARE_INTEGRAL_TYPE_ARITH_COUNT(integral, countcl) \ inline integral operator += (integral & x, const countcl& y) \ { x += y.data; return x; } \ inline integral operator -= (integral & x, const countcl& y) \ { x -= y.data; return x; } \ inline countcl operator + (integral x, const countcl& y) \ { return countcl (x + y.data); } \ inline countcl operator - (integral x, const countcl& y) \ { return countcl (x - y.data); } #define DECLARE_INTEGRAL_TYPE_COMPARE(integral, cl) \ inline bool operator < (integral x, const cl& y) \ { return (EMACS_INT) x < y.data; } \ inline bool operator <= (integral x, const cl& y) \ { return (EMACS_INT) x <= y.data; } \ inline bool operator > (integral x, const cl& y) \ { return (EMACS_INT) x > y.data; } \ inline bool operator >= (integral x, const cl& y) \ { return (EMACS_INT) x >= y.data; } \ inline bool operator == (integral x, const cl& y) \ { return (EMACS_INT) x == y.data; } \ inline bool operator != (integral x, const cl& y) \ { return (EMACS_INT) x != y.data; } #if 0 /* Unfortunately C++ doesn't let you overload the ?: operator, so we have to manually deal with ambiguities using casting */ #define DECLARE_INTEGRAL_TYPE_TRISTATE(integral, cl) \ inline cl operator ?: (bool b, integral x, const cl& y) \ { return b ? cl (x) : y; } \ inline cl operator ?: (bool b, const cl& x, integral y) \ { return b ? x : cl (y); } #endif /* 0 */ /* DECLARE_POINTER_TYPE_ARITH_COUNT (const Intbyte *, Bytecount); DECLARE_POINTER_TYPE_ARITH_COUNT (const Extbyte *, Bytecount); */ DECLARE_POINTER_TYPE_ARITH_COUNT (Intbyte *, Bytecount); DECLARE_POINTER_TYPE_ARITH_COUNT (Extbyte *, Bytecount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Bytecount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Charcount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Bytecount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Charcount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Bytecount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Charcount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Bytecount); DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Charcount); DECLARE_INTEGRAL_TYPE_COMPARE (int, Bytecount); DECLARE_INTEGRAL_TYPE_COMPARE (int, Charcount); DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Bytecount); DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Charcount); DECLARE_INTEGRAL_TYPE_COMPARE (long, Bytecount); DECLARE_INTEGRAL_TYPE_COMPARE (long, Charcount); DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Bytecount); DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Charcount); #if 0 /* doesn't work */ inline Bytecount operator - (const Intbyte *x, const Intbyte *y) \ { return Bytecount (x - y); } #endif #define class c_class #define this c_this #endif /* __cplusplus */