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:
:q!
, om vi
zonder opslaan
te verlaten;:wq
, om op te slaan en te verlaten.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."
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.
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/.
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.