Verder Terug Inhoud

10. Iets over programmeren

10.1 Shell Scripts: .BATch bestanden

Als je gewend was .BATch bestanden aan te maken als verkorte opdrachten voor lange opdrachtregels (ik deed dit veel), kan dit doel worden bereikt door de passende alias regels in profile of .bash_profile in te voegen. Maar als je gecompliceerdere .BATch bestanden gebruikte, dan zal je de scripttaal die beschikbaar is door de shell weten te waarderen: het is zo krachtig en goed als de oude QBasic, zo niet beter. Het bevat variabelen, structuren zoals while, for, case, if... then... else, en heel veel andere mogelijkheden: het kan een goed alternatief zijn voor een ``echte'' programmeertaal.

Voor het schrijven van een script---het equivalent van een .BATch bestand onder DOS---hoef je slechts een standaard ASCII-bestand met de instructies te schrijven, het op te slaan, en het vervolgens uitvoerbaar te maken met het commando chmod +x <scriptfile>. Typ de naam ervan in, om het uit te laten voeren.

Een waarschuwing. De systeem editor wordt vi genoemd, en mijn ervaring is dat nieuwe gebruikers het erg moeilijk in 't gebruik vinden. Ik ga niet uitleggen hoe je het kunt gebruiken; raadpleeg alsjeblieft Matt Welsh's boek of zoek naar een tutorial op het net. Ik volsta met hier te zeggen dat:

Een goede editor voor beginners is joe: start het programma door jstar in te tikken. je krijgt dezelfde key bindings als in de DOS/Win editor. jed in WordStar of IDE mode is zelfs beter. Raadpleeg paragraaf Waar kun je applicaties vandaan halen om erachter te komen hoe je aan deze editors kunt komen.

Het schrijven van scripts onder bash is zo'n veelomvattend onderwerp dat hiervoor een volledig boek nodig zou zijn, en ik zal het onderwerp hier niet verder uitdiepen. Ik geef je slechts een voorbeeld van een shellscript, van waaruit je enkele basisregels kunt halen:


#!/bin/sh
# sample.sh
# Ik ben commentaar
# verander de eerste regel niet, deze moet hier aanwezig zijn
echo "Dit systeem is: `uname -a`" # gebruik de uitvoer van het commando
echo "Mijn naam is $0" # ingebouwde variabelen
echo "Je gaf me de volgende $# parameters: "$*
echo "De eerste parameter is: "$1
echo -n "Wat is je naam? " ; lees je je_naam
echo merk het verschil op: "hi $je_naam" # omsloten door "
echo merk het verschil op: 'hi $je_naam' # omsloten door '
DIRS=0 ; FILES=0
for file in `ls .` ; do
  if [ -d ${file} ] ; then # als het bestand een directory is
    DIRS=`expr $DIRS + 1`  # DIRS = DIRS + 1
  elif [ -f ${file} ] ; then
    FILES=`expr $FILES + 1`
  fi
  case ${file} in
    *.gif|*jpg) echo "${file}: grafisch bestand" ;;
    *.txt|*.tex) echo "${file}: tekstbestand" ;;
    *.c|*.f|*.for) echo "${file}: bronbestand" ;;
    *) echo "${file}: gewoon bestand" ;;
  esac
done
echo "er zijn ${DIRS} directory's en ${FILES} bestanden"
ls | grep "ZxY--%%WKW"
if [ $? != 0 ] ; then # exit code van laatste commando
  echo "ZxY--%%WKW niet gevonden"
fi
echo "genoeg... typ 'man bash' als je meer info wilt."

10.2 C

Onder UNIX is de systeemtaal C, hou ervan of haat het. Er zijn tevens nog heel wat andere talen (Java, FORTRAN, Pascal, Lisp, Basic, Perl, awk...) beschikbaar.

Aangenomen dat je bekend bent met C, zijn hier een aantal richtlijnen voor degenen die verwend zijn met Turbo C++ of één van de DOS varianten. Linux's C compiler wordt gcc genoemd en het mist alle toeters en bellen waar gewoonlijk de DOS tegenhangers van vergezeld gaan: geen IDE, on-line help, geïntegreerde debugger, enz. Het is slechts een grove commandoregel compiler, erg krachig en efficiënt. Voor het compileren van je standaard hello.c geef je op:

$ gcc hello.c

waarmee een uitvoerbaar bestand genaamd a.out zal worden aangemaakt. Geef het uitvoerbare bestand een andere naam met

$ gcc -o hola hello.c

Om een library aan het programma te koppelen, voeg je de switch -l<libname> toe. Bijvoorbeeld, om de math library te linken:

$ gcc -o mathprog mathprog.c -lm

(De -l<libname> switch forceert gcc de library /usr/lib/lib<libname>.so te koppelen; dus -lm koppelt /usr/lib/libm.so).

Als je programma uit verschillende bronbestanden bestaat, zul je gebruik moeten maken van de utility make. Laten we ervan uitgaan dat je een expression parser hebt geschreven: het bronbestand heet parser.c en # bestaande uit twee header bestanden, parser.h en xy.h. Dan wil je gebruik maken van de routines in parser.c in een programma, stel calc.c, welke op zijn beurt bestaat uit # parser.h. Wat moet je nu doen om calc.c te compileren?

Je zal een zogenoemde Makefile moeten schrijven, die de compiler laat weten wat de afhankelijkheden tussen sources en object bestanden zijn. In ons voorbeeld:


# Dit is Makefile, gebruikt om calc.c te compileren
# Druk waar aangegeven op de <TAB> toets!

calc: calc.o parser.o
<TAB>gcc -o calc calc.o parser.o -lm
# calc rekent op twee objectbestanden: calc.o en parser.o

calc.o: calc.c parser.h
<TAB>gcc -c calc.c
# calc.o rekent op twee bronbestanden

parser.o:  parser.c parser.h xy.h
<TAB>gcc -c parser.c
# parser.o rekent op drie source bestanden

# einde Makefile.

Bewaar dit bestand als Makefile en typ make om je programma te compileren; sla het alternatief op als calc.mak en typ make -f calc.mak, en natuurlijk LMP. Je kunt wat hulp krijgen over de C-functies die in man pages worden behandeld, in sectie 3, bijvoorbeeld:

$ man 3 printf

Gebruik voor het opsporen van fouten in je programma's gdb. info gdb om te leren hoe je het kunt gebruiken.

Er zijn heel veel library's beschikbaar; onder de eersten die je wellicht wilt gebruiken bevinden zich ncurses (tekstmode effecten), en svgalib (console graphics). Veel editors kunnen als IDE fungeren; emacs en jed, bijvoorbeeld, hebben als feature syntax highlighting, automatisch inspringen, enzovoort. Haal als alternatief het package rhide op vanaf ftp://metalab.unc.edu:/pub/Linux/devel/debuggers/. Het is een Borland IDE-kloon, en de kans bestaat dat het je bevalt.

10.3 X11 Programmeren

Als je er wat voor voelt om met X11 programmering aan de slag te gaan (zo moeilijk is het niet), bestaan er verscheidene library's waarmee het schrijven van X11 programma's een makkie is. De belangrijkste te bezoeken sites zijn die van GTK+, http://www.gtk.org, and Qt, http://www.troll.no. Gtk+ is een op C gebaseerde widget set oorspronkelijk ontworpen voor het grafische pakket De GIMP ( http://www.gimp.org), en het wordt gebruikt in de Gnome omgeving. Kdeveloper is gebaseerd op de op C++ gebaseerde Qt, die door KDE wordt gebruikt. Zeer waarschijnlijk zal je één van deze library's gebruiken.

Een aantal van de beste tools voor visueel programmeren zijn Kdevelop voor Qt, http://www.kdevelop.org, en Glade voor GTK+, http://glade.pn.org. Deze pagina geeft meer informatie: http://www.free-soft.org/guitool/.

Multi-Platform Programmering

Zou het niet aardig zijn als je code zou kunnen schrijven die onder Linux en Windows naadloos compileerde met gebruik van gcc? Tijdens dit schrijven zijn er een aantal widget sets die een meer of minder stabiele multi-platform programmering mogelijk maken. Zover als het de stabiliteit als volledigheid echter betreft, zou ik zeggen dat de keuze is beperkt tot praktisch één: FLTK, de Fast Light Tool Kit http://www.fltk.org. Het is verbazingwekkend klein, snel en stabiel. Het heeft tevens een semi-visuele builder genaamd Fluid.


Verder Terug Inhoud