LOAD R1,10
               LOAD R2,10
   
            The  translation  from  neumonics  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 you 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  seperate  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