"far" type specifiar

[Prescott K. Turner]

In article <6347 at cup.portal.com> Paul_L_Schauble at cup.portal.com writes:
>Here's another request. I just had a go around with 'far' in Microsoft C.
>Could one of the wizards please post a description of how const, volatile,
>&c work in declarations?

The first confusing thing about Microsoft C's keywords near, far, etc. is the
terminology with which they are documented.  "Far" used in "far int" means
the int data object is allocated to far storage.  But when used in
"far pointer" it does NOT mean that the pointer data object is allocated to
far storage, it means that the object POINTED TO can be allocated to far
storage.  So to be clear, I prefer to say "pointer to far data" or
"far-allocated pointer" and avoid "far pointer" which has an ambiguous
tendency.

Microsoft C's syntax is not so bad as to share this ambiguity.  Its problem
is that the syntax for C++'s "const" type specifier works differently than
"far", and that ANSI incorporated "const".  "Const" tends to group to the
left, while "far" is grouped with things to its right.  Since Microsoft C is
staying compatible with earlier releases while adopting ANS extensions,
users will have to keep in mind both ways of using type specifiers.

My examples will use "far" and "const".  "Near" and "huge" work as "far".
"Volatile" works as "const".

Microsoft C rules:
   1. Given a declaration of some data object x, replacing x with
      (far x) declares that x is allocated in "far" storage.
   2. Given a declaration where "*" is used to indicate a pointer
      type, replacing "*" with "far *" indicates that the object
      pointed to may be allocated in "far" storage.
ANS C rules:
   1. Given a declaration where "*" is used to indicate a pointer
      type, replacing "*" with "* const" indicates that the pointer
      itself is unmodifiable.
   2. (Take a deep breath.)  Given a declaration of the form
            declaration-specifiers declarator;
      the declaration specifiers indicate some base type.
      The object declared either has that type, is a pointer
      to that type, an array of that type, or some such thing.
      Then adding "const" to the list of declaration specifiers
      says respectively that the object is unmodifiable, the
      object pointed to is unmodifiable, the array elements are
      unmodifiable, or some such thing.  For example, given
            int (*p)[3];
      declaring a pointer to an array of 3 integers, both
            int const (*p)[3];
            const int (*p)[3];
      declare a pointer to an array of 3 unmodifiable integers.

Examples:

Microsoft C pointer to far-allocated data:
      int far * p;
      int (far * p);    /* int far (* p);    is a syntax error */
ANS C pointer to unmodifiable data:
      int const * p;
      int const (* p);  /* int (const * p);  is a syntax error */
Microsoft C far-allocated pointer to ordinary data:
      int * far p;
      int (* far p);
      int * (far p);    /* int * far (p);    is a syntax error */
ANS C unmodifiable pointer to ordinary data:
      int * const p;
      int (* const p);
      int * const (p);  /* int * (const p);  is a syntax error */

It's not easy for Microsoft C to support both of these kinds of type
specifiers in combination.  Actually, there is a bug in the ANS support,
since Microsoft C indicates a syntax error for
      int (* const (* p));
which in ANS C declares a pointer to an unmodifiable pointer to an int.
--
Prescott K. Turner, Jr.
Software Development Technologies, Inc.
375 Dutton Rd., Sudbury, MA 01776 USA        (617) 443-5779
UUCP:genrad!mrst!sdti!turner