Frozen Fish 2: PC/frozenfish_august_1995.bin/bbs/d03xx/d0340.lha/NorthC/NorthC.lzh/hello.doc

Text File | 1990-02-27 | 10KB | 290 lines

  (c) 1990 S.Hawtin.
  Permission is granted to copy this file provided that:
   1) It is not used for commercial gain
   2) This notice is included in all copies
   3) Altered copies are marked as such.

  No liability is accepted for the contents of the file.



  Welcome to NorthC, this is a public domain 'C' programming system,
put together out of parts from people too numerous to mention.  This
disk contains all you require to start creating or porting 'C' programs
on your Amiga.

  So, you have just got this new disk from the public domain, and you are
wondering how to become a top 'C' wizard in an afternoon.  Well you must
start by writing a program.  Lisp programmers always write factorial as
thier first program, but that is because they are strange.  'C' being a
"real" language all 'C' programmers start with the "Hello World" program.

  This file outline the steps you should take to create a simple 'C'
program, compile it and run it.  This should work on anything from an
unexpanded Amiga 500 upwards, however if you have an unexpanded Amiga 500
go out and buy a second drive, they don't cost much and they make your
life so much easier.


  In this set of instructions I am assuming that the floppy you are using
is called "NorthC", if it is called something else, for example "Lib298",
then you will have to type the name of the floppy every time I say you
should type "NorthC:"


  The steps you should take are as follows.


1) Backup Your Disk

  Write protect the original NorthC disk, so you can see through the hole,
then either use the "Workbench"-"Duplicate" option, or the command "diskcopy"
to make a copy of the NorthC floppy.  Once you have done this always use
the copy, that way if something goes wrong you can make another copy.


2) Start the CLI

  The 'C' environment requires that you are running in a shell.  Double
click the shell icon in the "Workbench 1.3" floppy.


3) Set up the NorthC environment

  You will need to do this every time you run the 'C' compiler, once you
get bored enough you can put this in the startup-sequence file.

  How you set up the environemnt depends on your configuration, there are
three posibilities, either you have a hard disk, you have a second floppy,
or you only have a single floppy.


3a) A Single Floppy

  Type the command

    execute NorthC:Single-Disk

this will copy the necessary programs into the ram disk, once the programs
are copied you can "delete ram:copy" to give yourself more room for
compiling programs.


3b) If you have a second floppy drive

  Place the NorthC floppy into the second floppy drive, and type

    cd NorthC:
    setup-NorthC

this will add the "bin" directory to the search path and tell the system
where to find the 'C' libraries.


3c) If you have a hard drive

  Copy the files in the "NorthC:bin" directory into your executables
directory, copy the include files from "NorthC:include" into "include",
copy the files in "NorthC:libs" into a suitable 'C' library directory,
for example "clibs" and add the line

    assign clibs: hd0:clibs

into your "s:startup-sequence" file.


4) Move to the source directory

  The command

    cd NorthC:examples/hello

should move you to a suitable empty source directory, this is where you will
create the "Hello World" program.


5) Create a source file

  You should use "memacs" from the 1.3 Extras disk to enter a 'C' program,
the command

    "Extras 1.3:tools/memacs" hello.c

will start the editor up, enter the following file

    #include <stdio.h>

    main()
       {/* The simplest 'C' program ever */
    printf("\a\aHello World\n");
    }

once you have typed this in select "save-exit" on the "Project" menu, this
will save the file to the disk and exit the program.

  You should learn to use "memacs" when typing 'C' programs, it is a
version of the most widely used program editor for 'C' programmers.  It has
a large number of features that make it very powerfull for editing programs.


6) Compile the file

  If you called your file "hello.c" type the command

    cc hello.c

after much clunking of disk drives, and disk swapping if you have just
the one drive, you will find that your directory contains a file "a.out"
as well as "hello.c".  Use the command

    list

to show you the contents of the directory.


7) Run the file

  Once "a.out" has been created you can run the program by typing

    a.out

you will be amazed by the result, or there again you might not be.


8) Go again

  Edit the "hello.c" file to do something else, get ideas from published
'C' programs, public domain programs, friends, and anywhere else you can.

  There are a number of example programs on this disk look in the "examples"
directory and the "tools" directory, steal all the good ideas from them (if
you can find any).

  You should normally compile your programs with a command such as

    cc -ohello hello.c

this will create a program called "hello" rather than "a.out", this makes it
easier to remember what the program does.


9) Get serious

  Buy yourself a copy of "Kernigan & Ritchie" or better yet get someone else
to buy one for you.  I know it is expensive but if you get seriously into
'C' you will get your own copy in the end anyway.  It really is the best
book on 'C' ever written, even if the code layout is a bit weird.

  Find a good book for AmigaDOS, I cannot recommend any book here as I
have yet to find one that doesn't require a degree in computer science
to understand, however I am sure that some easy to understand books are
around.

  Read the "libc.doc" file on this disk to see what is currently implemented
in the NorthC library, read the "Bugs.doc" file especially if a program
does something you really didn't expect, or if it fails to compile.


10) Multiple files

  As a taster for the complexities of programming I will explain about
compiling large programs that are split over many files, ignore this bit
if you want.

  Once you have a decent sized program you will want to split it over many
source files, suppose you have a program that is written in the files
"foo.c" "bar.c" and "baz.asm".  You can compile the files with the command

    cc -ofoo foo.c bar.c baz.asm

however this will recompile all three files each time you compile the
program.

  The 'C' world contains four different types of file, source files,
assembler files, object files and executable files.  You can usually tell
which category any file comes in by its extension, for example source file
names end in ".c", for example "foo.c" "this.is.source.c" and so on.  Object
files normally end in ".o", assembler files end in ".s" or ".asm", and
executable files have no extensions.

  The 'C' compilation process contains three stages, first a compiler that
translates source files into assembler files, then an assembler that translates
assembler files into object files, and finally a linker that combines a number
of object files to create an executable.  The "cc" command will call each of
these stages for you, when you type

    cc -ohello hello.c

cc will first call the compiler, called NorthC, to create a file "hello.s",
next cc will call the assembler, called A68K, to create a file "hello.o",
and finally it will call the linker, Blink, to make the executable "hello",
once this is created it will delete the intermediate files "hello.s" and
"hello.o".

  We can tell cc not to bother with the linking stage by passing the "-c"
flag, for example the command

    cc -c hello.c

will create the "hello.o" file then stop.  Similarly

    cc -c bar.c
    cc -c baz.asm

will create the files "bar.o" and "baz.o", in the case of "baz.asm" cc
knows it is an assembler file because its name end in ".asm" so it just
calls A68K to assemble it.

  Once we have "foo.o" "bar.o" and "baz.o" we can link them together with
the command

    cc -ohello foo.o bar.o baz.o

this will complete the compilation process, calling Blink to produce the
executable file "hello".

  If we now find that there is a mistake in our "foo.c" source file we just
change "foo.c" the we only have to compile this one file, with

    cc -c foo.c

and then link all the files, with

    cc -ohello foo.o bar.o baz.o

rather than having to compile all the files again.

  Once you have understood all that you should find a good 'C' book and look
up libraries, not to be confused with Amiga libraries, this will get you
nicely confused again.  I hope that didn't confuse you.

  Examine the source code for "cc" in tools, this will show what "cc" can do,
if you would rather that it did something differently change the file "cc.c"
make a note of the fact you have changed it at the top of the file and
recompile it.  "cc.c" was hacked together in a single evening with just the
UNIX "cc" manual for a spec, so I won't mind if you 'improve' it, provided
you note what changes you have made at the top of the source.


11) Share and Enjoy (or Go Stick Your Head in a Pig)

  Once you understand 'C' you should share your knowledge, if you have an
interesting program put it into the public domain or make it shareware, if
you find learners in 'C' and AmigaDOS explain how to do things, always
remember that you once knew nothing about computers, even if it was a long
time ago.  Most of all you should have fun with computers, unless of course
you are a COBOL programmer.


12) After

  If you are a real 'C' wizard go off and learn a proper language, get a
copy of "scheme", on Fish 149, and "The Structure and Interpretation of
Computer Programs" by Ableson & Sussman.  The factorial function is

    (define (factorial n)
        (if (= n 0) 1
            (* n (factorial (- n 1)))))

there I told you Lisp programmers were weird.