ABSTRACT: gcc aufruf wird erklaert. kein vollstaendiger C kurs sondern nur
          eine kurzeinfuehrung was ein C compiler ueberhaupt macht.
          inklusive eines einfachen "hello world" programms.

AUDIENCE: junior admin
SYSTEM:   any unix
SECTION:  basic unix commands
AUTHOR:   mond <fs@mond.at>
COPYRIGHT: GNU Free Documentation Licence http://www.gnu.org/licenses/fdl.txt

  kleine scripts mit bash und perl koennen wir ja schon schreiben. fuer die
  meisten aufgaben die so typischerweise anfallen ist das auch alles was wir
  brauchen. die meisten systemprogramme und der kernel sind in einer sprache
  namens C geschrieben. einwenig C knowhow schadet daher keinem unix user.

  der C compiler auf einem unix heisst "cc". auf freien unixen ist das ein
  alias auf den GNU C compiler: gcc

  ein compiler uebersetzt programme in direkt ausfuehrbaren code. zum testen
  des c compilers schreiben wir uns ein kleines C programm:

  wir machen uns mit dem editor ein file namens hello.c mit folgendem inhalt
  
---------------scnhipp-------------------------
#include<stdio.h>

int main() { /* usnser erstes c programm */

  printf("hallo welt\n"); 

  return 0;
}
---------------schnapp--------------------------

  die erste zeile #include<stdio.h> fuegt an der stelle ein anderes file
  ein. filenamen im ekigen klammern werden aus dem "include pfad" gesucht. 
  stdio.h ist ein header file (.h) in dem standard funktionen definiert sind
  die man oft benoetigt. zeilen die mit # anfangen werden vom "c
  preprozessor" (cpp) abgearbeit der intern vom gcc aufgerufen wird. 
 
  hatte man anfuehrungszeichen anstatt spitzen klammern so wuerde gcc das
  file im aktuellen verzeichniss suchen.

  danach wird eine funktion definiert mit dem namen "main". die funktion
  wird beim start des programmes aufgerufen. sie wird als typ "int"
  definiert das heisst dass sie einen integer (eine ganze zahl)
  zurueckliefert. den wert den die funktion zurueckliefert (weiter unten mit
  dem return statement wird hier 0 zurueckgegeben. der zurueckgegeben wert
  ist der return wert des programmes. (siehe die CD zu "test"). 

  die funktion printf dient zur formatierten ausgabe. sie schreibt auf
  STDOUT. "\n" ist wie in perl ein zeilenvorschub. 

  /* */ klammert einen kommentar. 

  hat man die man pages zu den C funktionen installiert (sind in sektion 3)
  so kann man zu den standard C funktionen auch die man page nachschlagen. 
  z.b.:

man 3 printf

  mit

gcc -Wall hello.c -ohello

  compilieren wir unser programm. d.h. gcc macht ausfuehrbaren maschinencode
  daraus.  die angabe -ohello besagt dass das fertige programm "hello"
  heissen soll (ohne angabe von -o wuerde das programm "a.out" heissen)

  -Wall besagt dass wir den hoechsten level an warning messages haben
  wollen. was bei neuen programmen gut ist um fehler zu vermeiden. d.h. wir
  der gcc gibt viele warnungen aus auch wenn das programm trozdem
  compiliert.

  nach erfolgreichen compilieren koennen wir das programm starten:

./hello

  (./ ist notwendig weil wir i.a. das aktuelle verzeichniss nicht in unserem
  suchpfad haben)

  wichtige optionen von gcc:

    -On schaltet auf optimierungsstufe n. z.b. -O2
 
    -I/home/maxmeier/meineincludes wuerde dieses verzeichniss zum
           includepath hinzufuegen.
 
    -ggdb  wuerde das programm mit debuging informationen fuer den gnu
           debuger "gdb" (mit dem man programme zeilenweise abarbeiten kann
           und in interne variablen schaun kann) uebersetzten. ueber den gdb
           lernen wir ein ander mal.


  groessere programme werden aus mehreren .c files modular aufgebaut. man
  compiliert zuerst jedes der einzelnen teile zu einem .o file und macht aus
  diesem dann ein programm.

gcc -Wall -c hello.c

  das erzeugt ein object file namnes hello.o (das nicht direkt ausfuehrbar
  ist sondern darauf wartet gemeinsam mit anderen .o files zusammengelinkt zu
  werden.)

gcc hello.o -ohello

  linkt dann (hier eben nur dieses einzelne .o file zusammen zu unserem
  fertigen programm)

  bei groesseren projekten ruft man gcc auch nicht haendisch auf sondern
  erzeugt ein "Makefile" dass die anweisungen zum kompilieren enthaelt. das
  programm "make" arbeitet dann das "Makefile" ab. das lerenen wir auch
  demnaechst.


EXERCISES:

  * compiliere ein kurzes C progamm einmal direkt und einmal ueber den umweg
    von .o files


REFERENCES:


man gcc 
info gcc
man cpp
gcc --help