INTRODUCTION



languages among systems programmers. It is "the" language used on
and by the UNIX operating system, which appears to have the inside
track on being the replacement for CP/M on the largest
microcomputers (e.g., those based on 68000 and other more advanced
processors).
     C, somewhat like Forth, is fairly intimately tied to the machine
level. For example, there are operators in C which will increment or
decrement a memory location, just as there are such instructions in the
assembly language of most modern microprocessors.
     Unlike Forth, however, C requires the user to declare that he/she
is going beyond the scope of the language structures in order to
"cheat" and access the machine level directly. In standard C (i.e., as
found on UNIX), we could change the current cursor row via
something like this:

     *((char *) 84) = V;

     Which, I suppose, is just as cryptic as Forth to the uninitiated. If
you remember that parentheses imply precedence, just as in BASIC,
you could read the above as "Use the expression '84' as a pointer to a
character (i.e., the address of a byte--specified by 'char*') and store
V ('=') indirectly (the first '*') into that location." Whew! Even
experienced C users (well, some of us) often find themselves putting in
extra parentheses to be sure the expression means what they want it to.
     Anyway, that '(char *)' is called "type casting" and is a feature of
more advanced C compilers than those available for the Atari. But, to
be fair, it is really a poor way of doing the job, anyway. So let's do it
"right":

     Problem 1.
        char *pc; /* Pc is a pointer to a byte */
        int *pi; /* pi is a pointer to a double byte */
        pc = 84; pi = 85;
        ...
        *pc = V; *pi = H;

     Problem 2.
        char *pc;
        int *pi;
        pc = 84 ; pi = 85;
        ...
        V = *pc; H = *pi;

     As with the Pascal solutions, in the following section, we must
declare the "type" of a variable, rather than simply assuming its
existence (as in BASIC) or declaring its existence (as in Forth). The
theory is that this will let the compiler detect more logic errors, since
you aren't supposed to do the wrong thing with the wrong variable
type. (In practice, the C compilers available for the Atari, including