> I used to own the CCS compiler.  Don't buy it either.
>
> It has been replaced by the HiTech compiler, which will "any day now"
> support the 16-bit devices.  I've been using it since August and love it.

What do you mean "it has been replaced by"?  No offense to HiTech, but for
many applications the CCS compiler works fine.  I haven't used the HiTech
outside of some beta testing, but could readily believe that it's superior
to CCS in essentially every way except price (and the user interface which
I at least like better on CCS).  For professional programmers, it may well
be that the extra $400 invested in HiTech is worthwhile.  On the other hand,
there is definitely a place in the market for a decent $100 compiler, and
IMHO the CCS compiler fills that role quite nicely.  It's not perfect, but
it's fast, convenient, and reliable at handling 8 and 16 bit unsigned maths
and parameter passing (it's also supported floating point and signed math
for awhile; I've gotten so used to coding for unsigned that I've not had
need to try out these new features so I can't comment on them).  I've found
that it has allowed me to do projects much faster than would have been
possible in assembly language alone, and adapting programs to fit customer
needs was FAR easier than had I used assembly language (tell me how to write
an expression evaluation routine like:

/*** NOTE: This is pretty close to an actual routine I wrote for a certain
     job.  The calculations are changed slightly, and the variable names
     are all different, but the approximate complexity is comparable.
****/

/* ui is a typedef for a 16-bit unsigned integer */

/* This routine computes mum( (measure1-base1)/(measure2-base2) ), checking
   to ensure all values are within acceptable ranges.  The reciprocol func-
   tion computes 2^24/x.
*/

ui result(ui measure1, ui measure2)
{
  ui foo,bar,boz;

  if (measure2 > base2)
  {
    foo = (measure1-base1)
    bar = (measure2-base2)
    if (foo >= 256 && foo < 4095)
    {
      boz = foo*recip(bar);
      if (boz < 4095)
        return mum(boz);
      else
        return 0xFFFF;
    }
    else
      return 0xFFFE;
  }
  else
    return 0xFFFF;
}

Certainly  it would be possible for me to code something like that in PIC
assembly language; changing the formulae, however, to add temperature comp-
ensation would have been a nightmare.  In C, however, adding the temperature
compensation was a relative piece of cake (the toughest part was writing a
square-root routine).

Perhaps professionals would better spend their time on a fancier compiler;
at the time I got CCS it was probably the best one out there.  Since that
time, the CCS compiler has improved, and I've gotten better at anticipating
and avoiding constructs that might cause problems.  With the newer versions
such anticipation/avoidance may no longer be so necessary, but for me it's
so instinctive it's hard to judge what the learning curve would be for a new
user.