Power-Programmierung/CD2.mdf/c/compiler/micro_c/cintro.doc

Text File | 1992-02-24 | 114.3 KB | 2,498 lines

                                      An
                                 Introduction
                                      to


                                     CCC
                                    CC CC
                                   CC   CC
                                   CC
                                   CC   CC
                                    CC CC
                                     CCC


                                    Using
                             The MICRO-C Compiler










                              Revised: 14-Jan-92










                      Copyright 1989,1992 Dave Dunfield
                             All rights reserved
   Intro to MICRO-C                                                 Page: 1


   1. INTRODUCTION

         Since releasing my MICRO-C compiler in 1988, I have received  many
      requests to include information on the 'C' language as part  of  that
      package.

         This manual is intended as a companion to  the  MICRO-C  compiler,
      and presents an introduction to the 'C' language for  those  who  are
      not already familiar  with  it.  The  language  represented  is  that
      portion of 'C' which is implemented by the  MICRO-C  compiler.  Since
      MICRO-C implements a  subset  of  the  'C'  programming  language  as
      described by Kernighan and Ritchie (the original  developers  of  the
      language), you should have little difficulty  using  and  learning  a
      full 'C' compiler once you have mastered it.

         You should also refer to the  MICRO-C  technical  manual  entitled
      "MICRO-C a compact 'C' compiler for small systems" for details on the
      MICRO-C implementation.

         'C' has many inter-relationships between  its  various  constructs
      and features. I have attempted to introduce them  in  a  logical  and
      "building" manner,  however  it  is  not  always  possible  to  fully
      describe each feature before it is mentioned in  the  description  of
      some other construct. For this reason, I suggest that you  read  this
      text "lightly from cover to cover" at least once before  you  try  to
      fully understand each point.

         This is a first draft of this document. In its present form, it is
      not very easy reading, but does contain much  useful  information.  I
      will be improving and adding to it as I find the time.

         Presented herein is a brief summary of the major features  of  the
      'C' language as implemented in MICRO-C.
   Intro to MICRO-C                                                 Page: 2


   2. BACKGROUND INFORMATION

         This section provides some detailed background information for the
      novice, and may be skipped if  you  are  already  familier  with  the
      basics of  computer  architecture  and  programming  languages.  This
      information is presented  here  because  'C'  is  a  very  low  level
      language, and an understanding of these basic  principals  will  help
      you more easily understand how and why certain  constructs  work  the
      way they do.

      2.1 Computer Architecture

            The basis of any computer system is its Central Processor  Unit
         (CPU) which controls the operation  of  all  other  parts  of  the
         computer, by following a set of "instructions"  which  make  up  a
         software "program". The program is stored in "memory" and  directs
         the CPU to read and write data  to  various  "peripheral"  devices
         (Such as terminals, disks and printers), and  to  manipulate  that
         data in a matter which accomplishes  the  goals  set  out  by  the
         author of the program.

            Although there are a wide variety of CPUs available  in  modern
         computers, they are all very similar, and  feature  the  following
         characteristics:

            All data accessed by the CPU is represented by  circuits  which
         may be either OFF or ON. This is represented by the digits  0  and
         1. Since there are only two states (0 and 1), the computer may  be
         thought of as operating in a BASE 2 (Binary)  number  system,  and
         each individual data element is called a  Binary  digIT,  or  BIT.
         This BASE 2 number system is used because it  is  much  easier  to
         build and interface to electrical circuits  which  have  only  two
         states (OFF and ON) than ones which have many states.

            Since  single   BITs   cannot   represent   much   information,
         manipulating large amounts of data at the BIT  level  would  be  a
         very tedious chore. For this reason, modern CPUs  access  data  as
         groups of BITs. Usually the smallest group of data  which  can  be
         manipulated by a computer consists of 8  BITs,  and  is  called  a
         BinarY TErm (BYTE).

            Very small computers can often only access data a BYTE (8 bits)
         at a time, while  larger  machines  may  be  able  to  access  and
         manipulate data in larger groups called WORDS.  The  size  of  the
         data group usually manipulated by a CPU is  called  its  WORDSIZE,
         and is expressed in a number of bits.  This  is  almost  always  a
         multiple of 8 bits, resulting in an even number of bytes. Thus, if
         you hear a CPU or computer called a "16  bit"  machine,  you  know
         that it can access and manipulate 16 bits (2 bytes) of data  at  a
         time. A "32 bit" machine would operate on 32  bits  (4  bytes)  of
         data. In general, the larger the WORDSIZE of a CPU, the more  data
         it manipulates at one time, resulting in faster  completion  of  a
         given task.
   Intro to MICRO-C                                                 Page: 3


            The CPU has access to external "memory", which consists of many
         thousands (and often  millions)  of  WORDS  of  data.  Up  to  one
         complete word of data may  be  transferred  between  the  CPU  and
         memory in one memory access.

            Often it is known that each data element stored in memory  will
         not take up an entire word, and is it desirable to  access  memory
         in smaller groups, to reduce the number of memory  words  required
         to accomplish a particular task. For this reason, most modern CPUs
         can access any single BYTE (8 bits) from a memory word. It  should
         be understood however, that accessing a single byte causes a  full
         memory access, and takes just as much time as accessing an  entire
         word.

            In order to provide the programmer  with  a  simple  method  of
         specifying memory locations, each BYTE of memory  is  assigned  an
         ADDRESS, which is simply the number of BYTES from the beginning of
         memory to the desired byte. Therefore, the first  byte  in  memory
         has address 0, the second byte byte in memory has address  1,  the
         third byte has address 2 etc. Thus, memory from the  viewpoint  of
         the programmer may be considered  as  a  simple  array  of  BYTES,
         beginning with an address of 0,  and  continuing  with  sequential
         addresses up the memory size (in bytes) of the computer.

            In addition to the external memory, a CPU has a small amount of
         very fast internal memory which is  organized  into  words  called
         "registers". Registers act as holding places  to  store  the  data
         words which are to be manipulated. At least some of the  registers
         are internally connected to an Arithmetic Logic Unit (ALU),  which
         has the necessary electronics to perform basic operations such  as
         addition and subtraction on  the  data  in  those  registers.  The
         result of the operation is also placed in a register, often one of
         the registers which contained the original data.

            One special register called the Program Counter (PC) is used by
         the CPU to follow the software program. It contains the address of
         the next INSTRUCTION to  be  executed.  At  the  beginning  of  an
         INSTRUCTION CYCLE, the CPU reads the word of memory at the address
         which is contained in the PC, and interprets the  value  contained
         there as an operation to be performed, such as loading a  register
         from memory, storing a register  into  memory,  or  performing  an
         arithmetic operation  on  the  registers.  After  performing  that
         operation, the CPU advances the PC to the next memory word  before
         beginning another instruction cycle. In this manner,  all  of  the
         instructions in a program are read, and the programmed  operations
         are carried out.

            The CPU may also read from and  increment  the  PC  during  the
         execution of an instruction, in order to access data  bytes  which
         are OPERANDS to the particular instruction  being  executed.  Such
         would be the case if you  were  instructing  the  CPU  to  load  a
         register with the contents of a  particular  memory  address.  The
         data bytes following the  instruction  would  contain  the  memory
         address to be used.
   Intro to MICRO-C                                                 Page: 4


            There are a few instructions which direct the CPU  to  store  a
         new value in the PC, rather than  advance  it.  These  are  called
         JUMPS,  and  are  used  to  make  the  program   begin   executing
         instuctions at a different address. This can  be  used  to  create
         LOOPS in the program where a sequence of instructions is  executed
         over and over again.

            Some of the "jump" instructions will only store the  new  value
         in the PC if certain conditions are met,  such  as  the  last  ALU
         operation resulted in zero, or did not result in zero. This allows
         the program to alter  its  pattern  of  execution  based  on  data
         values.

            For example, here is a program to count to 10 on a very  simple
         imaginary computer. It shows the  use  of  IMMEDIATE  operands  to
         instructions, which are shown by [PC+], and indicate  that  during
         the execution of the instruction, the CPU  reads  the  next  value
         from the address in the PC. The PC is advanced so that that  value
         will not  be  executed  as  another  instruction  when  the  first
         instruction is finished:

             Address   Interpretation of instruction value
             ------------------------------------------------------
               [0]     Load [PC+] data byte into register1
               [1]     Data: 0
               [2]     Add [PC+] data byte to register1
               [3]     Data: 1
               [4]     Load [PC+] data byte into register2
               [5]     Data: 10
               [6]     Subtract register1 from register2
               [7]     Jump if result not zero to address in [PC+]
               [8]     Data: 2
               [9]     Halt CPU
   Intro to MICRO-C                                                 Page: 5


      2.2 Assembly Language

            In the preceeding section, you have learned how a CPU  executes
         a program, and how a program may be coded in memory as a series of
         instruction and data values. It should  be  obvious  to  you  that
         although you can create programs in this way, it would be  a  long
         and tedious job to write a program of any size using only  numeric
         values.

            Not  only  is  it  very  hard  to  remember  the  hundreds   of
         instruction  values  which  may  be  used   to   perform   certain
         operations, but managing the memory address  which  are  coded  as
         operands to the instructions becomes  a  real  headache.  This  is
         particularily true when you  change  a  portion  of  the  program,
         causing a change in the number of bytes of  memory  used  by  that
         portion, and therefore  changes  all  of  the  memory  address  of
         instructions and data which follow.

            To help ease the programming job, each of the CPU manufacturers
         have defined an ASSEMBLY LANGUAGE for their CPU, which  represents
         each of the machine operations with a more meaningful name  called
         a MNEMONIC. Similar instructions may be  grouped  under  the  same
         mnemonic with the individual instruction values determined by  the
         operands.  For  example,  it  might  be  a  completely   different
         instruction value which loads Register1 with  a  value  than  that
         which loads register2. In assembly language you would use  similar
         statements such as:

               LOAD R1,10
               LOAD R2,10

            The  translation  from  mnemonics  to  instruction  values   is
         performed by  a  program  called  an  ASSEMBLER.  In  addition  to
         performing this translation, the assembler also allows LABEL names
         to be assigned to addresses. The labels may be  referred  to  from
         within other assembly  language  statements  instead  of  absolute
         addresses.

            When written in assembly language, our "count  to  10"  program
         would look something line this:

                   LOAD    R1,0
           LOOP:   ADD     R1,1
                   LOAD    R2,10
                   SUB     R2,R1
                   JMPNZ   LOOP
                   HALT

            As  you  can  see,  the  above  program  would  be  much   more
         understandable than a series of  numbers,  but  it  is  still  not
         obvious to someone other that the author what the  intent  of  the
         program is until he has followed through the loop, and  determined
         what is accomplished by each instruction.
   Intro to MICRO-C                                                 Page: 6


            Imagine that you have just started a  new  job  as  a  computer
         programmer, and your  manager  hands  you  a  listing  of  several
         hundred pages, each of which is full of  assembly  language  lines
         looking like the example  above,  and  says  "The  'SCAN'  command
         causes corruption of the database search parameters. This is  VERY
         important, could you stay and fix it tonight". You would have many
         hours  (days?)  ahead  of  you  trying  to   determine   what   is
         accomplished by each portion of the program. Now, imagine that the
         assembly language looked more like this:

           ;
           ; Simple demonstration program to count from 0 to 9
           ;
                   LOAD    R1,0        ; Begin with count of zero
           ; Execute this loop once for each count
           COUNT:  ADD     R1,1        ; Increment count
                   LOAD    R2,10       ; Loop termination value
                   SUB     R2,R1       ; Test R1, (result destroys R2)
                   JMPNZ   COUNT       ; Repeat until we reach 10
           ; We have reached 10 - All done
                   HALT                ; Stop processing

            The text statements following the ';' characters in  the  above
         example are called COMMENTS. They are completely  ignored  by  the
         assembler, but are very useful to anyone attempting to  understand
         the program.

      2.3 High Level Languages

            As you can see in the  preceeding  section,  assembly  language
         programming offers much of  an  improvement  over  programming  by
         direct instruction  values,  while  retaining  the  capability  to
         control  EXACTLY  the  individual  operations  the  program   will
         instruct the CPU to perform. Also, since the assembly language for
         a particular CPU is defined by the manufacturer, you can  be  sure
         that using it will allow you to take advantage  of  EVERY  feature
         and capability that has been designed  into  that  particular  CPU
         architecture.

            A good assembly language programmer can produce highly efficent
         and compact programs because of this power. For  this  reason  you
         will often see assembly  language  used  for  very  time  or  size
         intensive applications.
   Intro to MICRO-C                                                 Page: 7


            It would seem that assembly language would be the ideal  method
         of  doing  all  your  programming.  There  are  however,   several
         drawbacks to using assembly language:

         1) Efficent use of assembly language often requires a  "different"
            way of  looking  at  a  problem  and  strong  "logical"  mental
            dicipline.
            ** Not everyone is a good assembly language programmer **

         2) Assembly language source files are big.
            ** It takes much codeing to perform even simple operations **
            ** Significant time is spent entering source text **
            ** Greater chance of error during design and entry **

         3) Poorly documented assembly language is undecipherable.
            ** It is hard to maintain **

         4) Each assembly language is different and incompatible.
            ** Programs will run on only one type of CPU **
            ** Programmers have difficulty working on other CPUs **

            To help solve these problems,  there  are  a  number  of  "high
         level"  programming  languages  available.  The  main   difference
         between  assembly  and  high  level  languages  is  that  assembly
         language produces only  one  CPU  instruction  for  each  language
         "statement",  while  high  level  languages   can   produce   many
         instructions for each "statement".

            High level languages attempt to provide a method of programming
         by expressing ideas, rather than by directing the CPU  to  perform
         each individual operation. When using a high level  language,  you
         are freed from the task of keeping track of  register  and  memory
         usage, and can concentrate  on  expressing  the  algorithms  which
         accomplish the goal of the program.

            Here are some "high  level"  versions  of  our  "count  to  10"
         program:


       Basic:      100 FOR I=0 TO 10:NEXT I

       Fortran:        DO 100 i=0,10
                   100 CONTINUE

       Forth:      11 0 DO LOOP

       'C':        for(i=0; i <= 10; ++i);
   Intro to MICRO-C                                                 Page: 8


      2.4 Interpreters VS Compilers

            There  are   two   basic   types   of   high   level   language
         implementations, INTERPRETERS and COMPILERS.

            An INTERPRETER is a program which reads  your  source  program,
         and performs the actions indicated by  its  statements.  The  main
         advantages to this approach are:

         1) FAST DEVELOPMENT:  Interpreters  often  include  complete  text
            editors, which make it easy to  edit  and  debug  your  program
            without leaving the interpreter. Also,  since  the  program  is
            interpreted  directly,  there  is  no  waiting  to  compile  or
            assemble it before you can try out a new change.

         2) EASY DEBUGGING:  Since  the  interpreter  is  actually  another
            program, it will usually allow you to stop your program in  the
            middle of execution, examine/modify  variables,  trace  program
            flow, display callback stacks, etc. This makes  for  very  easy
            debugging. Also, a good interpreter will perform  very  through
            checking of your program as it interpretes,  thus  finding  and
            reporting design errors which might otherwise show up  only  as
            erratic and inconsistant program operation.

            And of course, there are drawbacks to interpreting:

         1) SLOW EXECUTION: The interpreter has to process  each  statement
            in your program and determine what action is  to  be  performed
            every time it encounters that statement. Many hundreds or  even
            thousands of instructions are executed to accomplish  this  FOR
            EACH STATEMENT.

         2) USES MEMORY: A good interpreter is a  fairly  complex  program,
            and therefore occupies a substantial portion of system  memory,
            meaning that less is available for your program & variables.

         3) DIFFICULTY OF USE: Once you are finished debugging,  you  would
            like to  make  your  program,  as  easy  to  use  as  possible.
            Unfortunatly, when using an interpreter,  you  always  have  to
            load and execute the interpreter before loading  and  executing
            your program.

            These disadvantages are so severe that interpreters are  rarely
         used for serious programs which are to be  used  frequently  by  a
         number of people. They are however, excellent learning  tools  for
         the novice computer user.
   Intro to MICRO-C                                                 Page: 9


            A COMPILER is a program which reads your  source  program,  and
         translates its statements into CPU INSTRUCTIONS which perform  the
         specified function. Instead of actually executing your program, it
         converts it to a form which can later be directly executed by  the
         CPU. Its main advantages are:

         1) FAST EXECUTION: Since the program will be executed directly  by
            the CPU, it will run much faster that  the  equivalent  program
            being translated by an interpreter.

         2) LESS MEMORY: Although a compiler is a very complex program, and
            uses lots of memory when it runs,  it  only  runs  once,  after
            which your program is executed by itself directly by  the  CPU.
            This means that the amount of memory required by  the  compiler
            does not affect the amount of memory which is available for use
            by your program when it runs.

         3) EASE OF USE: Since your program executes  by  itself,  you  can
            load and execute it directly from the operating system  command
            prompt.

            The main disadvantages of compilers over interpreters are:

         1) LONGER DEVELOPMENT: Many "traditional" compilers  require  that
            you prepare your source program using a  separate  editor,  and
            then save it to a disk  file,  and  submit  that  file  to  the
            compiler. Every time you do this, you  have  to  wait  for  the
            compiler to finish before you can even try your program.  NOTE:
            some compiler vendors are  now  providing  integrated  editors,
            eliminating the "save and exit" step, however you may not  like
            the editor they have chosen for you.

         2) MORE  DIFFICULT  DEBUGGING:  Since  your  program  executes  by
            itself, you have to run a standard system debugger  to  monitor
            its execution. This will usually  be  somewhat  less  intuitive
            than an interpreters built in debugging  features.  NOTE:  some
            compiler  vendors  provide  a  "debug"  option  which  includes
            debugging information in the program, and  a  special  debugger
            which provides debugging facilities equal  to  or  better  than
            those available from most interpreters.

      2.5 Object Modules & Linking

            Most assemblers and compilers available today support  the  use
         of a LINKER. The linker is a program which  will  combine  several
         previously compiled (or assembled) programs called OBJECT  MODULES
         into a single larger executable  program.  This  helps  speed  the
         development process by eliminating  the  need  to  re-compile  the
         entire program when you have changed only one module.
   Intro to MICRO-C                                                 Page: 10


      2.6 Compiler Libraries

            Modern compilers promote  the  use  of  STRUCTURED  PROGRAMMING
         techniques, which make programs easier to debug and maintain. I do
         not propose to get into a  discussion  of  structured  programming
         methods, but the main idea is to divide the  program  into  simple
         parts, each of which performs a clearly defined function.

            Such functions often perform common algorithms required by many
         programs, and  hence  are  made  into  compiler  LIBRARIES.  These
         libraries are simply collections of small  useful  programs  which
         may be used from within your programs without you having to  write
         them. Most compiler manufacturers  provide  such  a  "library"  of
         functions which they  believe  to  be  commonly  needed,  and  the
         development tools necessary to link them with your programs.

      2.7 Portability

            One BIG advantage of high level languages is the fact that once
         a program is written and running on one CPU, you can  usually  get
         it  running  on  another  completely  different  CPU  with  little
         difficulty. This is because although the CPUs are  different,  the
         HIGH LEVEL LANGUAGE IS NOT CPU DEPENDANT AND REMAINS THE SAME. All
         you have to do is to re-compile your  program,  using  a  compiler
         which produces code for the new CPU.

            Actually, it usually takes a bit more effort than that, because
         the language or library functions may  differ  slightly  from  one
         implementation to another.

            This concept of PORTABILITY is one of the strong points of  the
         'C' language, and you will see it  mentioned  from  time  to  time
         throughout  this  manual.  In  addition  to  consistant   compiler
         language implementation, 'C' benefits from very "standard" library
         function definitions which are followed by most vendors.
   Intro to MICRO-C                                                 Page: 11


   3. INTRODUCTION TO 'C'

         'C' is a "high level" computer language,  which  has  become  very
      popular in recent years. It has proven suitable for a  large  variety
      of programming tasks, and unlike most other high level languages,  is
      quite good for "low  level"  and  "system"  type  functions.  A  good
      example of this capability is the popular  "UNIX"  operating  system,
      which is  written  almost  entirely  in  'C'.  Before  UNIX,  it  was
      generally thought that only assembly language was efficent enough for
      writing an operating system.

         Programs in 'C' are divided into two main parts, VARIABLES,  which
      are blocks of memory reserved for storing data, and FUNCTIONS,  which
      are blocks of memory containing executable CPU instructions. They are
      created using a DECLARATION STATEMENT, which is basically  a  command
      to the compiler telling it what type of variable or function you wish
      to create, and what values or instructions to place in it.

         There are several 'C' KEYWORDS which serve to inform the  compiler
      of the size and type of a variable or function. This  information  is
      used by the compiler to determine how to interpret the  value  STORED
      in a VARIABLE, or RETURNED by a FUNCTION.

       Size:   int         - 16 bit value (default)
               char        - 8 bit value
       type:   unsigned    - Positive only (0-2**bits)
                           + Default is signed (positive & negative)

       Examples:   int a;              /* 16 bit signed variable */
                   char b;             /* 8 bit signed variable */
                   unsigned int c;     /* 16 bit unsigned variable */
                   unsigned d;         /* Also 16 bit unsigned variable */
                   unsigned char e;    /* 8 bit unsigned variable */

         Normally, when you define a function or global variable, its  name
      is made accessable to all object modules which will  be  linked  with
      the program. You may access a  name  which  is  declared  in  another
      module by  declaring  it  in  this  module  with  with  the  "extern"
      modifier:

          extern int a;       /* external variable of type int    */
          extern char b();    /* external function returning char */

         If you want to make sure that a function or global  variable  that
      you are declaring is not accessable to  another  module  (To  prevent
      conflicts with names in other modules etc), you can declare  it  with
      the "static" modifier. This causes the name to be accessable only  by
      functions within the module containing the "static" declaration:

                                static int a;
   Intro to MICRO-C                                                 Page: 12


      3.1 Functions

            FUNCTIONS in 'C' are  collections  of  C  language  STATEMENTS,
         which are grouped together under a name. Each statement represents
         an operation which is to be performed by the CPU. For example, the
         statement:

                                  A = A + 1;

         directs the CPU to read the variable called 'A', add a value of  1
         to it, and to store the result back into the variable  'A'  (we'll
         discuss variables in the next section). Note the  SEMICOLON  (';')
         at the end  of  the  statement.  The  'C'  compiler  uses  ';'  to
         determine when the statement ends. It does not care about lines or
         spaces. For example, the above statement could also be written:

                                      A
                                      =
                                      A
                                      +
                                      1
                                      ;

         and would still compile without error. Thus, you can have  a  VERY
         long statement in 'C', which spans several lines. You must  always
         however, be very careful to include the terminating ';'.

            Each function within a 'C' program can be "called" by using its
         name in any statement, may accept "argument" values which  can  be
         accessed by the statements contained within it, and may  return  a
         value back to the caller. This allows functions in 'C' to be  used
         as "building blocks", providing extensions to the language,  which
         may be used from any other function.

            Below is a sample 'C' function,  which  performs  an  operation
         (addition) on two argument values. The text between '/*' and  '*/'
         is COMMENTS, and is ignored by the compiler.

           /* Sample 'C' function to add two numbers */
           int add(num1, num2)     /* Declaration for function */
               int num1, num2;     /* Declaration for arguments */
           {
               return num1+num2;   /* Send back sum of num1 and num2 */
           }

            The names located within the  round  brackets  '()'  after  the
         function name "add" tells the compiler what names you want to  use
         to refer to the ARGUMENT VALUES. The "return" statement  tell  the
         compiler that you want to terminate the execution of the function,
         and return the value of  the  following  expression  back  to  the
         caller. (We'll discuss "return" in more detail later).
   Intro to MICRO-C                                                 Page: 13


            Now that you have defined the function "add", you could use  it
         in any other statement, in any function in your program, simply by
         calling it with its name and argument values:

                                a = add(1, 2);

            The above statement would call "add", and pass  it  the  values
         '1' and '2' as arguments. "add" evaluates 1  +  2  to  be  3,  and
         returns that value back, which is then stored in the variable 'a'.

            Note that 'C' uses the  round  brackets  following  a  name  to
         determine that you wish to call the function, therefore, even if a
         function has no argument values, you must include '()':

                               a = function();

            Also note, that if a function does not return a value,  or  you
         do not want to  use  the  returned  value,  you  simply  code  the
         function name by itself:

                                 function();

      3.2 Variables

            VARIABLES in 'C' are reserved areas of memory  where  the  data
         manipulated by the program is stored. Each variable is assigned  a
         name by which it  is  referenced  by  other  'C'  statements.  ALL
         VARIABLES IN 'C' MUST BE DECLARED.

            Variables in 'C' may be single values as shown eariler, or they
         may be declared as an ARRAY, which reserves  memory  space  for  a
         number of data elements, each  with  the  type  declared  for  the
         variable.

                                int array[4];

            The above statement reserves memory  for  four  16  bit  signed
         values, under the name "array". It is important to know  that  'C'
         considers the elements of an array to be numbered from  zero  (0),
         so the four locations in the above array are referenced by using:

                                   array[0]
                                   array[1]
                                   array[2]
                                   array[3]

            There are two basic types  of  variables  in  'C',  GLOBAL  and
         LOCAL.
   Intro to MICRO-C                                                 Page: 14


         3.2.1 GLOBAL Variables

               GLOBAL variables are set up permanently in memory, and exist
            for the duration of the entire programs execution. The names of
            global variables may be referenced by  any  statement,  in  any
            function, at any time. Global variables are declared in 'C'  by
            placing the declaration statement OUTSIDE of any function.  For
            example:

               int a;      /* Declare GLOBAL variable */

               inita()     /* Function to initialize 'a' with 1 */
               {
                   a = 1;
               }

               Note that the declaration statement for 'a' is NOT contained
            within the definition of "inita".

               Since global variables are permanent blocks of memory, it is
            possible to INITIALIZE them in the declaration statement.  This
            causes the variable to be assigned a  value  at  COMPILE  time,
            which will be loaded into memory at  the  same  time  that  the
            program is loaded to be executed. This means that your  program
            will not have to explicitly store a value in a.

                                  int a = 1;

               Array variables may also be initialized in  the  declaration
            statement, by using the  curly  brackets  '{}'  to  inform  the
            compiler that you have multiple values:

                          int a[4] = { 1, 2, 3, 4 };

               In MICRO-C, the initial values for an array are expressed as
            a single string of values  REGUARDLESS  of  the  shape  of  the
            array:

                        int a[2][2] = { 1, 2, 3, 4 };

               If an array has only one dimension (set of  '[]'s),  you  do
            not have to specify the  size  of  initialized  variables.  The
            compiler will automatically set  the  size  to  the  number  of
            initial values given:

                        int array[] = { 1, 2, 3, 4 };
   Intro to MICRO-C                                                 Page: 15


         3.2.2 LOCAL Variables

               Variables  which  are  declared  WITHIN   a   function   are
            determined by the compiler to be  LOCAL.  The  memory  used  by
            these variables is automatically  reserved  when  the  function
            begins to execute, and is released when it terminates. Names of
            LOCAL variables are only accessable from  within  the  function
            where they are defined:

               inita()     /* Function to initialize 'a' with 1 */
               {
                   int a;  /* Declare LOCAL variable */

                   a = 1;
               }

               The  above  function  shows  the  declaration  of  a   local
            variable, but is not very useful since the local variable  will
            cease to exist when the function returns. Local  variables  are
            used as temporary locations  for  holding  intermediate  values
            created during a functions execution, which are not required by
            any other part of the program.

               Each function may have its own local  variables,  but  since
            memory is  only  used  by  the  functions  which  are  actually
            executing, the total amount of memory reserved is usually  less
            that the total size of all local variables in the program.

               Since local variables are allocated and released during  the
            execution of your program, it is  not  possible  to  initialize
            them at compile time, and therefore MICRO-C does not allow them
            to be initialized in the declaration. Some compilers  do  allow
            this, however,  the  code  generated  is  equivalent  to  using
            assignment statements to initialize them at  the  beginning  of
            the function.

               The ARGUMENTS to a function  (See  Functions)  are  actually
            local variables for that function which are  created  when  the
            function is called. For this reason,  the  argument  names  are
            also un-available outside of the function  in  which  they  are
            defined.
   Intro to MICRO-C                                                 Page: 16


      3.3 Pointers

            A POINTER in 'C' is a memory address,  which  can  be  used  to
         access another data item in memory. All pointers in MICRO-C are 16
         bit values, which allows access to a maximum  of  65536  bytes  of
         memory through it.

            Any variable or function  may  be  declared  as  a  pointer  by
         preceeding its name with the '*' character in the declaration:

           int *a;                 /* a = 16 bit pointer to int value */
           char *b;                /* b = 16 bit pointer to char */
           extern char *fgets();   /* Returns 16 bit pointer to char */

            Later on, I will show you how you can use  a  special  operator
         called INDIRECTION to access data items at the  address  contained
         in the pointer.

      3.4 A complete 'C' program

            With all of the preceeding  information  under  you  belt,  you
         should be able to understand most  of  this  simple  but  complete
         program:

           #include stdio.h

           /* Main program */
           main()
           {
               int a, b, c;

               a = 1;
               b = 2;
               c = add(a, b);
               printf("The result of (1+2)=%d\n", c);
           }

           /* Our old familiar "add" function */
           int add(num1, num2)
               int num1, num2;
           {
               return num1+num2;
           }

            Did you fully understand it??? ... I thought not!!!

            There are a few new things presented in this program,  which  I
         will now explain.

            First of all, you should know that the function name "main"  is
         a special name which will be called at the  very  beginning,  when
         the program is first run. It provides a starting  point  for  your
         programmed functions. All 'C' programs have a "main" function.
   Intro to MICRO-C                                                 Page: 17


            You may also be wondering about those "#include"  and  "printf"
         statements. This all comes back to the concept of PORTABILITY, and
         has to do with the programs ability to perform  INPUT  and  OUTPUT
         (I/O). Methods of performing  I/O  may  differ  greatly  from  one
         operating system to another, and hence make it difficult to  write
         "portable" programs. If you don't know  what  portability  is,  go
         back and read the "Background Information" section.

            In order to insure that 'C' compilers could be  easily  adapted
         to nearly any operating system,  the  designers  of  the  language
         decided not to  include  ANY  I/O  capabilities  in  the  compiler
         itself. By not implementing it, they didn't have  to  worry  about
         it. All such activity is performed by a set of  functions  in  the
         'C' STANDARD LIBRARY, which is provided for each operating system.

            These library functions are used in nearly all programs,  since
         a program which can't read or  write  any  data  doesn't  do  much
         useful work.

            Many of the library functions must be  declared  as  a  certain
         type, which may be specific  to  the  compiler  implementation  or
         operating system. (For example  the  "printf"  functions  must  be
         declared as "register" in MICRO-C). The file "stdio.h" is provided
         with  all  "standard  libraries",   and   contains   any   special
         declarations required by the library functions.

            The "#include"  statement  causes  the  compiler  to  read  the
         "stdio.h"  file,  and  to  process  the   declaration   statements
         contained within it. This is equivalent to incorporating the  full
         text of "stdio.h" at the beginning of your program.

            The "printf" statement is actually a call to a STANDARD LIBRARY
         FUNCTION. It is available in almost all 'C'  implementations,  and
         in the above example, displays the prompt "The result of  (1+2)=",
         followed by the decimal value of the passed argument 'c'. For more
         information about "printf" and other library functions,  refer  to
         the MICRO-C Technical manual.

            At his point you may wish to enter  the  demonstration  program
         into a file called "DEMO1.C", and  compile  it  with  the  MICRO-C
         compiler. Remember that 'C' IS CASE SENSITIVE, so be sure to enter
         the program EXACTLY as it is shown. Also, make sure that  you  are
         positioned in the MICRO-C directory before you  create  the  file.
         After entering and saving the file with your favorite text editor,
         compile the program using the command:

                                  CC86 DEMO1

            You can  run  the  resultant  "DEMO1.COM"  program,  by  simply
         typeing "DEMO1", at the DOS command prompt.
   Intro to MICRO-C                                                 Page: 18


      3.5 'C' memory organization

            Now that you have seen a complete 'C'  program,  and  know  the
         basic concepts of functions and variables, you may  want  to  know
         how MICRO-C organizes the computer memory  when  these  constructs
         are used. Knowing this  may  help  you  understand  functions  and
         variables more precicely.

            The information in this section is  not  really  necessary  for
         casual use of the language, if you feel  that  such  detail  would
         only confuse you, feel free to skip it until later.

            The MICRO-C compiler builds your program to occupy a  block  of
         memory. In the case of small 8 bit computers, this block of memory
         will usually be the entire free ram in the machine. In the case of
         larger machines, it will usually be 64K (65536 bytes), but may  be
         larger or smaller depending on the implementation.

            The exact size of the memory block  is  unimportant,  since  it
         affects only the maximum size of a MICRO-C program. The methods of
         memory allocation remain the same.

         3.5.1 Static memory

               MICRO-C places all of the executable code from the  compiled
            functions at the very  beginning  of  the  memory  block.  This
            includes all  CPU  instructions  which  are  generated  by  the
            compiler. MICRO-C places all initialized  global  variables  in
            this area as well, and also something called the LITERAL POOL.

               The "literal pool" consists of all string data which is used
            in statements or initializations in the program. An example  of
            this is the string used in the preceeding demonstration program
            ("Result of (1+2)=%d\n"), which is  a  series  of  data  bytes,
            which are passed to the "printf" function.

               This collection of CPU  instructions,  Initialized  variable
            data, and literal pool data is the complete program image which
            must be loaded into memory every time the program is executed.

               The next section of memory allocated by  MICRO-C  holds  the
            global variables which have not been  initialized.  Since  they
            have no initial values, they do not have  to  be  loaded  every
            time the program runs. This also means that until  the  program
            stores a value in a particular  memory  location  its  contents
            will be some random value which happened to be at that location
            in memory before the program was loaded.

               All of this memory is called "STATIC" memory, because it  is
            reserved for code and data at COMPILE time. Once the program is
            compiled, the above mentioned items are fixed  in  memory,  and
            cannot be moved or changed in size.
   Intro to MICRO-C                                                 Page: 19


         3.5.2 Dynamic memory

               When your program begins execution, one of the first  things
            that happems, is that a STACK is set up at the very top of  the
            memory block. This  stack  is  always  referenced  by  a  STACK
            POINTER register which always points to the lowest  address  of
            memory used on the stack. All memory in  the  block  above  the
            stack pointer is deemed to be in use. This is usually  a  built
            in feature of the CPU.

               At the beginning of every function,  the  code  produced  by
            MICRO-C contains instructions to reduce the value of the  stack
            pointer by the number of bytes of memory required by the  local
            variables in that function.  When  the  function  "returns"  or
            terminates, the stack pointer is increased by the same amount.

               This allows the function to use the memory immediatly  above
            the new stack pointer for its local variables without fear that
            another function will also try to use it. When another function
            is called, it will reserve its memory BELOW the memory  already
            in use by the calling  function,  and  will  return  the  stack
            pointer when it is finished. Thus, all local variables  may  be
            accessed as constant offsets from the stack pointer set  up  at
            the beginning of the function.

               ARGUMENTS to a function are passed by  reserving  memory  on
            the stack, and setting it to the argument values, just PRIOR to
            calling the function. When the  called  function  returns,  the
            stack reserved for its arguments is  removed  by  the  function
            performing the call. In this way, the arguments are  just  more
            local variables, and may also be accessed as  constant  offsets
            from the stack pointer.

         3.5.3 Heap memory

               Some programs need temporary memory which will not disappear
            when the function terminates, or they may not  know  the  exact
            amount of memory they need for a certain operations until  some
            calculations have been performed.

               To resolve these problems,  'C'  provides  another  type  of
            dynamic memory which is called "HEAP" memory. To  make  use  of
            this memory, the program uses the "malloc" function  (from  the
            standard library)  which  allocates  a  block  of  memory,  and
            returns a pointer value to its address. The  program  may  then
            access and manipulate this memory through the pointer.

               When the program is finished with the memory,  it  may  then
            use the "free" library function to  release  it,  and  make  it
            available for use by other calls to "malloc".

               A program may continue allocating  memory  via  "malloc"  as
            long as there is available free memory to allocate. The library
            functions will  keep  track  of  which  blocks  of  memory  are
            allocated, and which blocks are available for allocation.
   Intro to MICRO-C                                                 Page: 20


               A typical memory layout for a 'C' program in the  middle  of
            execution might look something like this:

               +----------------------------------------+
               |            CPU Instructions            |
               |         which make up program          |
               |                "code"                  |
               +----------------------------------------+
               |      Initialized GLOBAL variables      |
               +----------------------------------------+
               |           LITERAL POOL data            |
               +----------------------------------------+
               |    Un-initialized GLOBAL variables     |
               +----------------------------------------+
               |      Memory allocated to the heap      |
               +----------------------------------------+
               |          (Heap grows upward)           |
               |                   |                    |
               |  Free memory, available for growth of  |
               |           the heap and stack.          |
               |                   |                    |
               |         (Stack grows downward)         |
               +----------------------------------------+
               |  Local variables of innermost function |
               +----------------------------------------+
               |  Return address of innermost function  |
               +----------------------------------------+
               |     Arguments of innermost function    |
               +----------------------------------------+
               |  Local variables of middle function    |
               +----------------------------------------+
               |   Return address of middle function    |
               +----------------------------------------+
               |      Arguments of middle function      |
               +----------------------------------------+
               |    Local variables of main function    |
               +----------------------------------------+
               |    Return address of main function     |
               +----------------------------------------+

               For those  not  familiar  with  computer  architecture,  the
            RETURN ADDRESS is placed on the stack by  a  CALL  INSTRUCTION,
            and  is  the  memory   address   immediately   following   that
            instruction. When a RETURN INSTRUCTION is later  executed,  the
            CPU removes the return address from the stack, and places it in
            the PROGRAM COUNTER, thus causing program execution  to  resume
            with the instruction immediately following  the  original  call
            instruction.
   Intro to MICRO-C                                                 Page: 21


   4. EXPRESSIONS

         An expression in 'C' consists of one or more values, and OPERATORS
      which cause those values to be modified in  a  calculation.  Anywhere
      that you would use a simple  value  in  'C',  you  can  also  use  an
      expression. We have already seen that with the "return" statement  in
      the "add" function in our example program. Knowing that  we  can  use
      expressions and values interchangably, we could shorten  the  example
      "main" function to:

           main()
           {
               int a, b;

               a = 1;
               b = 2;
               printf("The result of (1+2)=%d\n", add(a,b));
           }

       or even:

           main()
           {
               int a, b;

               a = 1;
               b = 2;
               printf("The result of (1+2)=%d\n", a+b);
           }

       or even:

           main()
           {
               printf("The result of (1+2)=%d\n", 1 + 2);
           }

       Or, if we wanted the 'a, b & c' variables set anyway:

           /* Note the use or round brackets '()' to incorporate
              a SUB-EXPRESSION into the main expression */
           main()
           {
               int a, b, c;

               printf("The result of (1+2)=%d\n", c = (a = 1) + (b = 2));
           }

         You can see that an entire expression, including three ASSIGNMENTS
      was included in a place where only a simple value is  used.  This  is
      one of the great powers of 'C', and can result  in  very  small  fast
      efficent code (at the expense of readability). Numerous  examples  of
      this type of programming may by found in  the  source  code  for  the
      MICRO-C compiler.
   Intro to MICRO-C                                                 Page: 22


      4.1 Unary operators

            Unary (single operand)  operators  are  those  operators  which
         perform a computation on only a single value. In most  cases,  the
         operator must be placed immediatly BEFORE the value to be operated
         on.

         4.1.1 Negate: -

               The NEGATE operator causes the value  to  its  right  to  be
            changed in sign. Thus, a positive value will be converted to  a
            negative value (of the same magnitude) and vice  versa.  It  is
            most often used to enter negative numbers, but it is  perfectly
            legal to apply this operator to a variable or expression.

           eg:     a = -5;         /* a = negative 5 */
                   b = 10;         /* b = positive 10 */
                   c = -b;         /* c = -10 */
                   d = -(b+5);     /* d = -15 */
                   e = -b+5;       /* e = -5  *
                   f = -a;         /* f = 5   */

         4.1.2 Bitwise Complement: ~

               The BITWISE COMPLEMENT operator reverses the value (0 or  1)
            of each individual BIT in the value to its right. This is  very
            useful when used with the other BITWISE operators (AND, OR  and
            XOR), to perform test on combinations of bits in a byte  (char)
            or word (int).

           eg:     a = 5;          /* a = 00000101 */
                   b = ~a;         /* b = 11111010 */

         4.1.3 Logical Complement: !

               The LOGICAL COMPLEMENT operator reverse the "logical  sense"
            (TRUE or FALSE) of the value to its right. In 'C'  a  value  is
            considered to be logically TRUE if it contains any value  other
            than zero. A value of zero is considered to be logically FALSE.
            The logical complement gives a value of  zero  (FALSE)  if  the
            original value was non-zero, and a value of one (TRUE)  if  the
            original value was zero. You will  see  later  that  there  are
            CONDITIONAL statements in 'C', which perform certain operations
            only if values are TRUE. This operator provides a simple method
            of reversing those conditions to occur when the value is FALSE.

           eg:     if(a) b = 10;   /* Set b to 10 if a is TRUE */
                   if(!a) b = 10;  /* Set b to 10 if a is FALSE */
   Intro to MICRO-C                                                 Page: 23


         4.1.4 Increment: ++

               The INCREMENT operator must be used on a value that  can  be
            ASSIGNED (such as a variable or array element). It  causes  the
            value to be INCREASED by one (except for a  special  case  with
            POINTERS which are advanced by the size of the  type  to  which
            they point).

               Unlike most other unary operators,  the  increment  operator
            may be placed either BEFORE or AFTER  the  value,  and  behaves
            slightly differently  depending  on  its  position.  If  placed
            BEFORE the value, the variable  is  incremented,  and  the  new
            value is passed on as the result. If placed  AFTER  the  value,
            the original value is passed on as the result, and the variable
            is then incremented.

           eg:     a = b = 10;     /* Set a & b to 10 */
                   c = ++a;        /* c = 11 (a = 11) */
                   d = b++;        /* d = 10 (b = 11) */

         4.1.5 Decrement: --

               The  DECREMENT  operator  behaves  exactly   the   same   as
            increment,  except  that  the  value  is  REDUCED  instead   of
            increased.

           eg:     a = b = 10;     /* Set a & b to 10 */
                   c = --a;        /* c = 9  (a=9) */
                   d = b--;        /* d = 10 (b=9) */

         4.1.6 Indirection: *

               The INDIRECTION operator may only be applied to POINTERS, or
            expressions which result in a  POINTER  VALUE.  It  causes  the
            memory contents at the address contained in the pointer  to  be
            accessed, instead of the pointer value itself.

           eg:     char *ptr;      /* Declare a pointer to character */
                   ptr = 10;       /* Set pointer variable to 10 */
                   *ptr = 5;       /* Set 'char' at address 10 to 5 */
                   a = ptr;        /* a = 10 (pointer value) */
                   b = *ptr;       /* b = 5 (Indirect through address 10) */

         4.1.7 Address: &

               The ADDRESS operator may only be used on a value  which  can
            be ASSIGNED (such as a variable or array element).  It  returns
            the memory address of the value, instead of the value itself.

           eg:     a = 10;         /* Set variable a to 10 */
                   ptr = &a;       /* Get address of 'a' */
                   b = *ptr;       /* b = 10 (contents of 'a') */
                   *ptr = 15;      /* Store 15 at address of 'a' */
                   c = a;          /* c = 15 */
   Intro to MICRO-C                                                 Page: 24


      4.2 Binary Operators

            In additon to the "unary" operators presented above, 'C' has  a
         large complement of BINARY (two  operand)  operators.  The  binary
         operators take two values, presented on the left and right side of
         the operator, and combine them into some form of computed value.

         4.2.1 Addition: +

               The ADDITION operator computes the SUM of two values.

           eg:     a = b + 5;      /* a = sum of b and 5 */

         4.2.2 Subtraction: -

               The SUBTRACTION operator  computes  the  DIFFERENCE  of  two
            values.

           eg:     a = b - 5;      /* a = difference of b and 5 */

         4.2.3 Multiplication: *

               The MULTIPLICATION operator  computes  the  PRODUCT  of  two
            values.

           eg:     a = b * 5;      /* a = b multiplied by 5 */

         4.2.4 Division: /

               The DIVISION operator computes the QUOTIENT  resulting  from
            the division of the left value by the right value.


           eg:     a = b / 5;      /* a = b divided by 5 */

         4.2.5 Modulus: %

               The MODULUS operator computes the REMAINDER  resulting  from
            the division of the left value by the right value.

           eg:     a = b % 5;      /* a = remainer of b divided by 5 */

         4.2.6 Bitwise And: &

               The BITWISE AND operator performs an AND  function  on  each
            pair of bits between the values. Bit positions which have a one
            (1) bit in BOTH values will receive a one in  the  result.  All
            other bit positions will receive zero (0).

           eg      a = 5;          /* a = 00000101 */
                   b = 6;          /* b = 00000110 */
                   c = a & b;      /* c = 00000100 (4) */
   Intro to MICRO-C                                                 Page: 25


         4.2.7 Bitwise Or: |

               The BITWISE OR operator performs an OR function on each pair
            of bits between the values. Bit positions which have a one  (1)
            in EITHER value will receive a one in the result. All other bit
            positions will receive zero (0).

           eg      a = 5;          /* a = 00000101 */
                   b = 6;          /* b = 00000110 */
                   c = a | b;      /* c = 00000111 (7) */

         4.2.8 Bitwise Exclusive Or: ^

               The BITWISE EXCLUSIVE OR operator performs an  EXCLUSIVE  OR
            function on each pair of bits between the values. Bit positions
            which have a one (1) in EITHER value, but NOT  IN  BOTH  values
            will receive a one in the result. All other bit positions  will
            receive zero (0).

           eg      a = 5;          /* a = 00000101 */
                   b = 6;          /* b = 00000110 */
                   c = a ^ b;      /* c = 00000011 (3) */

         4.2.9 Logical And: &&

               The LOGICAL AND operator returns  TRUE  (non-zero)  only  if
            BOTH values are TRUE. If either value is FALSE, FALSE (zero) is
            returned.

               MICRO-C accomplishes this by evaluating the left value,  and
            returning zero (FALSE) if it is equal to  zero,  otherwise  the
            right value is evaluated and returned. Some 'C' compilers force
            the returned value to be either zero (0) or one (1).

           eg:     if(a && b)
                       printf("Both 'a' AND 'b' are TRUE");

         4.2.10 Logical Or: ||

               The LOGICAL OR operator returns TRUE  (non-zero)  if  EITHER
            value is true, if  both  values  are  FALSE,  FALSE  (zero)  is
            returned.

               MICRO-C accomplishes this by evaluating the left value,  and
            returning its value if it is not  zero  (TRUE),  otherwise  the
            right value is evaluated and returned. Some 'C' compilers force
            the returned value to be either zero (0) or one (1).

           eg:     if(a || b)
                       printf("Either 'a' OR 'b' is TRUE");
   Intro to MICRO-C                                                 Page: 26


         4.2.11 Shift Left: <<

               The SHIFT LEFT operator returns a value which  is  equal  to
            the left value shifted left by a number of bits  equal  to  the
            right value.

           eg:     a = 10;         /* a = 00001010 */
                   b = a << 3;     /* b = 01010000 (80) */

         4.2.12 Shift Right: >>

               The SHIFT RIGHT operator returns a value which is  equal  to
            the left value shifted right by a number of bits equal  to  the
            right value.

           eg:     a = 80;         /* a = 01010000 */
                   b = a >> 3;     /* b = 00001010 (10) */

         4.2.13 Equals: ==

               The EQUALS operator performs  a  test  of  the  values,  and
            returns a one (1) of they are identical. If they do not  match,
            a zero (0). is returned. NOTE a common  difficulty  encountered
            when learning 'C' is to confuse the EQUALS (==) and  ASSIGNMENT
            (=) operators.

           eg:     if(a == 10)
                       printf("a is equal to 10");

         4.2.14 Not Equals: !=

               The NOT EQUALS operator perform a test of  the  two  values,
            and returns a one (1) if they are NOT identical. If the  values
            match, a zero (0) is returned.

           eg:     if(a != 10)
                       printf("a is not equal to 10");
   Intro to MICRO-C                                                 Page: 27


         4.2.15 Greater Than: >

               The GREATER THAN operator performs a test of the two values,
            and returns a one (1) is the left  value  is  higher  than  the
            right value. If the left value is equal to  or  less  than  the
            right value, zero (0) is returned.

           eg:     if(a > 10)
                       printf("a is bigger than 10");

         4.2.16 Less Than: <

               The LESS THAN operator performs a test of  the  two  values,
            and returns a one (1) is the left value is lower than the right
            value. If the left value is equal to or greater than the  right
            value, zero (0) is returned.

           eg:     if(a < 10)
                       printf("a is smaller than 10");

         4.2.17 Greater Than or Equals: >=

               The GREATER THAN OR EQUALS operator performs a test  of  the
            two values, and returns a one (1) is the left value  is  higher
            than OR equal to the right value. If the  left  value  is  less
            than the right value, zero (0) is returned.

           eg:     if(a >= 10)
                       printf("a is bigger than or equal to 10");

         4.2.18 Less Than or Equals: <=

               The LESS THAN OR EQUALS operator performs a test of the  two
            values, and returns a one (1) is the left value is  lower  than
            OR equal to the right value. If the left value is greater  than
            the right value, zero (0) is returned.

           eg:     if(a <= 10)
                       printf("a is smaller than or equal to 10");
   Intro to MICRO-C                                                 Page: 28


         4.2.19 Assignment: =

               The ASSIGNMENT operator takes the value to  the  right,  and
            STORES it in the left value. The left value must be ASSIGNABLE.

           eg:     a = 10;     /* Store 10 in variable a */

         4.2.20 Self Assignment Operators

               'C' provides special operators which implement  a  shorthand
            method of performing an operation on two values when the result
            is stored back into the left value. These operators are  called
            SELF ASSIGNMENT operators.

                      Shorthand:          Equivalent to:
                   --------------------------------------
                       a += 1;             a = a + 1;
                       b -= 2;             b = b - 2;
                       c *= 3;             c = c * 3;
                       d /= 4;             d = d / 4;
                       e %= 5;             e = e % 5;
                       f &= 6;             f = f & 6;
                       g |= 7;             g = g | 7;
                       h ^= 8;             h = h ^ 8;
                       i <<= 9;            i = i << 9;
                       j >>= 10;           j = j >> 10;

               With most compilers, the self assignment  operators  do  not
            produce any better  code  when  using  simple  variables.  They
            simply allow you to state what you want done in  a  more  clear
            and concise manner.

               With MICRO-C, and most non-optimizing compilers, there is an
            advantage  to  using  the  self   assignment   operators   when
            referencing a CALCULATED ADDRESS (Such  as  when  accessing  an
            indexed array).

                                array[a] += b;

                         Is often more efficent than:

                           array[a] = array[a] + b;
   Intro to MICRO-C                                                 Page: 29


      4.3 Other Operators

            There are a few 'C' operators which do not fall into one of the
         above clearly defined classes. Those operators are presented here:

         4.3.1 Statement terminator: ;

               We have already seen the ';' STATEMENT TERMINATOR,  this  is
            just a reminder of how important it is. Leaving out the ';'  at
            the end of a statement is a good way to convince  the  compiler
            to produce lots of error messages.

         4.3.2 Comma Operator: ,

               The function performed by the COMMA operator ',' depends  on
            where it occurs in the 'C' source file.

               When used within the  arguments  to  a  function  call,  its
            function is to separate each argument that is passed:

           eg:     function(a, b, c);

               When used in a DECLARATION statement,  its  function  is  to
            separate each variable name to be defined:

               eg: int a, b, c;

               When used in a global variable initialization, its  function
            is to separate the initial elements:

           eg:     int array[] = { 1, 2, 3 };

               When used in  any  expression  other  than  those  mentioned
            above, a comma allows several expressions to be used in a place
            where only one expression is expected. The  value  returned  in
            that of the RIGHTMOST expression:

           eg:     return a=4, 10;     /* Set a = 4, and return 10 */
   Intro to MICRO-C                                                 Page: 30


         4.3.3 Conditional Operator: ?

               The CONDITIONAL operator  allows  you  to  create  a  single
            expression which evaluates one of two SUB-EXPRESSIONS depending
            on a logical condition. It is coded in the 'C'  source  program
            in the form:

             <condition> ? <TRUE expression> : <FALSE expression>

               Consider, the standard  library  function  "toupper",  which
            converts any  lower  case  character  to  upper  case.  If  the
            original character was lower case, no conversion is  made,  and
            the character is returned unchanged.

               Knowing that in ASCII, lower case characters  have  a  value
            equal to the equivalent upper case character  +  64,  we  could
            code the following function:

               /* Function to convert lower case to upper case */
               char toupper(chr)
                   char chr;
               {
                   if((chr >= 'a') && (chr <= 'z'))    /* lower case ? */
                       return chr - 64;                /* Convert */
                   else
                       return chr;                     /* Leave alone */
               }

               The same function coded using a conditional expression is:

               /* Function to convert lower case to upper case */
               char toupper(chr)
                   char chr;
               {
                   return (chr >= 'a') && (chr <= 'z') ? chr - 64 : chr;
               }

               Although the difference between the above two functions  may
            seem  trivial,  remember  that  you  can  use  ANY   expression
            (including a CONDITIONAL expression) anywhere  that  you  could
            place a simple value. Once you get the hang of that,  you  will
            find that conditional expressions are a very  powerful  feature
            of the 'C' language.
   Intro to MICRO-C                                                 Page: 31


         4.3.4 Round Brackets: ( )

               The ROUND BRACKETS are used by 'C' to perform two functions.
            First, as already mentioned, they identify function calls,  and
            hold any arguments which are being passed:

           eg:     function1();
                   function2(a);
                   function3(a, b);

               The round brackets are also used to set up a SUB EXPRESSION,
            which can be used within another expression as a simple value:

           For example:

                   b = a + 5;
                   c = b / 2;

           Can be replaced by:

                   c = (a + 5) / 2;

           Or, if you want 'b' assigned:

                   c = (b = a + 5) / 2;

         4.3.5 Square Brackets: [ ]

               The SQUARE BRACKETS are used to perform indexing.  Variables
            which  have  been  declared   as   ARRAYS   may   be   indexed.
            MULTIDIMENSIONAL arrays may be  indexed  by  using  a  pair  of
            square brackets for each dimension:

           eg:     int array1[4], array2[2][2];

                   array1[0] = 10;
                   a = array1[1];
                   b = array2[1][0];

               If a multidimensional array is  indexed  with  a  number  of
            square  bracket  pairs  which  is  less  that  the  number   of
            dimsnsions of the array, the value returned is a POINTER  VALUE
            to the beginning address of the next dimension. A  pointer  may
            be indexed as it they were single dimension array,  the  memory
            offsets added to the pointer will be calculated  based  on  the
            size of the data type to which it has been declared to point:

           eg:     int array[3][3], *ptr;

                   array[2][1] = 10;
                   ptr = array[2];
                   a = ptr[1];         /* a = 10 */
   Intro to MICRO-C                                                 Page: 32


   5. CONTROL STATEMENTS

         There are a number of statements in 'C', which  serve  to  control
      the flow of program execution.

      5.1 The IF statement

            The IF statement controls the execution of one other statement,
         based of  the  logical  value  (TRUE  or  FALSE)  of  a  CONDITION
         EXPRESSION:

           if(condition)
               statement;

            The "statement" in the above example would only be executed  if
         "condition" evaluated to a logically TRUE (non zero) value.

            An optional "else" clause may be added to the IF statement.  In
         this example, "statement-1" is executed if  "condition"  evaluates
         to TRUE, and "statement-2" is executed if "condition" evaluates to
         FALSE.

           if(condition)
               statement-1;
           else
               statement-2;

      5.2 The WHILE Loop

            The WHILE  statement  is  similar  to  the  first  form  of  IF
         statement (without  an  else),  except  that  the  "statement"  is
         repeated until the condition becomes  FALSE.  If  the  "statement"
         does not effect the condition, the statement will be executed over
         and over forever (ie: infinite loop).

           while(condition)
               statement;

            Try entering, compiling and executing the following program:

           #include stdio.h
           /* Our old familiar "count to 10" program, with a few
              improvements to let us see the numbers */
           main()
           {
               int a;

               a = 0;
               while(a < 10)
                   printf("A=%d\n", a++);
           }
   Intro to MICRO-C                                                 Page: 33


            Note the '\n' at the end of the prompt in the call to "printf".
         'C' operates on a concept called STREAM I/O, which means that  all
         input and  output  is  considered  to  occur  in  a  never  ending
         "stream", like a stream of water. There  are  no  "lines"  in  the
         stream unless we cause them. The '\n' sequence at the end  of  the
         prompt is a NEWLINE character, which tells the compiler to  insert
         the necessary code into the string to cause the output to go to  a
         NEW LINE on a terminal or printer when the  string  is  displayed.
         Try removing the '\n' from the prompt and see what happens.

      5.3 The DO/WHILE Loop

            The DO/WHILE statement  is  similar  to  the  WHILE  statement,
         except that  the  condition  is  tested  AFTER  the  statement  is
         executed, not BEFORE. Note  that  when  using  DO/WHILE,  you  are
         guarenteed that the statement will always  be  executed  at  least
         ONCE.

           do
               statement;
           while(conditon);

            Here is another example of our "count" program, which uses  our
         own function to output the number in decimal:

           #include stdio.h

           /* Main "count" program */
           main()
           {
               int a;

               a = 0;
               do
                   outnum(a);
               while(++a < 10);
           }

           /* Function to output a number in decimal */
           outnum(value)
               unsigned value;
           {
               char stack[6];      /* Small stack to hold digits */
               unsigned sp;        /* Our own stack pointer */

           /* calculate each digit of the number (in reverse order) */
               sp = 0;
               do
                   stack[sp++] = (value % 10) + '0';
               while(value /= 10);
           /* Display the stack of calculated digits */
               while(sp)
                   putc(stack[--sp], stdout);
               putc('\n', stdout);     /* move to new line */
           }
   Intro to MICRO-C                                                 Page: 34


            The "putc" function  is  another  function  from  the  STANDARD
         LIBRARY. The name "stdout" is defined in the "stdio.h"  file,  and
         tells "putc" that the character should  be  written  to  "standard
         output" (The PC console).

            The DO/WHILE loop in the "outnum" function demonstrates a  case
         where a simple  WHILE  would  not  suffice.  Try  to  re-code  the
         function using only WHILE loops. You might try:

           sp = 0;
           while(value)
               stack[sp++] = (value % 10) + '0', value /= 10;

         This appears to work, however, try executing "outnum(0)". The loop
         is never executed,  "sp"  is  never  incremented  from  zero,  and
         NOTHING is output. Not even a single '0'.

      5.4 The FOR Loop

            Notice that in the example above, we have to  initialize  "sp",
         test "value", and perform an operation on value at the end of  the
         loop. 'C' provides a special loop construct, just for  doing  such
         operations. It is called a FOR loop:

           for(initialization; condition; operation)
               statement;

            Using the FOR loop, we can rewrite the above example as:

           for(sp = 0; value; value /= 10)
               stack[sp++] = (value % 10) + '0';

            Actually, the FOR loop is more often used to  implement  simple
         loops which execute a predetermined number of times:

           /* A count loop, which executes 10 times */
           for(a=0; a < 10; ++a)
               printf("A=%d\n", a);

            Sometimes, it is possible to do all the computations  that  are
         required in  the  "initialization",  "condition"  and  "operation"
         expressions to the FOR loop. In  this  case,  you  could  use  the
         SEMICOLON ';' as the entire "statement" to tell FOR that  and  you
         don't want it to perform any other operations:

           for(a=0; a < 10; printf("A=%d\n", a++))
               ;       /* This is a NULL statement */
   Intro to MICRO-C                                                 Page: 35


            This semicolon by itself is called a NULL statement, and can be
         used anywhere that any other statement would be used.

           a = 0;
           while(a++ < 100)
               ;

           if(a == b)
               ;
           else
               printf("a is not equal to b");

            Note that the expressions in a FOR statement end with ';'. This
         means that they are also optional, and could be replaced  by  NULL
         statements.

           for(; a < 10; ++a) ;    /* No initialization */
           for(a = 0;; ++a) ;      /* No condition (infinite loop) */
           for(a = 0; ++a < 10;) ; /* No operation at end of loop */
           for(;;) ;               /* Standard way to do infinite loop */

      5.5 Compound Statements

            This is all well and good you say, but IF, WHILE, DO/WHILE  and
         FOR seem quite limited in that the "condition" or  "loop"  applies
         only to a single statement. What if I want to perform more complex
         calculations in my loop?

            Another very powerful feature of the 'C' language, is that  any
         number of ordinary statements may be placed together  in  a  group
         and treated as a single large statement. All you have to do is  to
         enclose them in CURLY BRACKETS '{ }'. For example:

           if(a == 10) {       /* '{' begins compound statement */
               printf("A was equal to 10... ");
               a = 99;
               printf("But its not anymore"); }    /* '}' ends */
           else
               printf("A was never equal to 10");

            You have already seen an example of compound statements, in the
         curly brackets which surround the body of functions.  Technically,
         each function consists of only one statement, but thanks  to  'C's
         compounding capability, you can actually use as many statements as
         you wish.
   Intro to MICRO-C                                                 Page: 36


      5.6 BREAK and CONTINUE

            Two more  'C'  statements  are  available  which  are  designed
         specially for extending the capabilities of loops.

            The BREAK statement causes the program to  skip  any  remaining
         statements in the loop, and to break out of  the  loop.  Execution
         will proceed with the first statement which follows the loop, just
         as if the loop had terminated in its normal fashion:

           for(a=0; a < 10; ++a) {
               if(a == 5)
                   break;
               printf("A=%d\n", a); }

            The above loop will never  reach  its  terminal  count  of  10,
         because the "break" statement will be executed  when  'a'  reaches
         five. Thus, the BREAK statement allows you to sprinkle  additional
         exit conditions throughout the body of the loop.

            The CONTINUE statement causes the loop to  skip  any  remaining
         statements in the loop, but to continue  looping.  Execution  will
         proceed as  if  all  the  statements  in  the  loop  had  executed
         normally:

           for(a=0; a < 10; ++a) {
               if(a != 5)
                   continue;
               printf("A=%d\n", a); }

            The above example will execute all 10 interations of the  loop,
         but the "printf" statement will only be executed for the  loop  in
         which 'a' is equal to 5.

      5.7 The SWITCH Statement

            Sometimes, you have a large number of conditions, which are  to
         be executed depending on the value of a certain variable. One  way
         that you could do this is with a series of "IF" statements,  using
         a popular "else if" construct:

           if(a == 1)
               statement-1;        /* Executed if a == 1 */
           else if(a == 2)
               statement-2;        /* Executed if a == 2 */
           else if(a == 3)
               statement-3;        /* Executed if a == 3 */
           else if(a == 4) {       /* Note compound statement */
               statement-4;        /* Executed if a == 4 */
               statement-5; }      /* Executed if a == 4 */
           else
               statement-6;        /* Executed if a == anything else */
   Intro to MICRO-C                                                 Page: 37


            'C' has  a  built  in  statement  to  implement  this  kind  of
         structure. It is more readable, and generates more  efficent  code
         than such a series of "IF"  statements.  It  is  called  a  SWITCH
         statement:

           switch(a) {
               case 1 :
                   statement-1;        /* Executed if a == 1 */
                   break;
               case 2 ;
                   statement-2;        /* Executed if a == 2 */
                   break;
               case 3 :
                   statement-3;        /* Executed if a == 3 */
                   break;
               case 4 :
                   statement-4;        /* Executed if a == 4 */
                   statement-5;        /* Executed if a == 4 */
                   break;
               default:
                   statement-6; }      /* Executed of a == anything else */

            The "BREAK" statement at the  end  of  every  CASE  causes  the
         program to proceed to the statement immediately following the  end
         of the entire switch  construct.  If  it  were  not  present,  the
         statements in  a  case  would  "fall  through",  and  execute  the
         statements in the following case as well. Since the case values do
         not have to be presented in any particular  order,  this  behavior
         can often be used to your advantage by careful placing of the case
         statements relative to each other. Note also that the code in  the
         last case ("Default") does not need a "break" since it is  already
         at the end of the switch construct.

      5.8 Labels and GOTO

            If none of the above constructs does exactly what you  need  to
         structure a particular program. 'C' also  has  available  the  old
         familiar GOTO command. Although the use of "GOTO" is often frowned
         upon, it can save you much programming effort in  some  cases.  In
         order to use goto, you must have a LABEL.  Any  statement  may  be
         labeled by preceeding it with a name, followed immediatly by  ':'.
         For example:

           #include stdio.h
           /* Our "count to 10" program using goto looping */
           main()
           {
               int a;

               a = 0;
           count: printf("A=%d\n", a);     /* Labeled "count" */
               if(++a < 10)
                   goto count;
           }
   Intro to MICRO-C                                                 Page: 38


   6. RECURSION

         RECURSION is the ability of a function to call itself,  and  is  a
      powerful capability of the 'C' language.

         In a previous section, I explained how memory is allocated on  the
      stack to a function  when  it  begins  execution.  This  allows  each
      function to have its own local variables. It also  means  that  if  a
      function calls itself (by referencing its own name in  an  expression
      contained within it), the function will begin executing with its  own
      local memory, which is distinct from the local memory of the  calling
      function (which  is  itself!).  This  means  that  when  the  "lower"
      instance of the function terminates, it will not  have  affected  the
      memory or execution state of the "higher" version of the function.

         The classic example of a recursive  algorithm  is  the  FACTORIAL,
      which may be defined as: factorial(n) is equal  the  product  of  all
      numbers from one to n.

         Thus:
                   factorial(1) == 1       /* 1         */
                   factorial(2) == 2       /* 1*2       */
                   factorial(3) == 6       /* 1*2*3     */
                   factorial(4) == 24      /* 1*2*3*4   */
                   factorial(5) == 120     /* 1*2*3*4*5 */

         Using this algorithm, we can define an  ITERATIVE  (non-recursive)
      function to calculate the factorial of a passed value:

               /*
                * ITERATIVE factorial function
                */
               unsigned factorial(value)
                   unsigned value;
               {
                   unsigned result;

                   result = 1;             /* Begin with one */
                   while(value > 1)        /* For each value */
                       result *= value--;  /* Include in product & reduce */

                   return result;          /* Send back result */
               }

         You can see that in this above example, the function simply  loops
      the required number of times to perform  the  appropriate  number  of
      multiply operations to calculate the factorial. (The factorial  of  0
      is defined as 1, NOT 0, so the above function will return the correct
      result in this case).
   Intro to MICRO-C                                                 Page: 39


         Another way to define factorial is: factorial(n) = the product  of
      n and factorial(n-1). (Remember that the factorial of zero is defined
      as 1).

         Thus:
                   factorial(1) == 1       /* 1*1  */
                   factorial(2) == 2       /* 2*1  */
                   factorial(3) == 6       /* 3*2  */
                   factorial(4) == 24      /* 4*6  */
                   factorial(5) == 120     /* 5*24 */

         Using this algorithim, we  can  define  a  RECURSIVE  function  to
      calculate the factorial of a passed value:

               /*
                * RECURSIVE factorial function
                */
               unsigned factorial(value)
                   unsigned value;
               {
                   if(value == 0)  /* Factorial 0 is 1 */
                       return 1;

                   return value * factorial(value - 1);
               }

         In this example, you can see that the function will  call  itself,
      each  time  passing  a  reduced  value  until  a  value  of  zero  is
      encountered. When the zero value is passed, "factorial"  returns  the
      pre-defined result of one, and  all  other  called  versions  of  the
      function will perform a  single  multiplication,  and  pass  the  new
      result on. The value returned by the "highest" version of "factorial"
      will be the factorial of the originally passed value.

         This is the "classic" example of recursion, and it is a poor  one.
      Although it demonstrates the concept,  it  does  not  show  a  useful
      application. In fact, the recursive factorial function  will  execute
      slower and require much more memory  than  the  interative  function.
      (Remember each "version" of the function gets its own local memory).

         The MICRO-C compiler  itself  relies  heavily  on  recursion,  and
      provides much better examples of this programming technique since  it
      is  used  to  accomplish  feats  which  are  not  possible  using   a
      non-recursive algorithm.

         One such use of recursion in the compiler is  to  accomplish  'C's
      COMPOUND STATEMENT capability. Recall that multiple statements in 'C'
      may be  grouped  together  and  treated  as  a  single  statement  by
      enclosing them in CURLY BRACKETS  '{}'.  Any  statement  within  this
      "group" may also be a  compound  statement,  and  this  "nesting"  of
      compound statement blocks may continue to ANY LEVEL.
   Intro to MICRO-C                                                 Page: 40


         The compiler contains a  function  called  "statement",  which  is
      passed the first token from  a  'C'  statement,  and  processes  that
      statement.  This  function  contains  a  "switch"   statement   which
      processes the token, and decides the action to be performed for  that
      statement.  Note:  "tokens"  are  numeric  representations   of   the
      individual entities which may occur  in  the  source  file  (such  as
      keywords, symbol names, operators etc.).

         The "statement" function contains a  fragment  of  code  which  is
      similar to this:

               /*
                * Evaluate a language statement
                */
               statement(token)
                   unsigned token;
               {
                   /* ... Not shown ... */
                   switch(token) {     /* act upon the token */
                       /* ... Not shown ... */
                       case OCB:       /* '{' - begin a block */
                           while((token = get_token()) != CCB)
                               statement(token);
                           break;
                       /* ... Not shown ... */
                       case WHILE:
                           /* ... Not shown ... */
                           eval(CRB, 0);
                           cond_jump(FALSE, b, -1);
                           statement(get_token());
                           test_jump(a);
                           /* ... Not shown ... */
                           break;
                       /* ... Not shown ... */ }
               }

         In  this  function,  a  "while"  keyword  causes   the   following
      expression to be evaluated, followed by  a  conditional  jump,  after
      which  a  single  statement  is  compiled  (by  recursive   call   to
      "statement"), followed by  a  jump  back  to  the  beginning  of  the
      expression evaluation.

         If "statement" finds an  Opening  Curly  Bracket  (OCB),  it  will
      accept and compile more statements (recursivly) until a Closing Curly
      Bracket (CCB) is found. Therefore, if the statement compiled  in  the
      "while" loop  begins  with  OCB,  that  version  of  the  "statement"
      function will compile all subsequent statements up to CCB. When  that
      version of  "statement"  terminates,  the  original  version  of  the
      function (handling the "while") will then compile the  closing  jump.
      This has the effect that all statements between OCB and CCB ('{'  and
      '}') will be included in the body of the "while" loop.

         Another case where recursion is used within the MICRO-C  compiler,
      is to evaluate sub-expressions (contained  in  round  brackets  '()')
      which are inside another expression. In  this  case,  the  expression
      evaluation function calls itself (recursivly) when an  Opening  Round
      Bracket (ORB) is encountered.
   Intro to MICRO-C                                                 Page: 41


   7. COMMAND LINE ARGUMENTS

         When a 'C' program is invoked  by  typing  its  name  at  the  DOS
      command prompt, the remainder of the command line is broken down into
      distinct "words" (based on separating spaces or tabs), and passed  as
      standard 'C' arguments to the main function.

         Two values are passed to "main", the first is an integer count  of
      the number of command line arguments which were found, and the second
      is an array of pointers to character strings which  contain  each  of
      the arguments. In order that the program  may  identify  itself,  the
      first (zero'th) argument is always the name of  the  file  containing
      the programs executable image.

         For example, consider this program, compiled and saved in  a  file
      called "TEST.COM":

           #include stdio.h        /* Standard I/O definitions */

           /*
            * Command line arguments - DEMO program
            */
           main(argc, argv)
               int argc;       /* Count of arguments */
               char *argv[]    /* Array of pointers to char strings */
           {
               int i;          /* Temporary counter variable */

               for(i=0; i < argc; ++i)
                   printf("argv[%d] = '%s'\n", i, argv[i]);
           }

         When executed with the following command line:

                           TEST the quick brown fox

         The program will display the following output:

           argv[0] = 'TEST.COM'
           argv[1] = 'the'
           argv[2] = 'quick'
           argv[3] = 'brown'
           argv[4] = 'fox'

         NOTE1: The 'argc' value includes argv[0]  (program  name)  in  its
      argument count.

         NOTE2: Like any other  'C'  function,  "main"  does  not  have  to
      declare its arguments unless it is going to use them.
   Intro to MICRO-C                                                 Page: 42


   8. FILE ACCESS

         As mentioned before, all I/O  in  'C'  is  performed  by  STANDARD
      LIBRARY FUNCTIONS. Before any  file  access  can  be  performed,  the
      header file "stdio.h" must be included in the  source  (Via  #include
      pre-processor directive), in order to  properly  define  the  various
      functions and types which are used on your particular system.

         For  detailed  information  on  the  standard  library   functions
      mentioned below, see the MICRO-C technical manual.

      8.1 File Pointers

            All files in 'C' are identified by a FILE POINTER, which  is  a
         value returned by the operating system when the  file  is  OPENED.
         Since the type of value used to identify files may vary  from  one
         operating system to another, the "stdio.h" header file  defines  a
         data type called "FILE" which contains the correct definition  for
         your particular operating system. This allows the  declaration  of
         the file pointers to  be  portable  from  one  system  to  another
         without changing the program source code.

      8.2 File I/O Functions

            The standard library function "fopen" is used to open a file by
         name, and obtain the file pointer value.

            The functions "getc", "fread", "fgets" and "fscanf" may be used
         to read information from an open file.

            The functions "putc", "fwrite", "fputs" and  "fprintf"  may  be
         used to write information to an open file.

            The function "fclose" is used to close the file, which  informs
         the operating system that you are finished with it.
   Intro to MICRO-C                                                 Page: 43


               /*
                * Sample program to copy a file called "input"
                * To a file called "output". Note: To keep this
                * example simple, no error checking is perormed.
                */
               main()
               {
                   char buffer[1000];  /* Declare a copy buffer */
                   int nbytes;         /* Records # bytes read */
                   FILE *ifp, *ofp     /* Declare file pointers */

               /* Open the files */
                   ifp = fopen("input","r");   /* Open for Read access */
                   ofp = fopen("output", "w"); /* Open for Write access */

               /* Copy data in 1000 byte blocks */
                   do {
                       nbytes = fread(buffer, 1000, fp);   /* Read data */
                       fwrite(buffer, nbytes, fp); }       /* Write data */
                   while(nbytes == 1000);

                   fclose(ifp);            /* Close the input file */
                   fclose(ofp);            /* Close the output file */
               }

      8.3 Standard I/O

            Whenever a 'C' program is executed,  three  file  pointers  are
         automatically  established  which  allow  access  to  the  console
         keyboard and display:

           stdin   - Reads input from the console keyboard. Note that stdin
                     may be REDIRECTED (using '<filename'). For example:
                              program <input.dat
                     executes "program", and causes it to read its standard
                     input from "input.dat" instead of the keyboard.

           stdout  - Writes to the console display. Note that stdout may be
                     REDIRECTED (using '>filename). For example:
                             program >output.dat
                     executes "program", and causes  it to  write  standard
                     output to "output.dat" instead of the display.

           stderr  - Also writes to  the  console display,  but  CANNOT  BE
                     REDIRECTED, usually used to insure that error messages
                     will be displayed on the console even  if  the  output
                     has been redirected.

            The stdin, stdout and stderr file pointers are defined  in  the
         "stdio.h" header file, and are always available. They do not  have
         to be opened or closed.

            Since "stdin" and "stdout"  are  used  very  often  within  'C'
         programs, the functions "scanf" and "printf" are available.  These
         behave exactly the same as  the  general  "fscanf"  and  "fprintf"
         functions, except that they do not accept a file pointer argument,
         and always access stdin and stdout.
   Intro to MICRO-C                                                 Page: 44


   9. SAMPLE FUNCTIONS

         Here are some sample 'C' functions, demonstrating features of  'C'
      which we have discussed:

         Any function used in an example  but  not  defined  therein  is  a
      Library Function.  Refer  to  the  MICRO-C  Technical  Manual  for  a
      description.

      9.1 Prime Number Generator

           #include stdio.h        /* Standard I/O definitions */

           /*
            * This program tests a range of numbers, and prints out any
            * values which it finds to be prime. Each value is divided
            * by increasing values from 2 to (num/2). The "modulus" ('%')
            * operator is used, resulting in a zero result (no remainder)
            * if a factor is found. The main loop is incremented by two,
            * to skip even numbers which are never prime (except for 2
            * which is not shown by this program).
            */
           main()
           {
               int num, test, limit;
               char flag;

               for(num=1; num < 1000; num += 2) {      /* Test range */
                   limit = num/2;                      /* Only test to 1/2 */
                   flag = 1;                           /* Assume prime */
                   for(test = 2; test < limit; ++test) { /* Test factors */
                       if(!(num%test)) {               /* No remain: factor */
                           flag = 0;                   /* Not prime */
                           break; } }                  /* Waste no more time */
                   if(flag)                            /* Prime, display */
                       printf("%d\n", num); }
           }
   Intro to MICRO-C                                                 Page: 45


      9.2 A Simple Sort

           #include stdio.h        /* Standard I/O definitions */

           /*
            * This is an array of unsorted numbers
            */
           int numbers[10] = { 13, 25, 22, 7, 16, 91, 11, 41, 18, 0 };

           /*
            * This main program calls a function "sort" which re-arranges
            * the elements of an integer array to place them in ascending
            * order. It then prints out the resultant array using a simple
            * loop.
            */
           main()
           {
               int i;

               sort(numbers, 10);      /* Perform the sort */

               for(i=0; i < 10; ++i)   /* Display contents of array */
                   printf("[%d]=%d\n", i, numbers[i]);
           }

           /*
            * Function to sort an array of numbers. It is passed the
            * address of an integer array, and the size (in elements).
            *
            * Note: The declaration 'int array[]' identifies "array" as a
            * single dimension integer array of unspecified size. Since
            * arrays in 'C' are passed as a pointer value to the array
            * address, accesses to "array" will access the actual contents
            * of the passed array variable, allowing that variable to be
            * modified directly by this function.
            */
           sort(array, size)
               int array[], size;
           {
               int i, j, lowest;

               for(i=0; i < size; ++i) {           /* For each element */
                   lowest = i;
                   for(j=i+1; j < size; ++j)       /* Search higher elems */
                       if(array[j] < array[lowest])
                           lowest = j;             /* And remember lowest */
                   j = array[lowest];              /* Swap with original */
                   array[lowest] = array[i];
                   array[i] = j; }
           }
   Intro to MICRO-C                                                 Page: 46


      9.3 Text Display of Value

            This program accepts any  number  of  command  line  arguments,
         which it evaluates as unsigned numbers, and  displays  the  result
         for each argument using english text.

            For example, if this  program  were  saved  in  a  file  called
         "TEXTNUM.COM", and the following command is executed:

               TEXTNUM 1000 1100 1111 31415 9265 358

            The program will display the following output:

               One Thousand
               One Thousand, One Hundred
               One Thousand, One Hundred and Eleven
               Thirty One Thousand, Four Hundred and Fifteen
               Nine Thousand, Two Hundred and Sixty Five
               Three Hundred and Fifty Eight

            Here is a listing of the program:

           #include stdio.h

           /*
            * Main program which processes all of its arguments,
            * interpreting each one as a numeric value, and
            * displaying that value as english text.
            */
           main(argc, argv)
               int argc;
               char *argv[];
           {
               int i;

               if(argc < 2)                /* No arguments given */
                   abort("\nUse: textnum <value> ...\n");

               for(i=1; i < argc; ++i) {   /* Display all arguments */
                   textnum(atoi(argv[i]));
                   putc('\n', stdout); }
           }

           /* >>> Continued on Next Page >>> */
   Intro to MICRO-C                                                 Page: 47


           /*
            * Text tables and associated function to display an
            * unsigned integer value as a string of words.
            * Note the use of RECURSION to display the number
            * of thousands and hundreds.
            */

           /* Table of single digits and teens */
           char *digits[] = {
               "Zero", "One", "Two", "Three", "Four", "Five", "Six",
               "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve",
               "Thirteen", "Fourteen", "Fifteen", "Sixteen",
               "Seventeen", "Eighteen", "Nineteen" };

           /* Table of tens prefix's */
           char *tens[] = {
               "Ten", "Twenty", "Thirty", "Fourty", "Fifty",
               "Sixty", "Seventy", "Eighty", "Ninety" };

           /* Function to display number as string */
           textnum(value)
               unsigned value;
           {
               char join_flag;

               join_flag = 0;

               if(value >= 1000) {             /* Display thousands */
                   textnum(value/1000);
                   fputs(" Thousand", stdout);
                   if(!(value %= 1000))
                       return;
                   join_flag = 1; }

               if(value >= 100) {              /* Display hundreds */
                   if(join_flag)
                       fputs(", ", stdout);
                   textnum(value/100);
                   fputs(" Hundred", stdout);
                   if(!(value %= 100))
                       return;
                   join_flag = 1; }

               if(join_flag)                   /* Separator if required */
                   fputs(" and ", stdout);

               if(value > 19) {                /* Display tens */
                   fputs(tens[(value/10)-1], stdout);
                   if(!(value %= 10))
                       return;
                   putc(' ', stdout); }

               fputs(digits[value], stdout);   /* Display digits */
           }



                               Intro to MICRO-C

                              TABLE OF CONTENTS


                                                                        Page

    1. INTRODUCTION                                                        1


    2. BACKGROUND INFORMATION                                              2

       2.1 Computer Architecture                                           2
       2.2 Assembly Language                                               5
       2.3 High Level Languages                                            6
       2.4 Interpreters VS Compilers                                       8
       2.5 Object Modules & Linking                                        9
       2.6 Compiler Libraries                                             10
       2.7 Portability                                                    10

    3. INTRODUCTION TO 'C'                                                11

       3.1 Functions                                                      12
       3.2 Variables                                                      13
       3.3 Pointers                                                       16
       3.4 A complete 'C' program                                         16
       3.5 'C' memory organization                                        18

    4. EXPRESSIONS                                                        21

       4.1 Unary operators                                                22
       4.2 Binary Operators                                               24
       4.3 Other Operators                                                29

    5. CONTROL STATEMENTS                                                 32

       5.1 The IF statement                                               32
       5.2 The WHILE Loop                                                 32
       5.3 The DO/WHILE Loop                                              33
       5.4 The FOR Loop                                                   34
       5.5 Compound Statements                                            35
       5.6 BREAK and CONTINUE                                             36
       5.7 The SWITCH Statement                                           36
       5.8 Labels and GOTO                                                37

    6. RECURSION                                                          38


    7. COMMAND LINE ARGUMENTS                                             41


    8. FILE ACCESS                                                        42

       8.1 File Pointers                                                  42

   Intro to MICRO-C                                       Table of Contents

                                                                        Page
       8.2 File I/O Functions                                             42
       8.3 Standard I/O                                                   43

    9. SAMPLE FUNCTIONS                                                   44

       9.1 Prime Number Generator                                         44
       9.2 A Simple Sort                                                  45
       9.3 Text Display of Value                                          46