File: Unix-Shell-Script-HOWTO-NL.sgml

package info (click to toggle)
doc-linux-nl 20051127-2
links: PTS
area: main
in suites: etch, etch-m68k
size: 16,408 kB
ctags: 94
sloc: xml: 47,403; makefile: 312; perl: 193; sh: 116; ansic: 12; csh: 9
file content (6939 lines) | stat: -rw-r--r-- 217,842 bytes
parent folder | download | duplicates (2)
<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook V3.1//EN"[]>

<article lang="NL">
  <artheader> 
    <title>	<acronym>Unix</acronym> shell scripting		</title>
    <author>
      <firstname> Daniel					</firstname>
      <OtherName> C.						</othername>
      <surname>   von Asmuth					</surname>
    </author>

    <CopyRight>	
      <Year>	2000						</Year>
      <Holder>	D.C.von Asmuth					</Holder>
    </CopyRight>
    <date>		v1.2, 29 Augustus '00			</date>
  </artheader>
   
<abstract> 
  <para>
	Dit is een uitgebreide inleiding over het gebruik van de 
	<acronym>Unix</acronym> shell en bijbehorende hulpmiddelen 
	om scripts te schrijven. 
	Het veronderstelt enige kennis van de <acronym>Unix</acronym> 
	commandoregel, bijvoorbeeld de bash-prompt-howto. 
	Het bevat wat meer voorbeelden dan de offici&euml;le 
	handleidingen. 
  </para>
</abstract>

<sect1 id="shell">
  <title>	<acronym>Unix</acronym> en de shell		</title>
  <para>
	De shell is de <acronym>Unix</acronym> `commandostip', 
	die opdrachten van 
	de gebruikers inleest van het toetsenbord, ze uitvoert 
	en het resultaat op het scherm zet. 
	In de simpelste vorm bestaat een opdracht uit de naam 
	van een programma; de shell zal dat programma dan 
	opstarten, dat de beschikking over het toetsenbord en 
	beeldscherm krijgt, en laat een nieuwe prompt zien als 
	het programma be&euml;indigd is.
  </para>
  <para>
	Het <acronym>Unix</acronym> besturingssysteem wordt wel 
	eens voorgesteld als bestaande uit een harde kern oftewel 
	kernel, die de hardware aanstuurt en hardware aanstuurt 
	en dat de shell een schil erom heen is, die de kernel van de 
	gebruikers afschermt. Het is echter de taak van de kernel 
	om de hardware af te schermen, terwijl de shell dient om 
	toegang tot het systeem te geven. Gebruikersprogramma's 
	hoeven geen gebruik van de shell te maken; de 
	C-bibliotheek heeft bijvoorbeeld wel de functie van een 
	schil om de kernel. 
  </para>

<sect2 id="inleiding">
  <title>	inleiding					</title>
  <para>
	Dit verhaal gaat ervan uit dat u enige ervaring met 
	<acronym>Unix</acronym> hebt en dus met het typen van 
	commando's in de shell. 
	Het kan nooit kwaad om de uitgebreide informatie over een 
	besproken commando op te vragen met 
	<command>man commando</command> of (op <acronym>GNU</acronym> 
	systemen) <command>info commando</command>. 
  </para>
  <para>
	Er zijn verschillende varianten op het <acronym>Unix</acronym> 
	besturingssysteem; alle besturingssystemen die de hier 
	besproken commando's bezitten worden hier voor het gemak 
	met <acronym>Unix</acronym> aangeduid, ook al zijn ze niet 
	gebaseerd op de originele code van <abbrev>A T &amp; T</abbrev>. 
	Op een <acronym>Unix</acronym> systeem zijn vaak verschillende 
	shells te vinden. 
	Het is ook mogelijk om een shell te draaien op Windows 
	<acronym>NT</acronym>&trade;. 
	De voorbeelden bij dit verhaal zijn getest onder Linux en 
	zullen op andere systemen soms aanpassing behoeven. 
  </para>
  <para>
	De oorspronkelijke <filename>/bin/sh</filename> is de Bourne 
	shell, en de andere zijn daarvan afgeleid. 
	De nummer twee was de C-shell, die handige features had om 
	processen te besturen, maar minder handig om ermee te 
	programmeren, en dus niet verder aan de orde zal komen. 
	De nieuwere Korn shell lijkt weer meer op de Bourne shell, 
	met de features van de C-shell, plus een hele reeks eigen 
	uitbreidingen voor interaktief gebruik en programmeren. 
	De Bourne Again Shell van het <acronym>GNU</acronym> projekt 
	heeft eveneens een wijde verbreiding gekregen.
  </para>
</sect2>

<sect2 id="tryout">
  <title>	Mijn eerste scriptje				</title>
  <para>
	Het bijzondere aan de shell is dat hij zowel een handige 
	commandoverwerker is voor interaktief gebruik als een 
	programmeertaal. 
	Verschillende delen van een <acronym>Unix</acronym> 
	besturingssysteem bestaan uit shell scripts, omdat deze 
	gemakkelijk door de gebruiker aan diens behoefte kunnen 
	worden aangepast, wat vooral systeembeheerders waarderen. 
	Shell scripts worden ook vaak gebruikt als een schil om een 
	complexe applicatie. 
  </para>
  <para>
	Het is een kleine moeite om een korte reeks veel gebruikte 
	commando's samen te voegen tot een scriptje: maak met 
        <command>vi</command> 
	(c.q. uw favoriete editor) een file <filename>voorbeeld</filename>
	aan met de volgende, vrij willekeurige,  inhoud:
    <informalexample>
      <programlisting>
date
uname -a
who 								</programlisting>
    </informalexample>

	Vervolgens typt u
    <command>
	chmod ugo+rx voorbeeld
    </command>
	waarmee het tekstbestand tot programma wordt gepromoveerd, 
	dat met
    <command>
	./voorbeeld
    </command>
	kan worden uitgevoerd. De kernel is zelf in staat te bepalen 
	of een uit te voeren file een script of binair programma bevat. 

  </para>
  <para>
	In het voorbeeld is de directory waar het programma zich 
	bevindt expliciet opgegeven. 
	Als die wordt weggelaten zal de shell de lijst van directory's 
	doorzoeken die in de speciale variabele <Envar>$PATH</Envar> 
	staat. 
	Het is enigszins riskant om de aktuele directory 
	(<filename>.</filename>) in het zoekpad op te nemen.
</para>
<para>
	Een standaard vergissing is om eigen programma's de naam 
	<filename>test</filename> te geven. 
	Helaas is <firstterm>test</firstterm> een ingebouwd commando 
	van de shell. 
	De shell heeft niet zoveel ingebouwde commando's: 
	het meeste werk wordt door externe programma's gedaan. 

</para>
</sect2>

<sect2 id="hallo">
  <title>	hallo						</title>
  <para>
	Als volgende voorbeeld de nederlandstalige versie van het 
	onvermijdelijke nutteloze programma <firstterm>hello</firstterm>, 
	bekend van Kernighan &amp; Ritchie.

    <informalexample>
      <programlisting>
#!/bin/sh 
# dit programma zegt vriendelijk goedendag 

echo Hallo, allemaal! ; exit 0					</programlisting>
    </informalexample>

	Dit lijkt al iets meer op een programma. 
	In de eerste regel staat achter <command>#!</command>  
	aangegeven welk programma het script moet uitvoeren. 
	Normaliter is dat de shell waarmee u inlogt; 
	u kunt hiermee voorkomen dat een programma niet werkt 
	als het bijvoorbeeld vanaf de C-shell wordt gestart. 
	Aan de andere kant zal een script dat begint met 
	<command>#!/bin/bash</command> niet werken op een systeem 
	waar die shell in <filename>/usr/local/bin</filename> 
	staat of afwezig is. 
	Deze eigenschap is vooral handig voor scripts in andere 
	talen, bijv.:

    <informalexample>
      <programlisting>
#!/usr/bin/perl
print "Hallo, allemaal!\n"					</programlisting>
    </informalexample>

	De programmeertaal <acronym>Perl</acronym> wordt hier niet 
	verder behandeld. 
	Voor de rest geeft een hekje aan dat de rest van de regel 
	kommentaar is. 
	Een lege commandoregel is toegestaan. 
	Behalve het einde van de regel kan ook een puntkomma 
	worden gebruikt om opdrachten te scheiden die na elkaar 
	worden uitgevoerd.
  </para>
  <para>
	De opdracht <firstterm>echo</firstterm> is een ingebouwde 
	functie van de shell, net als trouwens exit. 
	<command>Echo</command> zorgt ervoor dat de resterende 
	woorden op het 
	<firstterm>standaard uitvoerkanaal</firstterm> (bijv. het 
	scherm) worden afgedrukt. 
	Shell commando's, argumenten en vlaggen moeten atlijd  
	van elkaar worden gescheiden door spaties of andere 
	scheidingstekens. 
  </para>
  <para>
	De opdracht <firstterm>exit</firstterm> be&euml;indigt het 
	script, ook als er nog opdrachten volgen; het gebruik ervan 
	is niet verplicht. 
	Net als de exit functie in een C programma wordt er een foutcode 
	geretourneerd, die 0 bedraagt als er geen fout is opgetreden. 
	Typ maar eens de volgende regels in achter de prompt.

    <informalexample>
      <programlisting>
true
echo $? 
false
echo $?								</programlisting>
    </informalexample>

	De variabele <envar>$?</envar> krijgt de 
	<firstterm>exit status</firstterm> van het laatst uitgevoerde 
	commando of script. 
	Na exit of het einde van een script gaat de shell verder met 
	het aanroepende script of vraagt de gebruiker om invoer. 
	<command>True</command> en <command>false</command> zijn 
	externe programma's die niets doen en alleen in shell 
	programma's nut hebben. 
	Het resultaat verschilt nogal van Boolean types in 
	andere programmeertalen. 
  </para>
  <para>
	Als u inlogt zal de shell eerst het script 
	<filename>/etc/profile</filename>
	uitvoeren, waarin zich algemene instellingen bevinden, 
	gevolgd door <filename>.profile</filename> in uw eigen 
	directory, waarin u uw persoonlijke instellingen kwijt kunt. 
	Bash en ksh kennen ook initialisatie files 
	<filename>~/.bashrc</filename> en <filename>~/.kshrc</filename> 
	die iedere keer uitgevoerd worden 
	als een interactieve shell start, bijvoorbeeld bij 
	het openen van een xterm. 
  </para>
</sect2>

<sect2 id="herhaling">
  <title>	een herhalingsoefening				</title>
  <para>
	De rest van dit hoofdstuk wordt besteed aan <acronym>Unix</acronym> 
	en de shell, zonder dat er verder programmeren bij komt kijken. 
	De behandeling zal erg oppervlakkig blijven; in 
	<xref linkend="tools"> komen we er uitgebreid op terug. 
  </para>
  <para>
	Het centrale concept in <acronym>Unix</acronym> is de 
	<firstterm>file</firstterm> oftewel het bestand. 
	Files worden voortdurend gebruikt waar informatie voor 
	min of meer lange tijd moet worden bewaard. 
	Een file is een reeks bytes, die meestal op een schijf 
	wordt bewaard. 
	De belangrijkste operaties zijn het lezen of schrijven 
	van een aantal bytes. 
	Daarbij wordt de <firstterm>file pointer</firstterm> 
	of bladwijzer om het aantal 
	gelezen of geschreven bytes verplaatst. 
	Verder is het mogelijk om de file pointer naar een 
	opgegeven punt te verplaatsen en de lengte van het 
	bestand in te krimpen tot bijvoorbeeld nul bytes.
  </para>
  <para>
	De inhoud van een bestand ligt niet vast. 
	<acronym>Unix</acronym> maakt vaak gebruik van tekstbestanden. 
	Een byte staat dan voor een letterteken (karakter) van  
	het <acronym>ASCII</acronym> alfabet. 
	Het teken &lt;LF&gt; oftewel 0xa oftwel ^J oftewel \n 
	geeft het einde van een regel aan. 
	Er is geen teken nodig om het einde van een bestand te markeren,
        maar ^D kan worden gebruikt om invoer van de terminal te
	be&euml;indigen.   
  </para>
  <para>
	Veel tools gaan ervan uit dat een bestand tekst bevat. 
	Bijvoorbeeld zal
	<command>cat voorbeeld</command>
	de inhoud van het bestand over het scherm laten lopen. 
	Als het bestand echter geen tekst bevat, dan kan de 
	terminal de kluts kwijt raken van de stuurcodes; 
	doe dus geen
	<command>/bin/cat /bin/cat</command>.
	Met <command>cat -v</command> loopt u geen gevaar.
  </para>
  <para>
	In sommige Unices kunt u de schade repareren met 
	het commando <command>reset</command>. 
	De oude methode is de terminal uit en weer aan te zetten. 
	De schade is te voorkomen. 
	Het kommando <command>file hallo</command>
	zou iets moeten geven als
	<computeroutput>hallo: Bourne shell script text</computeroutput>.
  </para>
  <para>
	Als file een frase met het woord `executable' erin retourneert, 
	hebben we te maken met een binair programma. 
	Een binair programma kun je alleen uitvoeren: dat werkt wel 
	een stuk sneller dan een ingewikkeld shell script. 
	File kan zich ondanks zijn `magic' uiteraard vergissen. 
  </para>
  <para>
	Verder zijn er speciale files, waarmee bijvoorbeeld apparaten 
	kunnen worden afgelezen of beschreven alsof het files waren; 
	een tape wordt bijvoorbeeld bediend als een hele lange 
	pseudo-file, waarvan de grootte aan een vast maximum is 
	gebonden. 
	Deze worden vaak in de <filename>/dev</filename> directory 
	gevonden. 
  </para>
  <para>
	Tekst die naar <filename>/dev/tty</filename> wordt geschreven, 
	wordt wel zichtbaar gemaakt, maar niet opgeslagen. 
	Een poging om <filename>/dev/tty</filename> uit te lezen 
	retourneert niet de geschreven tekst, maar van het toetsenbord 
	ingevoerde tekens. 
	<acronym>Unix</acronym> zal u laten wachten totdat er een regel 
	is ingevoerd, c.q. op de return-toets is gedrukt. 
  </para>
  <para>
	Om een tekstbestand uit te printen zou je 
	<command>cat hallo &gt;/dev/lp0</command>
	of iets dergelijks kunnen doen, maar <acronym>Unix</acronym> 
	staat dat enkel aan de user <firstterm>root</firstterm> toe.  
	De juiste manier om een bestand te printen is via het printer 
	spoolprogramma met <command>lpr hallo</command>
  </para>
  <para>
	Een ander bestand dat in scripts gebruikt kan worden is 
	<filename>/dev/null</filename>, ook wel de bittenbak genoemd, 
	omdat alle data die er naartoe worden geschreven direkt 
	worden weggegooid in tegenstelling tot de vuilnisbak van 
	de Macintosh&trade;. 
	Lezen uit <filename>/dev/null</filename> is toegestaan, maar 
	er zal niets uit komen. 
  </para>
  <para>
	De <firstterm>directory's</firstterm> kunnen worden beschouwd 
	als een speciaal soort bestand, dat alleen met 
	speciale opdrachten als <command>ls</command>, 
	<command>cp</command>, <command>mv</command>, 
	<command>rm</command> en <command>ln</command> kan worden 
	gemanipuleerd. 
	Directory's bevatten weinig anders als de namen van files 
	en directory's. 
	Daarom is voor een opdracht als 
	<command>rm -f ./voorbeeld</command>
	schrijfpermissie op de aktuele directory vereist, maar geen 
	permissie op het bestand. 
	In scripts gebruiken we vaak de <option>-f</option> optie,
	zodat <acronym>Unix</acronym> niet nog eens vraagt of we het wel 
	zeker weten.
  </para>
  <para> 
	Een file kan meerdere namen of <firstterm>links</firstterm> 
	hebben; met het commando <command>ln</command> wordt een 
	nieuwe link naar een bestaand bestand gelegd. 
	<command>ln /bin/ls /bin/dir</command>
	maakt een nieuw commando, <command>dir</command> geheten, 
	dat hetzelfde doet als <command>ls</command>. 
	Met <command>rm</command> wordt het aantal links met 
	&eacute;&eacute;n verminderd. 
	Pas wanneer dat tot nul is gedaald en het bestand niet 
	in gebruik is, zal <acronym>Unix</acronym> het bestand 
	daadwerkelijk verwijderen. 
  </para>
  <para>
	Het is niet mogelijk naar een link te maken naar een directory 
	of een bestand op een andere schijf. 
	Deze beperking wordt opgeheven door de 
	<firstterm>symbolic link</firstterm> of snelkoppeling, 
	die je maakt met <command>ln -s</command>. 
	Een snelkoppeling loopt het gevaar dat het bestand waar hij 
	naar verwijst niet bestaat of dat een circulaire keten van 
	links ontstaat. 
	Vergelijk de uitvoer van <command>ls -lL</command> eens
	met <command>ls -l</command>. 
    <informalexample>   
      <screen>
-rwxr-xr-x 1 daniel users 769 Mai 29 example
-rwxr-xr-x 1 daniel users 769 Mai 29 voorbeeld

lrwxrwxrwx 2 daniel users   3 Jun 6 example -> wie
lrwxrwxrwx 2 daniel users   3 Jun 6 voorbeeld -> wie		</screen>
    </informalexample>
  </para>
</sect2>

<sect2 id="processen">
  <title>	processen en hun in- en uitvoer			</title>
  <para>
	We zagen al dat een programma in <acronym>Unix</acronym> 
	wordt opgeslagen in een bestand. 
	Een <acronym>Unix</acronym> <firstterm>proces</firstterm> 
	is een lopend programma, met zijn data en de context waarin 
	het draait zoals de huidige directory. 
	Moderne besturingssystemen kunnen een proces verdelen in 
	zgn. <firstterm>threads;</firstterm> 
	en programma kan daarmee meerdere taken tegelijk uitvoeren, 
	die hun data delen, wat al snel in een chaos kan ontaarden.
  </para>
  <para>
	De shell zal, met uitzondering van ingebouwde opdrachten, 
	commando's uitvoeren door er aparte processen voor te starten. 
	Shell scripts worden doorgaans in afzonderlijke processen 
	(subshells) uitgevoerd. 
	Ondanks dat <acronym>Unix</acronym>' 
	<firstterm>multi-tasking</firstterm> effici&euml;nter 
	werkt dan huis-, tuin- en keuken besturingssystemen, maakt 
	het voortdurende maken en opruimen van processen shell 
	scripts een stuk langzamer dan andere programmeertalen. 
  </para>
  <para>
	Als een extern programma is opgestart zal de shell gewoon 
	wachten totdat hij een seintje ontvangt van de kernel dat het 
	kindproces is gestorven c.q. be&euml;indigd.
  </para>
  <para>
	Door een `ampersand' achter een commando te zetten als in
	<command>voorbeeld&</command>, zal het `in de achtergrond' 
	worden verwerkt, en de shell onmiddellijk om de volgende 
	opdracht vragen.
  </para>
  <para>
	Een voorbeeld van een ingebouwde opdracht is het commando 
	<command>cd</command>. 
	Beginners verbazen zich er soms over dat een 
	<command>cd</command> opdracht binnen een shell script 
	wel wordt uitgevoerd, maar het effekt ervan vergeten is 
	als het script be&euml;indigd is en terug keert naar de 
	interactieve shell. 
  </para>
  <para>
	Commando's in een script kunnen ook worden uitgevoerd met bijv.
	<command>. ./voorbeeld</command>.
	Hiermee worden de opdrachten in het bestand voorbeeld 
	binnen de lopende shell uitgevoerd en werkt <command>cd</command>
	bijvoorbeeld wel. 
	Een minder gebruikte mogelijkheid is om programma's (niet 
	alleen scripts) te starten met de opdracht <command>exec</command> 
	ervoor. 
	Er wordt dan geen apart proces gemaakt, maar het nieuwe 
	programma wordt in het lopende proces geladen en vervangt het,  
	zodat het oorspronkelijke programma na afloop niet verder kan 
	gaan. 
  </para>
  <para>
	Tot de context van een proces behoren ook de 
	standaard invoer-, uitvoer- en error-kanalen. 
	Voor een interactieve shell verwijst de standaard invoer naar
	het toetsenbord en de uitvoer en error kanalen naar het 
	beeldscherm. 
	Als u bent ingelogd via een modem of netwerk, dan verwijzen 
	deze kanalen naar uw scherm en toetsenbord in plaats 
	van dat van de computer waarop de shell draait.
  </para>
  <para>
	Met <command>./voorbeeld &lt;data &gt;resultaat</command>
	worden de kanalen omgeleid zodat de inhoud van het bestand 
	<filename>data</filename> zal worden gelezen en de uitvoer 
	in het bestand <filename>resultaat</filename> komt. 
	Eventuele foutmeldingen komen nog op het scherm. 
  </para>
  <para>
	De notatie 
	<command>./voorbeeld &lt;data &gt;&thinsp;&gt;resultaat 2>&1 &</command>
  	zegt dat het script in de achtergrond moet draaien. 
	We zien toch geen resultaten. 
	Het dubbele `groter dan' teken geeft aan dat de uitvoer 
	achter de bestaande inhoud van <filename>resultaat</filename> 
	moet komen in plaats van het bestand eerst te wissen. 
  </para>
  <para>
	De aanduiding <command>2>&1</command> geeft aan dat het 
	standaard error-kanaal (de tweede 
	<firstterm>file-descriptor)</firstterm> een kopie is van 
	nummer 1 (standaard uitvoer), dus foutmeldingen en resultaten 
	verschijnen door elkaar heen in het bestand 
	<filename>resultaat</filename>; 
	het standaard-invoerkanaal heeft file-descriptor nummer 0. 
	Kind processen erven file-descriptors (open bestanden); 
	de standaard kanalen zijn altijd open. 
	Als de standaard kanalen zijn omgeleid naar bestanden zijn 
	toetsenbord en beeldscherm toch te benaderen door om te leiden 
	naar het pseudo-bestand <filename>/dev/tty</filename>. 
  </para>
  <para>
	Een <firstterm>here-document</firstterm> is een bijzonder 
	geval van omleiding waarin de te verwerken gegevens in het 
	script-bestand zelf staan. 

    <informalexample>
      <programlisting>
fox=dog; dog=fox
cat &lt;&thinsp;&lt;woord
The quick brown $fox jumps over the lazy $dog. 
&hellip;
woord 								</programlisting>
    </informalexample>

	De rest van het script tot aan woord wordt dan als invoer 
	gebruikt voor het commando (bijv. <command>cat</command>). 
	Het woord dat als markering dient moet letterlijk worden 
	herhaald op een aparte regel. 
	De shell zal wel eventuele substituties uitvoeren op de data. 
  </para>
</sect2>

<sect2 id="wildcards">
  <title>	 een les over `ls': jokertekens			</title>
  <para>
	Het volgende commando is een eenvoudige vervanging voor 
	<firstterm>ls</firstterm>.
    <informalexample> 
      <programlisting> 
echo * | tr  " " "\n" | column					</programlisting>
    </informalexample>
  </para>
  <para>
	Het illustreert hoe de shell <firstterm>jokertekens</firstterm> 
	of wildcards behandelt. 
	Als er in een woord een jokerteken voorkomt, dan zal de 
	shell dat woord vervangen door alle bestandsnamen in 
	de huidige directory die overeenkomen met dat zoekpatroon. 
  </para>
  <para>
	De <literal>*</literal> staat voor iedere reeks van nul 
	of meer tekens, dus <command>ls a*z</command> geeft de 
	lijst van alle bestanden waarvan de naam begint met een 
	a en eindigt op z, zoals `alcatraz' (onder DOS/Windows 
	kunt u de * alleen aan het eind gebruiken). 
	Als er geen corresponderende bestanden zijn dan blijft 
	de asterisk staan, bijv.
	<command>	echo Wie*dit*leest*is*gek		</command>
  </para>
  <para>
	Het is mogelijk te voorkomen dat jokertekens worden 
	vervangen door ze tussen aanhalingstekens te zetten 
	of door er een backslash (<literal>\</literal>) voor 
	te zetten; 
	<command>	ls \* 					</command>
	komt van pas, want een bestand met de naam 
	<literal>*</literal> is niet uitgesloten. 
  </para>
  <para>
	Een <literal>.</literal> corrrespondeert met een 
	willekeurig teken, zodat de shell <literal>p?n</literal> 
	kan vervangen door <literal>pan pen pin pon</literal>. 
	Een reeks van tekens tussen rechte haken kan worden 
	vervangen door &eacute;&eacute;n van die tekens, bijv. 
	<command>ls fig-[123456789].jpg</command> door 
	<literal>ls fig-1.jpg fig-2.jpg				</literal> 
  </para>
  <para>
	Let erop dat <command>ls *</command> ook de inhoud van 
	subdirectory's weergeeft. 
	<command>ls</command> geeft alleen files in de huidige 
	directory en <command>ls */</command> geeft de 
	inhoud van alle subdirectory's. 
 </para>
</sect2>

<sect2 id="pijpleidingen">
  <title>	pijpleidingen					</title>
  <para>
	Twee processen kunnen gemakkelijk via een 
	<firstterm>pijp</firstterm> gekoppeld worden, zodat 
	data die uit de standaard uitvoer van het eerste proces 
	komen, door de standaard invoer van het tweede proces 
	worden verwerkt, bijv.:
	<command>ps -ef | sort</command>
  </para>
  <para>
	Het eerste commando geeft een lijst van alle processen 
	die momenteel draaien en het <command>sort</command> 
	commando sorteert ze (op de inlognaam van de gebruiker; 
	werkt helaas niet op alle <acronym>Unix</acronym> versies 
	gelijk). 
	Als in een pijp een commando wordt gebruikt dat een 
	filenaam als argument nodig heeft, dan kan meestal `-' 
	worden gebruikt om de standaard invoer aan te duiden; 
	veel commando's gebruiken automatisch de standaard invoer als 
	ze geen bestandsnaam meekrijgen. 
  </para>
  <para>
	Een programma dat data van het standaard invoerkanaal 
	leest en na een eenvoudige bewerking naar het standaard 
	uitvoerkanaal schrijft noemen we een <firstterm>filter.</firstterm>
	Het eenvoudigste filter is <firstterm>cat,</firstterm> 
	dat data onveranderd kopieert; <firstterm>sort</firstterm> 
	is ingewikkelder. 
  </para>
  <para>
	Een ander filter is <firstterm>dd;</firstterm>.
	Voor details zie <xref linkend="split">; hier volgt een 
	voorbeeld hoe je een bestand kunt converteren 
	naar hoofdletters: 
	<command>dd conv=ucase &lt;voorbeeld &gt;gesorteerd 
	2&gt;/dev/null</command>
  </para>
  <para> 
	Dd wordt onder <acronym>Unix</acronym> wel gebruikt om een floppy 
	disk te kopi&euml;ren met  
	<command>dd if=/dev/fd0 of=image-file</command>
	Vervolgens verwissel je de disks en kopi&euml;ert de 
	image file terug naar floppy. 
  </para>
  <para>
	Vergelijk het resultaat van  
	<command>find /bin | sort</command> 
	eens met <command>ls -1 /bin/*</command>
	en u ziet dat <command>ls</command> de gewoonte heeft de 
	uitvoer te sorteren. 
	Bij gebruik van een pijp wordt de uitvoer van het eerste 
	proces opgeslagen in een kleine hoeveelheid buffergeheugen. 
	Als dat vol is, wordt de producent stilgezet totdat de 
	consument deze data heeft verwerkt. 
  </para>
  <para>
	Om de uitvoer van een commando op het scherm te bekijken 
	en tegelijk een kopie in een bestand te bewaren gebruikt men 
	iets als
	<command>./voorbeeld 2>&1 | tee resultaat</command> 
  </para>
  <para>
	Als u beschikt over het tooltje 
	<ulink url="http://199.103.168.8:4984/web1/hak/netcat.html">
	  <firstterm>netcat</firstterm> 
	</ulink>
	dan kunt u ook op eenvoudige wijze gegevens over 
	een netwerk versturen. 
	In plaats van <command>prog1 | prog2</command> start u op 
	machine <replaceable>host</replaceable> 
	<command>netcat -v -l -p 1234 | <replaceable>prog2</replaceable></command> 
	en op de andere machine doet u
	<command><replaceable>prog1</replaceable> | netcat host 1234</command> 
	Hierin is <literal>1234</literal> de gebruikte 
	<acronym>IP</acronym> poort: een min of meer willekeurig 
	nummer, mits de betreffende poort nog ongebruikt is, en 
	<varname>prog1</varname> en <varname>prog2</varname> zijn 
	willekeurige commando's. 
	Netcat fungeert hierin als een pijp tussen processen op 
	verschillende computers. 
  </para>
  <para>
	Alle <acronym>Unix</acronym> versies kennen de bovengenoemde 
	<firstterm>anonieme pijp;</firstterm> 
	sommige kennen ook een pijp die als een speciale file in het 
	bestandssysteem voorkomt. 
	Een pijp kan worden aangemaakt met 
	<command>mkfifo pijp</command> of
	<command>mknod pijp p</command>
	Het <firstterm>mknod</firstterm> commando wordt ook gebruikt 
	om speciale files van het <firstterm>block</firstterm> of 
	<firstterm>character</firstterm> type aan te maken. 
	Probeer maar eens welke output het <command>file</command> commando 
	op een speciale file geeft. 
  </para>
</sect2>
</sect1>
<!-- eind eerste hoofdstuk 					-->

<sect1 id="programmeren">
  <title>	elementair shell programmeren			</title>
  <para>	
	In dit artikel wordt de shell geprogrammeerd met 
	behulp van script files. 
	Moderne shells bezitten bovendien de mogelijkheid 
	om korte macro's te defini&euml;ren met de 
	<firstterm>alias</firstterm> opdracht
	bijv. <command>alias l='ls -alg '</command>
  </para>
  <para>
	Aliassen kunnen ingewikkelde commando's vervangen 
	door eenvoudiger te onthouden namen. 
	Ze worden vaak gedefinieerd in 
	<filename>~/.profile</filename>, een shell script 
	dat elke keer als iemand inlogt wordt uitgevoerd. 
	Met <firstterm>unalias</firstterm> wordt de 
	definitie weer verwijderd. 
  </para>
<sect2 id="variabelen">
  <title>	variabelen					</title>
  <para>	
	De werking van de shell is vrij ingewikkeld. 
	Er zijn verschillende manieren waarop de shell 
	reeksen tekens zal vervangen door andere. 
	Een daarvan is de expansie van aliassen: 
	het kommando <command>l ~/*/a* </command>
	kan worden uitgeschreven tot bijvoorbeeld
    <computeroutput>
	/bin/ls -alg /home/gast/agf/aardappel 
	/home/gast/agf/aardbei /home/gast/agf/appel 
	/home/gast/autos/audi
    </computeroutput>
  </para>
  <para>
	De alias kwamen we zojuist tegen; aan 'ls' is hier 
	het pad toegevoegd. 
	De tilde staat voor de <firstterm>home directory</firstterm>, 
	waarop de gebruiker `gast' inlogt; de uitdrukking `a*' 
	wordt door de shell vervangen door een lijst van 
	filenamen die met een a beginnen. 
  </para>
  <para>
	Een <firstterm>variabele</firstterm> is een naam, 
	die door de shell aan een reeks tekens wordt gekoppeld 
	met bijv. <command>L='ls -alg '</command>
  </para>
  <para>
	Het kommando <command>set</command> zonder argumenten 
	geeft een lijst van alle op dat moment gedefinieerde
	variabelen met hun waarden. 
	De shell heeft zelf een aantal ingebouwde variabelen 
	en andere variabelen worden bij het inloggen gedefinieerd, 
	zoals <envar>$HOME</envar>, de home directory van de gebruiker 
	en <envar>$PWD</envar>, de huidige directory. 
  </para>
  <para>
	We zijn ook al de variabele <envar>$PATH</envar> tegengekomen, 
	ook wel het zoekpad genoemd. 
	De waarde van <envar>$PATH</envar> is een lijst van directory's, 
	gescheiden door dubbele punten. 
	Als een commando dat geen slash (/) in de naam heeft, 
	niet is ingebouwd in de shell of als alias is 
	gedefinieerd, wordt gezocht of het commando overeenkomt 
	met de naam van een file in een van deze directory's. 
  </para>
  <para>
	Hetzelfde kunt u doen met het <command>which</command> commando, 
	dat echter niet op alle <acronym>Unix</acronym> systemen bestaat, 
	of waarvoor soms een alternatief <command>whence</command> voor 
	bestaat. 
	Voorbeeld: <command>which find</command>
  </para>
  <para>
	De shell zal een dollarteken gevolgd door de naam van een 
	variabele vervangen door de waarde van de betreffende variabele. 
	Nu kunnen we hetzelfde effekt als voorheen krijgen met
	<command>$L</command>.
  </para>
  <para>
	Hadden we echter L de waarde `l' gegeven, dan zou het resultaat 
	geweest zijn: 
	<computeroutput>l: command not found			</computeroutput>
	Bash en ksh brengen ons in dit geval verder met
	<command>eval $L</command> 
	Hiermee wordt de uitdrukking `l' nog eens ge&euml;valueerd, 
	nadat de shell de waarde van L 
	heeft gesubstitueerd. 
	Een opdrachtregel als
	<command>$apenkool</command>
	zal niets doen en ook geen foutmelding opleveren als de 
	betreffende variabele niet gedefinieerd is. 
  </para>
  <para>
  	We krijgen de waarde van de variabele <envar>L</envar> terug 
	met <command>echo $L</command>. 
	Het dollarteken maakt eigenlijk geen deel uit van de naam. 
	Als we nu een script of ander programma aanroepen waarin de 
	waarde van variabele L gebruikt wordt, zal die echter 
	ongedefinieerd zijn, tenzij we eerst de opdracht
	<command>export L</command>
	geven om een lokale variabele te exporteren naar de 
	programma-omgeving. 
	Echo en export zijn ingebouwde functies van de shell. 
  </para>
</sect2>
<sect2 id="aanhaling">
  <title>	aanhaling					</title>
  <para>	
	In de vorige paragraaf werd de waarde die aan L werd 
	toegewezen omgeven door enkele aanhalingstekens. 
	Deze zijn nodig om van de uitdrukking &eacute;&eacute;n 
	woord te maken, inclusief de spaties. 
	Dubbele aanhalingstekens hadden ook voldaan. 
	Het verschil is, dat binnen dubbele aanhalingstekens de 
	variabelen nog steeds worden vervangen door hun waarde, 
	en alleen tekst tussen enkele aanhalingstekens letterlijk 
	wordt overgenomen. 
  </para>
  <para>
	Tussen dubbele aanhalingstekens bestaat nog de mogelijkheid 
	om aan te geven dat een enkel teken exact moet worden 
	gekopi&euml;erd; 
	dit gebeurt door er een backslash voor te zetten als 
	<firstterm>escape symbool</firstterm>. 
  </para>
  <para>
	De programmeertaal C definieert een aantal escape
	symbolen, die ook in de shell kunnen worden gebruikt.
    <variablelist>
      <varlistentry>
	<term><literal>\a</literal>	(alert)			</term>
	<listitem>
	  <simpara>	&lt;BELL&gt; (laat een pieptoon horen)	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>\b</literal>	(backspace)		</term>
	<listitem>
	  <simpara>	&lt;BS&gt; verplaatst de cursor een stap 
			terug. (`x\bx' kan worden gebruikt om 
			een x vet af te drukken.)		</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>\f</literal>	(formfeed)		</term>
	<listitem>
	  <simpara>	&lt;FF&gt; geeft een nieuwe pagina	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>\n</literal>	(newline)		</term>
	<listitem>
	  <simpara>	&lt;LF&gt; geeft een nieuwe regel	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>\r</literal>	(carriage return)	</term>
	<listitem>
	  <simpara>	&lt;CR&gt; verplaatst de cursor terug 
			naar het begin van de regel		</simpara>
	</listitem>
      </varlistentry> 
      <varlistentry>
	<term><literal>\t</literal>	(tabulator)		</term>
	<listitem>
	  <simpara>	&lt;TAB&gt; verplaatst de cursor naar
			de volgende tab-stop			</simpara>
	</listitem>
      </varlistentry> 
      <varlistentry>
	<term><literal>\t</literal>	(vertical tab)		</term>
	<listitem>
	  <simpara>	&lt;VT&gt; verplaatst de cursor een stap
			omlaag					</simpara>
	</listitem>
      </varlistentry>
    </variablelist>

	Verder kunnen <acronym>ASCII</acronym> tekens worden 
	aangeduid in octale notatie, bijvoorbeeld \007 (ook \a) 
	voor het &lt;BELL&gt; teken. 
  </para>
  <para>
	Hierbij zij aangetekend dat de echo opdracht van de shell 
	van zichzelf een &lt;LF&gt; (regeleinde) toevoegt, tenzij 
	er <command>echo -n</command> is gebruikt; 
	gebruikers van bash moeten echo de <option>-e</option> 
	vlag meegeven om de escapes te laten werken. 
	Het resultaat kan verschillen als er oktale codes boven 0200 
	worden gebruikt. 
  </para>
  <para>
	Een speciale functie van de shell is de 
	<firstterm>commando substitutie</firstterm>, aangegeven door 
	achterwaartse aanhalingstekens, bijv.
	<command>L=`l`</command> 
	Hier wordt een aparte subshell gestart, waarin het commando 
	<command>ls -alg</command> wordt uitgevoerd; 
	het resultaat is weer te zien met
	<command>echo "$L"</command> 
  </para>
  <para>
	Probeer nu maar eens wat er gebeurt als de dubbele 
	aanhalingstekens worden weggelaten. 
	Een alternatieve notatie is om de te substitueren opdracht 
	tussen <literal>$(</literal> en <literal>)</literal> te zetten. 
	Daarmee kunnen gesubstitueerde processen bovendien genesteld 
	worden. 
	Let op het verschil tussen de notaties 
	<command>$( lijst;van;commando's)</command> en
	<command>(lijst;van;commando's)</command>: beide voeren de 
	opgegeven opdrachten uit in een aparte subshell, maar 
	waar de uitvoer van de tweede variant gewoon tussen de 
	standaard uitvoer verschijnt, wordt de uitvoer in het eerste 
	geval een deel van de opdrachtregel. 
  </para>
  <para>
	Om een variabele af te scheiden van de rest van de tekst kan 
	deze worden omgeven door dubbele aanhalingtekens of door 
	accolades, zodat de volgende uitdrukkingen alle de waarde van 
	de variabele <envar>L</envar> evalueren en er de letters `OVE' 
	achter plakken.
    <informalexample>
      <programlisting>
echo "$L"OVE
echo ${L}OVE
echo "${L}OVE"							</programlisting>
    </informalexample>
	De beperkingen van de shell als programmeertaal worden 
	duidelijk als je bij de variabele <envar>i</envar>
	1 wilt optellen. 
	Rekenen is mogelijk met behulp van het hulpprogramma 
	<firstterm>expr</firstterm>, bijv. 
	<command>i=$(expr $i + 1)</command>
	Let erop dat de shell spaties nodig heeft om de woorden 
	te onderscheiden. 
  </para>
</sect2>
<sect2 id="parameters">
  <title>	parameters					</title>
  <para>	
	We hebben inmiddels enkele manieren gezien waarop de 
	shell ingevoerde tekens bewerkt, zoals de substitutie 
	van variabelen en verwijderen van aanhalingstekens. 
	Vervolgens wordt een commando in woorden opgeknipt, 
	waarbij witruimte de scheiding tussen de woorden aangeeft. 
	De variabele <envar>IFS</envar> bevat de tekens die 
	hierbij als scheidingsteken worden gebruikt, 
	standaard zijn dit &lt;SP&gt;, &lt;TAB&gt; en &lt;LF&gt;. 
	Let erop dat een uitdrukking tussen enkele of dubbele 
	aanhalingstekens altijd als een woord wordt gezien, 
	ook al bevat ze spaties. 
	Twee aanhalingstekens direkt achter elkaar tellen 
	als een woord met lengte nul (0). 
  </para>
  <para>
	In een shell script zijn de parameters (c.q. argumenten 
	en vlaggen) beschikbaar via de speciale variabelen 
	<envar>$0</envar> t/m <envar>$9</envar> (en zonodig ook 
	<envar>${10}</envar> en hoger). 
	<envar>$0</envar> is de naam van het programma zelf. 
	Daarmee is het mogelijk om bijvoorbeeld 
	<firstterm>gunzip</firstterm> een link naar 
	<firstterm>gzip</firstterm> te laten zijn en het programma 
	verschillend te laten werken afhankelijk van de naam 
	waarmee het is aangeroepen. 
  </para>
  <para>
	De shell kent nog een aantal speciale parameters; 
	we zijn <envar>$?</envar> al tegengekomen, dat telkens de 
	exit status van het laatste uitgevoerde commando krijgt. 
	<envar>$$</envar> bevat het <acronym>Unix</acronym> 
	proces nummer van de shell die uw script draait. 
	Dit kan ook handig zijn om unieke filenamen te maken voor 
	tijdelijke bestanden. 
  </para>
  <para>
	De parameters <envar>$*</envar> en <envar>$@</envar> leveren 
	de complete parameterlijst op, met uitzondering van 
	<envar>$0</envar>.  
	Tussen dubbele aanhalings tekens gezet zal 
	<envar>"$*"</envar> een woord opleveren dat overeenkomt 
	met <computeroutput>"$1 $2 $3&hellip;"</computeroutput>, 
	terwijl <envar>"$@"</envar> een reeks woorden 
	<computeroutput>"$1" "$2" "$3"&hellip;</computeroutput> geeft. 
	De variabele <envar>$#</envar> geeft het aantal argumenten. 
  </para>
  <para>
	Hieronder volgt een scriptje om met het gebruik van 
	parameters door de shell te experimenteren. 
	De <command>shift</command> opdracht gooit de eerste parameter 
	weg en schuift de rest een positie op, met uitzondering van 
	<envar>$0</envar>. 
	De regel met <command>while</command> wordt nader toegelicht 
	in <xref linkend="herhalingen">. 
    <informalexample>
      <programlisting>
#!/bin/sh

echo "Script $0 aangeroepen met $# parameters:"

while [ $# -gt 0 ]
do 
  echo -n "\"$1\" "
  shift
done
echo
exit 								</programlisting>
    </informalexample>
  </para>
  <para>
	Het verwerken van de parameterlijsten kan nog wat 
	ingewikkelder worden. 
	Zo kan met de notatie <envar>${parameter:-woord}</envar>
	een standaardwaarde (default) worden aangegeven voor een 
	weggelaten parameter of met <envar>{$parameter:?woord}</envar> 
	een foutmelding worden gegeven als de parameter verplicht is, 
	bijvoorbeeld
    <informalexample>
      <programlisting>
cp ${1:?"De eerste parameter is verplicht"} \
   ${2:-"."}							</programlisting>
    </informalexample>
	Zoals gezegd wordt een opdracht be&euml;indigd door een 
	puntkomma of regeleinde. 
	Hier is een backslash gebruikt om aan te geven dat de 
	opdracht nog niet afgelopen is. 
  </para>
</sect2>
<sect2 id="if">
  <title>	als-dan						</title>
  <para>	
	De meest elementaire programma-constructie laat 
	&eacute;&eacute;n of meer opdrachten al of niet uitvoeren, 
	afhankelijk van de uitkomst van een test, bijvoorbeeld:
    <informalexample>
      <programlisting>
<command>if</command> /usr/bin/test "A" = "a"
<command>then</command>
  echo "Gelijk"
<command>else</command> 
  echo "Verschillend"
<command>fi</command>						</programlisting>
    </informalexample>
  </para>
  <para>
	Eerst wordt de opdracht achter <command>if</command> 
	uitgevoerd. 
	Er wordt dan gekeken welke exit status die opdracht 
	oplevert. 
	De meeste programma's geven standaard 0 terug, en 1 of 
	een andere foutcode als er problemen zijn, 
	<command>/bin/true</command> of <command>:</command> is 
	altijd 0, en <command>/bin/false</command> altijd 1. 
	<command>echo 1</command> zal weliswaar 1 als output 
	geven, maar het resultaat is 0. 
  </para>
  <para>
	De opdracht(en) achter <command>then</command> worden enkel 
	uitgevoerd als de if-opdracht 0 oplevert, 
	anders wordt het deel achter <command>else</command> 
	uitgevoerd, maar het opnemen van een else-tak is niet 
	verplicht. 
	De if-constructie wordt pas uitgevoerd als het sleutelwoord 
	<command>fi</command> is gelezen. 
	In een interactieve shell krijg je een 
	<firstterm>prompt string</firstterm> te zien om aan te geven 
	dat de shell op de volgende opdracht wacht. 
	Deze prompt wordt bepaald door de variabele <envar>PS1</envar>. 
	Als een opdracht niet afgesloten is, krijgt u de prompt 
	string <envar>PS2</envar> te zien. 
	De voorwaardelijke opdrachtregels worden hier ingesprongen 
	om de leesbaarheid te verbeteren. 
  </para>
  <para>
	De Bourne shell is een vrij beperkt programma. 
	Voor eenvoudige berekeningen kan het hulpprogramma 
	<command>expr</command> worden gebruikt en <command>test</command> 
	voor testen en vergelijken. 
	Moderne shells als ksh, bash of tcsh hebben deze faciliteiten 
	vaak ingebouwd. 
	In plaats van de notatie 
        <command>test <replaceable>expressie</replaceable></command>
	gebruiken ze 
	<command>[ <replaceable>expressie</replaceable> ]</command>. 
	De shell wil spaties zien tussen de verschillende onderdelen 
	van een expressie, terwijl in de opdracht variabele=waarde 
	juist geen spaties voor of na het =-teken mogen komen. 
        Voor uitgebreidere informatie zie <xref linkend="expr"> en
	<xref linkend="test">.
  </para>
  <para>
	Bovenstaand voorbeeld zal aangeven dat de strings 
	<literal>"A"</literal> en 
	<literal>"a"</literal> verschillend zijn.
	Hetzelfde geldt voor <command>test "1" = "01"</command> 
	terwijl <command>test "1" -eq "01"</command> 
	moet opleveren dat beide uitdrukkingen hetzelfde getal 
	voorstellen. 
	De opdracht <command>test -e "$file"</command> komt op 
	hetzelfde neer als 
	<command>ls "$file" &gt;/dev/null 2&gt;&amp;1</command>. 
	Zet variabelen tussen dubbele aanhalingstekens, anders 
	zal het fout gaan als de variabele niet bestaat of leeg is. 
  </para>
  <para>
	Er bestaan nog twee beknopte voorwaardelijke opdrachten:
    <command>
	<replaceable>commando1</replaceable> &amp;&amp;
 	<replaceable>commando2</replaceable>
    </command> en
    <command>
	<replaceable>commando1</replaceable> || 
	<replaceable>commando2</replaceable>
    </command>. 
	In beide gevallen wordt eerst 
	<command><replaceable>commando1</replaceable></command> 
	uitgevoerd. 
	In het eerste geval wordt 
	<command><replaceable>commando2</replaceable></command> 
	alleen uitgevoerd als het eerste exit status 
	<literal>0</literal> (nul) oplevert, 
	in het tweede geval als het resultaat van 
	<command><replaceable>commando1</replaceable></command>
	ongelijk is aan nul. 
	Het resultaat is dus <literal>true</literal> als 
	<command><replaceable>commando1</replaceable></command> 
	<emphasis>en</emphasis> c.q. <emphasis>of</emphasis> 
	<command><replaceable>commando2</replaceable></command> 
	<literal>true</literal> opleveren. 
  </para>
</sect2>
<sect2 id="case">
  <title>	meerkeuze tests					</title>
  <para>

	Om de waarde van een uitdrukking in de standaard uitvoer 
	te krijgen wordt de <command>echo</command> opdracht gebruikt. 
	Om een waarde van de standaard invoer te lezen en toe 
	te kennen aan een of meer variabelen wordt 
	<command> read <replaceable>naam1 naam2</replaceable>&hellip; </command>
	gebruikt. 
	De variabelen krijgen dan elk een woord van de invoer 
	als waarde. 
	Als er geen variabelen worden opgegeven, wordt er een regel 
	gelezen en in z'n geheel toegekend aan <envar>REPLY</envar>. 
  </para>
  <para>
	De if constructie kan met meerdere tests worden uitgebreid: 
    <informalexample>
      <programlisting>
<command>if</command> <replaceable>test1</replaceable> 
<command>then</command>
  <replaceable>commando1</replaceable> 
<command>else</command> 
  <command>if</command> <replaceable>test2</replaceable>
  <command>then</command> 
     <replaceable>commando2</replaceable>
  <command>else</command> 
  &hellip;
  <command>fi</command>
<command>fi</command>						</programlisting>
    </informalexample>

	Dit kan ook korter worden genoteerd. 

    <informalexample>
      <programlisting>  
<command>if</command> <replaceable>test1</replaceable> 
<command>then</command>
  <replaceable>commando1</replaceable> 
<command>elif</command> <replaceable>test2</replaceable>
<command>then</command> 
  <replaceable>commando2</replaceable>
<command>else</command> 
  &hellip;
<command>fi</command>						</programlisting>
    </informalexample>
  </para>
  <para>
	Om de inhoud van een variabele met meerdere waarden 
	te vergelijken gebruiken we de <firstterm>case</firstterm> 
	constructie, zoals in het volgende voorbeeld. 
    <informalexample>
      <programlisting>
echo -n $vraag		# variabele moet gedefinieerd zijn
read antwoord
antwoord=$(expr substr "$antwoord" 1 1 | tr \
  "[a-z]" "[A-Z]")
<command>case</command> $antwoord <command>in</command>
[YJDOS] )
  exit 0 ;;
N )
  exit 1 ;;
* )
  echo "Ongeldig antwoord!" 1>&2
  exit 2 ;;
<command>esac</command>						</programlisting>
    </informalexample>

	Hier wordt een vraag gesteld en een antwoord van de 
	gebruiker ingelezen, waarvan de eerste letter wordt 
	genomen en kleine letters in hoofdletters vertaald. 
	De case constructie vergelijkt <envar>antwoord</envar> 
	met een aantal patronen en voert de reeks bijbehorende 
	opdrachten uit, die wordt afgesloten met een dubbele puntkomma. 
  </para>
  <para>
	<userinput>Y</userinput> (yes), <userinput>J</userinput> (ja), 
	<userinput>D</userinput> (da), <userinput>O</userinput> (oui) of 
	<userinput>S</userinput> (si) retourneren exit status 
	<literal>0</literal> (true), 
	<userinput>N</userinput> (nein of njet) retourneren 
	<literal>1</literal> (false) en alle andere invoer komt overeen 
	met de asterisk en resulteert in 2 met bijbehorende foutmelding 
	op het standard error kanaal. 
  </para>
  <para>
	Een variant hierop is de <firstterm>select</firstterm> constructie, 
	die niet in de originele Bourne shell voorkomt, waarmee eenvoudige 
	menu's kunnen worden gemaakt. 
    <informalexample>
      <programlisting>
echo -n $vraag 
<command>select</command> woord <command>in</command> ja nee
<command>do</command> 
  <command>if</command> /usr/bin/test "$woord" != "" 
  <command>then</command> 
    break
  <command>fi
done</command>							</programlisting>
    </informalexample>
	Hier wordt de keuze van de gebruiker beperkt tot 
	<userinput>1</userinput> (ja) of 
	<userinput>2</userinput> (nee). 
	Let op dat <envar>"$woord"</envar> hier tussen aanhalingstekens 
	moet staan omdat de vergelijking anders niet goed gaat als 
	de waarde van de variabele een lege string is (gebruiker heeft 
	ongeldige invoer gepleegd). 
    </para>
</sect2>
<sect2 id="herhalingen">
  <title>	herhalingen					</title>
  <para>
	In het voorbeeld hierboven wordt de invoer zo lang 
	herhaald, totdat de gebruiker een geldige waarde heeft 
	ingevoerd. 
	Een meer algemene herhaling wordt geschreven als

    <informalexample>
      <programlisting>
<command>while</command> <replaceable>test</replaceable>
<command>do</command> 
  <replaceable>opdracht1</replaceable> 
  &hellip;
  <replaceable>opdrachtn</replaceable>
<command>done</command>						</programlisting>
    </informalexample>

	Hierin wordt telkens de opdracht achter 
	<firstterm>while</firstterm> herhaald en zo lang als het 
	resultaat <literal>0</literal> of true oplevert wordt 
	de reeks opdrachten tussen do en done herhaald, 
	wat dus ook nul keer het geval kan zijn en de test 
	(inderdaad is dat vaak het test commando) wordt altijd 
	een keer meer uitgevoerd dan de opdrachten. 
	Een voorbeeld van het gebruik van while 
	zagen we in <xref linkend="parameters">. 
  </para>
  <para>	    
	De <firstterm>until</firstterm> constructie lijkt hier 
	sterk op. 
	Hierin wordt de lijst van opdrachten herhaald 
	zolang als het resultaat ongelijk is aan 
	<literal>0</literal>. 
	De uitvoering van het script gaat dan verder 
	met de opdracht na `done'. 

    <informalexample>
      <programlisting>
<command>until</command> <replaceable>test</replaceable>
<command>do</command> 
  <replaceable>opdracht1</replaceable> 
  &hellip;
  <replaceable>opdrachtn</replaceable>
<command>done</command>						</programlisting>
    </informalexample>
  </para>
  <para>
	De <firstterm>for</firstterm> constructie wordt ook 
	vaak gebruikt.

    <informalexample>
      <programlisting>
<command>for</command> <replaceable>variabele</replaceable> <command>in</command> <replaceable>lijst</replaceable> 
<command>do</command> 
  <replaceable>opdracht</replaceable>1 
  &hellip;
  <replaceable>opdracht</replaceable>n
<command>done</command>						</programlisting>
    </informalexample>

	Achter <command>for</command> staat de naam van een variabele 
	zonder dollarteken. 
	Bij elke doorgang krijgt de variabele de waarde van het 
	volgende woord in de lijst. 
	We geven enkele voorbeelden. 
    <informalexample>
      <programlisting>
<command>for</command> file <command>in</command> * 
<command>do</command> 
  <command>if</command> [ -f "$file" ] 
  <command>then</command> 
    wc "$file"
  <command>fi
done</command>							</programlisting>
    </informalexample>
  </para>
  <para>
	Hier wordt voor elke file in de huidige directory het 
	commando <command>wc</command> uitgevoerd, dat het 
	aantal regels, woorden en tekens in het bestand telt. 
	Gebruik van <command>wc *</command> is niet zo netjes 
	omdat dan ook directory's en speciale files worden meegenomen.  

    <informalexample>
      <programlisting>
<command>for</command> i <command>in</command> 1 2 3 4 5 6 7 8 9 10
<command>do</command> 
  <command>for</command> j <command>in</command> 1 2 3 4 5 6 7 8 9 10
  <command>do</command> 
    echo -n $( expr $i '*' $j) " "
  <command>done</command>
  echo
<command>done</command>						</programlisting>
    </informalexample>
  </para>
  <para>
	Herhalingsopdrachten kunnen prima genest worden zoals in 
	bovenstaand voorbeeld, dat de tafels van vermenigvuldiging 
	afdrukt. 
	Let op de enkele aanhalingstekens rond het sterretje. 
	Er staat <option>-n</option> achter echo om de tafels op 
	&eacute;&eacute;n regel te houden en er wordt een spatie 
	tussenruimte ingevoegd. 
  </para>
  <para>
	Als het woord <command>in</command> en de volgende lijst 
	afwezig zijn dan krijgt de variabele achtereenvolgens de 
	parameters toegewezen waarmee het script werd aangeroepen, 
	zodat we het programma van <xref linkend="parameters">
	kunnen herschrijven als
    <informalexample>
      <programlisting>
echo "Programma $0 is aangeroepen met $# parameters"
<command>for</command> i
<command>do</command>
  echo $i
<command>done</command>						</programlisting>
    </informalexample>
  </para>
  <para>
	Een while lus kan oneindig doorlopen als voor de test 
	<command>:</command> of <command>/bin/true</command> 
	wordt ingevuld. 
	Een lus kan voortijdig worden verlaten met de 
	<command>break</command> opdracht; 
	met <command>break 2</command> wordt in geval van twee 
	geneste lussen de buitenste verlaten, enzovoorts. 
	De opdracht <command>continue</command> zorgt ervoor 
	dat de lijst opdrachten niet verder wordt afgewerkt en het 
	script verder gaat met de test. 
  </para>
</sect2>
<sect2 id="samenstellingen">
  <title>	samenstellingen					</title>
  <para>
	Tot de samengestelde commando's behoren if, case, select, 
	while, for, until en de functies, die verderop aan bod 
	komen. 
	Het simpelste samengestelde commando is 

    <informalexample>
      <programlisting>
{
  <replaceable>opdracht</replaceable>1 
  &hellip;
  <replaceable>opdracht</replaceable>n 
}								</programlisting>
    </informalexample>
  </para>
  <para>
	Het <firstterm> groep</firstterm> commando zal de 
	commando's in de groep na elkaar uitvoeren. 
	De exit status van de laatste opdracht is tevens het 
	resultaat van de groep. 
	Zo kan bijvoorbeeld een pijplijn als een opdracht worden 
	behandeld met 
	<command>{ <replaceable>opdracht</replaceable>1 | 
	  <replaceable>opdracht</replaceable>2; }</command>. 
  </para>
  <para>
	Als een lijst commando's in plaats van accolades tussen 
	ronde haken <command>()</command> wordt gezet, worden die binnen 
	een aparte <firstterm>subshell</firstterm> uitgevoerd. 
	Dit geldt ook voor 
	<command>$( <replaceable>lijst</replaceable> )</command>. 
	In het laatste geval wordt de uitvoer van de lijst als 
	deel van het script gebruikt. 
  </para>
</sect2>
<sect2 id="functies">
  <title>	functies					</title>
  <para>
	De definitie van een <firstterm>functie</firstterm> 
	bestaat uit diens naam met een paar haken erachter, 
	doorgaans gevolgd door een lijst commando's. 

    <informalexample>
      <programlisting>
<command><replaceable>functie-naam()</replaceable></command>
{
  <replaceable>opdracht</replaceable>1 
  &hellip;
  <replaceable>opdracht</replaceable>n 
}								</programlisting>
    </informalexample>
  </para>
  <para>
	Een functieaanroep bestaat uit de naam van de functie 
	gevolgd door de eventuele <firstterm>argumenten</firstterm> 
	gescheiden door spaties. 
	De betreffende commando's worden dan &eacute;&eacute;n voor 
	&eacute;&eacute;n in de huidige shell uitgevoerd, waarna 
	het script verder gaat waar het gebleven was. 
	Binnen de functie zijn de argumenten beschikbaar als 
	<literal>$1 &hellip;</literal>
  </para>
  <para> 
	De uitvoering van de functie stopt bij de afsluitende accolade 
	of na een return opdracht, die bij voorkeur de laatste opdracht 
	binnen de functie vormt. 
	Achter return kan eventueel een exit status volgen, die aan het 
	aanroepende script beschikbaar komt in <envar>$?</envar>. 
	De exit status is altijd een geheel getal. 
	Als een string als resultaat gewenst is, kan dat resultaat 
	bijvoorbeeld met echo worden uitgevoerd en de functie via 
	commando substitutie worden aangeroepen. 
	In plaats van 
	<command>for i in 1 2 3 4 5 6 7 8 9 10 </command> kan 
	<command>for i in `range 1 10`</command> worden geschreven 
	met de volgende functie:
  
    <informalexample>
       <programlisting>
<command>range()</command>
{ typeset i i

  i=$1
  while [ "$i" -le "$2" ]
  do
    echo $i
    i=`expr "$i" + 1`
  done
  unset i
}								</programlisting>
    </informalexample>
  </para>
  <para>
	Het kan handig zijn om functiedefinities in een apart bestand 
	<filename>functies</filename> te zetten en die met 
	<command>./functies</command> of 
	<command>source functies</command> in te lezen. 
	Bash zal een naam eerst proberen te koppelen aan een alias, 
	dan een functie en als laatste een bestand met dezelfde 
	naam gaan zoeken in zijn pad. 
  </para>
  <para>
	Binnen de functie zijn dezelfde variabelen als in de rest van 
	het script te gebruiken en gewijzigde waarden blijven ook na 
	afloop bestaan. 
	In de Korn en Bash shell kunnen ook 
	<firstterm>lokale variabelen</firstterm> worden gedeclareerd
 	met de <command>typeset</command> opdracht, die alleen binnen de 
	functiecontekst bestaat. 
	In Bash kan hetzelfde ook met <command>local</command> worden 
	bereikt. 
	Een lokale variabele maskeert een eventuele globale variabele 
	met dezelfde naam. 
    </para>
</sect2>
<sect2 id="voorbeelden">
  <title>	enkele voorbeelden				</title>
  <para>
	Het volgende voorbeeldprogramma geeft de namen van de 
	ingelogde gebruikers. 
	Na een tweetal functiedefinities volgt het hoofdprogramma, 
	dat bestaat uit een pijp van vijf segmenten. 

    <informalexample>
      <programlisting>
<command>word()</command>
{ if [ "$#" -gt 1 ]
  then
    i=0; n=$1; shift
    for j in $@
    do
      if [ $i = $n ]
      then
        echo "$j"
        break
      else
        i=$(expr $i + 1)
      fi
    done
  fi
} 

<command>item()</command>
{ OFS=$IFS; IFS=":"
  NR=$1; shift

  word $NR "$@" 
  IFS=$OFS
}

<replaceable># het hoofdprogramma </replaceable>
who \
| while read LINE1
  do 
    while read LINE2 
    do
      if [ "$(word 0 "$LINE1")" = 
           "$(item 0 "$LINE2")" ]
      then
        echo -e "$(item 0 "$LINE2")\011$(item 4
          "$LINE2")"
      fi
    done &lt;/etc/passwd
  done \
| sort \
| uniq -c							</programlisting>
    </informalexample>
  </para>
  <para>
	De functie <function>word</function> retourneert het 
	1<superscript>e</superscript> argument, dat wordt gebruikt 
	om een regel in woorden te splitsen; handiger dan daar 
	<firstterm>awk</firstterm> voor te gebruiken. 
	De functie <function>item</function> maakt handig 
	gebruik van de ingebouwde shell variabele <envar>IFS</envar> 
	om de dubbele punt in plaats van de spatie als scheidingsteken 
	te gebruiken. 
	Het hoofdprogramma doet niets anders dan uit de uitvoer van 
	<command>who</command> de username te knippen en die te 
	vergelijken met het corresponderende veld uit 
	<filename>/etc/passwd</filename>. 
	De uitvoer wordt dan gesorteerd en dubbele regels verwijderd. 
  </para>
  <para>
	Deze functies worden ook weer gebruikt in het volgende script 
	voor systemen die niet over een <command>which</command> commando 
	beschikken (zie <xref linkend="variabelen">). 
	Dit script houdt echter geen rekening met aliassen en 
	ingebouwde functies van de shell. 

    <informalexample>
      <programlisting>
<command>which_p()</command>
{ f=0
  while :
  do
    f=`expr $f + 1`
    dir=`item "$f" "$PATH"`
    if [ "$dir" = "" ]
    then
      break
    fi
    path=$dir/$1
    if [ -f "$path" ]
    then
      echo "$path"
      break
   fi
done
}

<replaceable># het hoofdprogramma `which'</replaceable>
if [ `expr match "$1" '.*/.*` -gt 0 ]
then
  if [ -f "$1" ]
  then
    echo "$1"
  fi
else
  echo `which_p "$1"`
fi								</programlisting>
    </informalexample>
  </para>
  <para>
	Het volgende programma toont verschillen tussen twee 
	bestanden, maar het is een stuk beperkter dan het
	<firstterm>diff</firstterm> commando. 
	Hier wordt zoals uitgelegd in <xref linkend="processen">
	het standaard invoerkanaal omgeleid naar het bestand dat
	als eerste argument op de commandoregel is meegegeven
	en er het tweede bestand wordt gekoppeld aan het derde
	invoerkanaal. 

    <informalexample>
      <programlisting>
<command>doit()</command>
{ LINE=0
  while read EEN<&0
  do
    LINE=`expr $LINE + 1`
    read TWEE<&3
    if [ "$EEN" != "$TWEE" ]
    then
      echo "$LINE""c""$LINE"
      echo "< $EEN"
      echo "---"
      echo "> $TWEE"
    fi
  done
}

<replaceable># hoofdprogramma					</replaceable>
if [ "$#" -ne 2 ]
  then
  echo "Usage: $0 file1 file2"
  exit 1
fi
if [ -r "$1" -a -r "$2" ]
then
  doit 0<$1 3<$2
  exit 0
else
  echo "Invoerbestand(en) onleesbaar"
  exit 1
fi 								</programlisting>
    </informalexample>
  </para>

</sect2>
<sect2 id="recursie">
  <title>	een voorbeeld van een recursieve functie	</title>
  <para>
	Een functie mag ook zichzelf aanroepen (recursie), 
	waarbij je moet voorkomen dat dat proces oneindig doorgaat. 
	In onderstaand voorbeeld voor bash en ksh vindt de recursie 
	alleen plaats als <envar>$1</envar> &gt; 0 en wordt het 
	argument verlaagd om te zorgen dat na een aantal stappen 
	<envar>$1</envar> gelijk wordt aan 0.

    <informalexample>
      <programlisting>
<command>Hanoi()</command>
{ typeset i aantal

  if [ "$1" -gt "0" ]
  then
    aantal=$(expr $1 - 1)
    Hanoi "$aantal" "$2" "$4" "$3"
    echo "Verplaats een schijf van $2 naar $3"
    Hanoi "$aantal" "$4" "$3" "$2"
  fi
}
<replaceable># Aanroepen met: </replaceable>
Hanoi 4 "A" "B" "C"						</programlisting>
    </informalexample>
  </para>
  <para>
	Voor wie het spel <firstterm>de Torens van Hanoi</firstterm>
	nog niet kent: je hebt een toren van 4 (of 64, maar 
	dan duurt het spel erg lang) gouden schijven van verschillende 
	diameter, die je &eacute;&eacute;n voor &eacute;&eacute;n 
	van stapel A naar B moet verplaatsen, waarbij nooit een grotere
 	schijf bovenop een kleinere mag komen te liggen. 
	De optimale oplossing is om de bovenste drie schijven eerst 
	recursief van A naar C te verplaatsen, waarna de onderste 
	schijf van A naar B kan worden verplaatst en de rest weer 
	recursief van C naar B. 
  </para>
  <para>
	Om te bewijzen dat een recursief algorithme korrekt is, 
	is inductie nodig. 
	Het is triviaal in te zien dat het algorithme een stapel van 
	nul schijven van A naar B verplaatst door niets te doen. 
	Voor 
		n &gt; 0
	verplaats je eerst de bovenliggende 
		(n - 1) 
	schijven van A naar C en na het verschuiven van de 
	n<superscript>e</superscript>, weer van C naar B. 
	Als we mogen aannemen dat het verplaatsen van 
		(n - 1) 
	schijven korrekt wordt uitgevoerd, dan gaat werkt het op deze manier 
	ook voor een toren van 
		n
	schijven. 
  </para>
  <para>
	De inductieregel stelt, dat aangezien het algorithme het gewenste 
	effekt heeft voor 
		n = 0
	en dat voor elke 
		n &ges; 0
	geldt, dat als het goed gaat voor 
		n,
	ook een toren van 
		(n + 1)
	schijven korrekt wordt verwerkt. 
	Op dezelfde manier is te bewijzen dat als elke schijf groter 
	is dan de schijf erboven, het algorithme nooit een grotere 
	schijf bovenop een kleinere zal leggen: de toren van 
		(n - 1)
	schijven is altijd kleiner dan de onderste en de onderste schijf 
	komt nooit ergens bovenop te liggen. 
  </para>
  <para>
	Uit het algorithme volgt een recurrente betrekking voor het 
	aantal verplaatsingen:
  
    <informaltable frame=none>
      <tgroup cols=1>
	<tbody>
	  <row><entry> 
	    V(0) = 0
	  </entry></row>
	  <row><entry>
	    V(n) = 2 &times; V(n-1) + 1
	  </entry></row>
	</tbody>
      </tgroup>
    </informaltable>
  </para>
  <para>
	Door een tabel te maken van de waarden voor verschillende n 
	zie je al snel dat dit overeenkomt met 
		V(n) = 2<superscript>n</superscript>-1, 
	wat vervolgens geverifi&euml;erd kan worden. 

    <informaltable frame=none>
      <tgroup cols=1>
	<tbody>
	  <row><entry> 
	    V(0) = 2<superscript>0</superscript>-1 = 0
	  </entry></row>
	  <row><entry>
	    V(n) = 2 &times; (2<superscript>n-1</superscript>-1) + 1 = 2<superscript>n</superscript> - 1
	  </entry></row>
	</tbody>
      </tgroup>
    </informaltable>
  </para>
  <para>
	Bewijzen dat er geen snellere weg bestaat, is moeilijker. 
	Het kritieke pad is het verplaatsen van de onderste schijf van 
	A naar B. 
	Voor dat het zover is, moeten de schijven erboven eerst op 
	&eacute;&eacute;n of andere manier naar C worden verplaatst en 
	daarna weer naar B. 
	Een van de weinige alternatieven is om eerst van A naar C te 
	verplaatsen, en daarna van C naar B, maar dat maakt het enkel langer. 
	Welke keuze je ook maakt, het heeft geen invloed op het verplaatsen 
	van de resterende schijven. 
  </para>
</sect2>
<sect2 id="signalen">
  <title>	signalen					</title>
  <para>
	We hebben al gezien hoe we processen in de achtergrond 
	kunnen starten en kennis gemaakt met een manier om de 
	manier om twee processen te co&ouml;rdineren door middel 
	van een pijp: het eerste proces mag zolang in de pijp 
	schrijven totdat de kleine buffer vol is; dan zal 
	<acronym>Unix</acronym> het stoppen totdat er weer 
	voldoende ruimte vrij is. 
	Het lezende proces wordt telkens als de pijp leeg is in 
	de wacht gezet. 
  </para>
  <para>
	De meeste vormen van interprocescommunicatie vergen een 
	hogere programmeertaal. 
	Voor de shell programmeur zijn de signalen het belangrijkst. 
	<acronym>Unix</acronym> heeft twintig tot dertig 
	voorgedefinieerde <firstterm>signalen</firstterm> 
	plus twee vrij definieerbare. 

	Met de opdracht 
	<command>kill <replaceable>signaal proces</replaceable></command> 
	stuur je een signaal naar het opgegeven proces. 
	De nummers van de processen zijn met <command>ps</command> 
	te achterhalen. 
	Het nummer van het proces zelf is te vinden in de 
	variabele <envar>$$</envar> en in bash zit het ouderproces 
	in <envar>$PPID</envar>. 
	De nummers van de signalen verschillen enigszins per 
	<acronym>Unix</acronym> versie; de signalen kunnen ook met 
	symbolische namen worden aangeduid; 
	voor bash beginnen die met de letters <literal>SIG</literal>, 
	maar in de korn shell moet dit voorvoegsel worden weggelaten. 
  </para>
  <para>
	Het effekt van een signaal is in de meeste gevallen dat het 
	opgegeven programma onmiddellijk wordt beeindigd. 
	Voor <literal>SIGKILL</literal> (9) is dit altijd het geval. 
	Het ligt voor de hand dat alleen 
	<foreignphrase>root</foreignphrase> het recht heeft om 
	andermans processen te doden. 
	Het besturingssysteem kan zelf besluiten een proces een 
	signaal te geven. 
	Als een programma stopt met 
	<computeroutput>segmentation violation</computeroutput>, 
	<computeroutput>bus error</computeroutput>, 
	<computeroutput>floating point exception</computeroutput> of 
	<computeroutput>illegal instruction</computeroutput> duidt 
	dat meestal op een programmeerfout; 
	shell scripts veroorzaken deze fouten zelden. 
  </para>
  <para>
	De gebruiker heeft een snellere manier om signalen naar 
	het proces op de voorgrond te sturen. 
	Deze kunnen vrij worden veranderd met het commando 
	<firstterm>stty</firstterm>. 
	Met <command>stty -a</command> krijg je een lijst van de 
	ingestelde waarden, bijvoorbeeld 
	<keycombo><keycap>Ctrl</keycap><keycap>D</keycap>	</keycombo>
	voor <literal>SIGHUP</literal>, 
	<keycombo><keycap>Ctrl</keycap><keycap>C</keycap>	</keycombo>
	of <keycap>Del</keycap> voor <literal>SIGINT</literal>, 
	<keycombo><keycap>Ctrl</keycap><keycap>\</keycap>	</keycombo>
	<literal>SIGQUIT</literal>. Met
	<keycombo><keycap>Ctrl</keycap><keycap>Z</keycap>	</keycombo>
	wordt een lopend programma tijdelijk onderbroken. 
	Onder bash kan een script zichzelf onderbreken met de 
	<command>suspend</command> opdracht. 
	De ingebouwde opdrachten met <command>fg</command> en 
	<command>bg</command> zetten een onderbroken job voort in de 
	voor- resp. achtergrond. 
	<comment>(fixme: uitleggen wat een job is)</comment>
  </para>
  <para>
	Met de opdracht 
	<command>sleep <replaceable>seconden</replaceable></command>
	wordt een programma tijdelijk onderbroken en zal het na het 
	opgegeven aantal seconden met <literal>SIGALRM</literal> worden 
	gewekt. 
	De <firstterm>wait</firstterm> opdracht onderbreekt een proces 
	zolang totdat het van <acronym>Unix</acronym> het signaal 
	<literal>SIGCHLD</literal> krijgt dat het opgegeven kind proces 
	of job in de achtergrond be&euml;indigd is. 
	<command>Wait</command> zonder argumenten wacht totdat alle 
	kinderen afgestorven zijn. 
	Als een proces in de voorgrond gestart is, wacht de ouder 
	zonder expliciet wait commando. 
  </para>
  <para>
	Een proces kan ervoor kiezen bepaalde signalen gewoon te negeren, 
	met uitzondering van <literal>SIGKILL</literal> en 
	<literal>SIGSTOP</literal>. 
	Het <literal>SIGHUP</literal> signaal dat aangeeft dat een 
	terminalgebruiker de (telefoon)verbinding heeft opgehangen wordt 
	genegeerd met <command>nohup commando&</command>. 
	De standaard uitvoer en error kanalen worden dan omgeleid naar 
	het bestand <filename>nohup.out</filename>. 
  </para>
  <para>
	Signalen worden asynchroon verwerkt, onafhankelijk van waar 
	een proces mee bezig was en na afloop gaat het programma verder 
	waar het gebleven was, tenzij het be&euml;indigd is. 
  </para>
  <para>
	Met het commando 
	<command>trap <replaceable>commando signa(a)l(en)</replaceable></command> 
	wordt aangegeven dat een bepaald commando moet worden uitgevoerd 
	als het volgende signaal c.q. &eacute;&eacute;n van de signalen wordt 
	ontvangen. 
	Dit zal vaak de naam van de functie zijn die het betreffende 
	signaal moet afhandelen. 
	Als een script voortijdig moet worden afgebroken zal zo'n functie 
	bijvoorbeeld tijdelijke bestanden verwijderen. 
  </para>
  <para>
	<command>Trap</command> heeft geen effekt op kind processen. 
	Als het commando <command>-</command> luidt of ontbreekt, 
	dan wordt de oorspronkelijke handelwijze hersteld. 
	Als het commando een lege string is, dan zal de lijst van 
	signalen door het script worden genegeerd. 
  </para>
</sect2>
</sect1>
<!-- eind tweede hoofdstuk 					-->

<sect1 id="tools">
  <title>	enkele <acronym>Unix</acronym> tools		</title>
  <para>
	De <acronym>Unix</acronym> shell is van oudsher de enige 
	programmeertaal zonder ingebouwde optelling. 
	Optellen en een eindeloze reeks andere functies kunnen 
	echter gerealiseerd worden door externe programma's. 
	De verzameling van tools die standaard met 
	<acronym>Unix</acronym> worden geleverd vormen een k
	rachtig en flexibel geheel. 
	Dit hoofdstuk behandelt er een paar die vooral 
	geschikt zijn voor gebruik in scripts; 
	het pretendeert niet volledig te zijn. 
  </para>
  <para>
	Een modale Unix commandoregel begint 
	met de naam van het programma, gevolgd door de opties, 
	die met een min-teken beginnen, met daarna de overige
	parameters, die vaak bestanden zijn. 
	Veelal mogen er ook meerdere bestanden voorkomen. 
	De opties mogen in willekeurige volgorde worden 
	gebruikt en opties van &eacute;&eacute;n letter gecombineerd van 
	<command>prog -a -b <replaceable>file</replaceable></command> 
	tot bijv. 
	<command>prog -ab <replaceable>file</replaceable></command>. 
	Verder kunnen argumenten aan opties worden gekoppeld met 
	iets als 
	<command>prog -a <replaceable>-variabele=waarde</replaceable> 
	-b &hellip;</command> of
	<command>prog -a <replaceable>-variabele waarde</replaceable>
	-b &hellip;</command>; 
	let op wanneer je wel of geen spaties moet gebruiken. 
  </para>
<sect2 id="expr">
  <title>	expr						</title>
  <para>
	Wie een rekenmachine zoekt gebruikt meestal 
	<firstterm>bc</firstterm> of <firstterm>xcalc</firstterm>. 
	<firstterm>Expr</firstterm> is speciaal voor shell scripts. 
	Elk argument is een getal of een operator, 
	en moet door spaties gescheiden worden;
	speciale tekens moeten door backslashes worden voorafgegaan. 
	Expr kent geen variabelen; daarvoor zijn shell variabelen. 
	Om een getal met drie te vermenigvuldigen gebruiken we iets als 
	<command>i=`expr "3" \* "$i"`</command>
  </para>
  <para>
	De rekenkundige operatoren <command>+</command> voor optellen, 
	<command>-</command> voor aftrekken, <command>*</command> 
	voor vermenigvuldigen, <command>/</command> voor delen en 
	<command>%</command> voor rest werken met gehele getallen. 
	De vergelijkingsoperatoren <command>&gt;</command>, 
	<command>&lt;</command>, <command>&gt;=</command>, 
	<command>&lt;=</command>, <command>=</command> (in 
	<acronym>GNU</acronym> expr ook <command>==</command>)  
	en <command>!=</command> kunnen ook voor strings worden 
	gebruikt. 
	In tegenstelling tot de shell retourneren ze een 
	<literal>1</literal> als de vergelijking waar is en 
	anders <literal>0</literal>, evenals de operatoren 
	<command>|</command> (logische `of') en <command>&</command> 
	(logische `en'). 
	In plaats van een nul mag de lege string worden gebruikt 
	en expressies kunnen tussen haakjes <command>( )</command> 
	gezet worden. 
	Let op dat in 
	<command> if $(expr "$i" = "") 				</command>
	de aanhalingstekens om de variabelenaam niet gemist kunnen worden. 
  </para>
  <para>
	De Korn shell en bash hebben ook een ingebouwde rekenfunctie: 
	de te berekenen uitdrukking wordt omgeven door 
	<command>$((</command> en <command>))</command>. 
	Hier worden geen aanhalingstekens gebruikt en de spaties 
	zijn niet vereist. 
	Er zijn extra operatoren: <command>=</command> staat 
	voor toewijzing, dus voor vergelijking wordt 
	<command>==</command> gebruikt. 
	Behalve in de decimale notatie kunnen getallen ook octaal 
	worden genoteerd door ze met <literal>0</literal> te beginnen 
	of hexadecimaal door er <literal>0x</literal> voor te zetten. 
	Het gebruik van de ingebouwde functie bespaart 
	<acronym>Unix</acronym> de tijd voor het maken van het 
	`expr' proces. 
  </para>
  <para>
	Expr kent ook een patroonherkenning operator 
	<command>:</command> die een string vergelijkt met een 
	reguliere expressie (zie <xref linkend="grep">). 
	Deze operator levert het aantal tekens dat overeenkomt op. 
  </para>
  <para>
	Modernere versies van <command>expr</command> bezitten een 
	aantal string functies. 

    <variablelist>
      <varlistentry>
        <term>
	  <command> 
		match <replaceable>string regexp</replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		een alternatieve notatie voor patroonherkenning  
	  </simpara>
        </listitem>
      </varlistentry>
    <varlistentry>
        <term>
	  <command> 
		substr <replaceable>string begin lengte</replaceable>
	  </command>
	</term>
        <listitem>
          <simpara> 
		retourneert een deel van de string van lengte 
		tekens vanaf positie <replaceable>begin</replaceable>; 
		posities worden vanaf <literal>1</literal> geteld
	  </simpara>
        </listitem>
      </varlistentry>
    <varlistentry>
        <term>
	  <command> 
		index <replaceable>string tekens</replaceable>
	  </command>
	</term>
        <listitem>
          <simpara> 
		retourneert de eerste positie in de 
		<replaceable>string</replaceable> waar 
		&eacute;&eacute;n van de reeks tekens voorkomt
	  </simpara>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <command> 
		length <replaceable>string </replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		retourneert het aantal tekens in de string 
	  </simpara>
        </listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="test">
  <title>	test						</title>
  <para>
	Het <firstterm>test</firstterm> commando, dat wordt 
	gebruikt in voorwaardelijke opdrachten, zijn we al 
	tegengekomen. 
	Let op dat test een ingebouwde functie van moderne 
	shells als bash of ksh is, die erg lijkt op 
	<filename>/usr/bin/test</filename>. 
	Die ingebouwde test functie kan ook worden genoteerd als 
	<command>[ <replaceable>expressie</replaceable> ]</command>. 
	De eerste toepassing is om te testen of een bestand bestaat. 

    <variablelist>
      <varlistentry>
        <term>
	  <command> 
		-d <replaceable>file</replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als de file een directory is
	  </simpara>
	</listitem>
      </varlistentry>
        <varlistentry>
        <term>
	  <command> 
		-f <replaceable>file</replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als de file een normaal bestand is
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <command> 
		-r <replaceable>file</replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als je het recht hebt om de file te lezen
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
        <term>
	  <command> 
		-w <replaceable>file</replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als je het recht hebt om naar de file te schrijven
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
        <term>
	  <command> 
		-s <replaceable>file</replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als het bestand niet leeg is
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
        <term>
	  <command>
		-t <replaceable>kanaal</replaceable>	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als het kanaal 
		<firstterm>(file descriptor)</firstterm> 
		aan een terminal gekoppeld is. 
		<acronym>Unix</acronym> koppelt elk bestand dat geopend 
		wordt aan een nummer. Om te lezen of te schrijven 
		verwijs je naar dat nummer. een bestand kan evt. dubbel 
		geopend zijn. 
		De shell zal bij het inloggen kanaal 0 openen voor invoer 
		van de terminal en 1 en 2 openen voor uitvoer naar de 
		terminal; 
		voor 
		<command>commando <replaceable>&lt;file</replaceable></command>
		zal de shell het bestand openen met nummer 3 of hoger, 
		het commando uitvoeren en de file weer sluiten. 
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para> 
	Hedendaagse Unices hebben wat meer opties. 
	De tweede groep tests vergelijkt strings. 

    <variablelist>
      <varlistentry>
        <term>
	  <command> 
	    <replaceable>string</replaceable>1 = <replaceable>string</replaceable>2	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als beide strings gelijk zijn
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <command> 
	    <replaceable>string</replaceable>1 != <replaceable>string</replaceable>2	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als beide strings verschillen
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <command> 
	    <replaceable>string</replaceable>1	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als de string niet de lege string "" is
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <command> 
	    -n <replaceable>string</replaceable>1	
	  </command>
	</term>
        <listitem>
          <simpara> 
		waar als de lengte van de string gen nul bedraagt
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Om in plaats van strings gehele getallen te vergelijken 
	worden de operaties <option>-eq</option>, 
	<option>-ne</option>, <option>-gt</option>, <option>-ge</option>,
	<option>-lt</option>, <option>-le</option> gebruikt. 
	Getallen worden als strings weergegeven. 
	Het verschil is dat <command> test "02" -eq "2"</command> 
	<literal>0</literal> (true) zal opleveren en 
	<command>/usr/bin/test "02" = "2"</command> 
	<literal>1</literal> (false). 
	Dit resultaat krijgt u te zien met <command>echo $?</command>. 
	<command>/usr/bin/expr "02" = "2"</command> zal op de 
	standaard uitvoer <literal>1</literal> (true) schrijven en de 
	exit status <literal>0</literal> (true) retourneren. 
  </para>
  <para>
	De vierde groep zijn de verbindingen. 
	<command>! <replaceable>expressie</replaceable></command> 
	staat voor logische negatie,  
	<command><replaceable>expressie</replaceable>1 -a 
	<replaceable>expressie</replaceable>2</command> 
	vormt een logische <emphasis>en</emphasis> en 
	<command><replaceable>expressie</replaceable>1 -o 
	<replaceable>expressie</replaceable>2</command> 
	een logische <emphasis>of</emphasis>. 
	Verder kunnen subexpressies tussen <command>( )</command> 
	haakjes worden gezet. 
  </para>
</sect2>
<sect2 id="grep">
  <title>	grep en reguliere expressies			</title>
  <para>
	<firstterm>Grep</firstterm> is een tool om in 
	tekstbestanden te zoeken; 
	met binaire bestanden kunnen veel van de hier besproken 
	tools problemen geven. 
	U kunt het <command>strings</command> commando gebruiken 
	om leesbare tekstfragmenten te vissen uit alle soorten 
	files. 
  </para>
  <para>
	Sinds het ontstaan van <acronym>Unix</acronym> zijn er 
	veel versies met verschillende kenmerken in omloop 
	en bovendien zijn er <firstterm>egrep</firstterm>, 
	<firstterm>fgrep</firstterm> en 
	<firstterm>agrep</firstterm> bij gekomen. 
	Ten behoeve van de portabiliteit zijn 
	egrep of fgrep aan te bevelen. 
  </para>
  <para>
	Hieronder volgt de syntaxis van de fgrep opdracht. 
	De rechte haken geven aan dat een onderdeel optioneel 
	is en worden in een echte opdrachtregel niet opgeschreven, 
	evenmin als cursieve termen letterlijk worden genomen. 

    <cmdsynopsis>
      <command> fgrep						</command>
      <arg choice="opt" rep="repeat">
	<replaceable>	optie					</replaceable>
      </arg>
      <arg choice="plain" rep="repeat">
	<replaceable>	string					</replaceable>
      </arg>
      <arg choice="opt" rep="repeat">
	<replaceable>	file					</replaceable>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	Fgrep is het beperktste en tevens snelste lid van 
	de familie. 
	Als er een enkele string als argument wordt meegegeven 
	functioneert het als een filter dat van de regels in 
	de invoer degene doorlaat die de opgegeven string 
	bevatten. 
  </para>
  <para>
	Er kan op meerdere strings worden gezocht, die dan 
	worden gescheiden door een regeleinde. 
	De strings moeten dan tussen aanhalingstekens worden gezet 
	om een argument te vormen en alle regels die 
	&eacute;&eacute;n van de strings bevatten worden 
	afgedrukt. 
	Fgrep kent de volgende opties. 

    <variablelist>
      <varlistentry>
        <term>
	  <option> -v						</option>
	</term>
	<listitem>
	  <simpara> 
		alle regels afdrukken, behalve degene die de 
		gezochte strings bevatten
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <option> -c						</option>
	</term>
	<listitem>
	  <simpara> 
		alleen het aantal regels afdrukken
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <option> -l						</option>
	</term>
	<listitem>
	  <simpara> 
		de namen van de files afdrukken, die de gezochte 
		strings bevatten
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <option> -i						</option>
	</term>
	<listitem>
	  <simpara> 
		geen onderscheid maken tussen hoofd- en kleine
		letters
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <option> -w						</option>
	</term>
	<listitem>
	  <simpara> 
		regels waarin de zoekstring een deel van een
		woord vormt tellen niet mee
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
        <term>
	  <option> -x						</option>
	</term>
	<listitem>
	  <simpara> 
		alleen regels die helemaal gelijk zijn aan de
		zoekstring tellen mee
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>  
	Er bestaan meer opties, maar die verschillen per systeem. 
	Als je wilt testen of een bepaalde string in een bepaalde 
	file voorkomt kun je de <option>-s</option> (silent) 
	optie gebruiken (BSD), of <option>-q</option> 
	(quiet, GNU) om de standaard uitvoer te onderdrukken. 
  </para>
  <para>
	Het volgende voorbeeld geeft een lijst van al je processen. 
	(de juiste opties van ps hangen af of je OS tot de System V 
	of BSD familie behoort) 
    <informalexample>
      <programlisting>
ps -al | fgrep `fgrep $USER /etc/passwd | cut -f 3 -d ':'` 	</programlisting>
    </informalexample>
  </para>
  <para>
	De binnenste <firstterm>fgrep</firstterm> selekteert de 
	regel van de ingelogde gebruiker uit het wachtwoordbestand. 
	<firstterm>Cut</firstterm> knipt daaruit het derde veld, 
	waarbij de dubbele punt als scheidingsteken wordt gebruikt. 
	De buitenste fgrep selecteert de regels met dit 
	<foreignphrase>User ID</foreignphrase> uit de uitvoer van 
	<firstterm>ps</firstterm>. 
	Vergelijk met het voorbeeld uit <xref linkend="voorbeelden">. 
  </para>
  <para>
	De functionaliteit van grep zelf verschilt nogal per systeem, 
	en daarom wordt hier het uitgebreidere 
	<firstterm>egrep</firstterm> besproken. 
	De opties zijn hetzelfde, maar het zoekt naar 
	<firstterm>reguliere expressies</firstterm> in plaats van alleen 
	letterlijke strings. 
	Reguliere expressies lijken op de wildcards 
	(jokertekens, zie <xref linkend="wildcards">) * en ? die de 
	shell gebruikt om naar bestandsnamen te zoeken, maar 
	de notatie verschilt sterk. 
	Denk eraan de zoekstring tussen enkele aanhalingstekens te 
	zetten om verhaspelen door de shell te voorkomen. 
	Het kan geen kwaad om zelf eens wat te proberen op een grote 
	woordenlijst. 
  </para>
  <para>
    <informalexample>
      <programlisting>
egrep -i 'abc
def' /usr/share/dict/words					</programlisting>
    </informalexample>

	Hiermee zoeken we naar alle woorden waarin de letters 
	<literal>abc</literal> en/of <literal>def</literal> direkt 
	achter elkaar staan. 
	De woordenlijst zou ook in bijv. 
	<filename>/usr/dict/words</filename> kunnen staan. 
  </para>
  <para>
	Reguliere expressies moeten voldoen aan de volgende regels.
  </para>
  <itemizedlist mark="opencircle">
    <listitem>
      <para>
	Een enkel teken dat geen speciale functie heeft, komt 
	overeen met dat teken zelf
      </para>
    </listitem>
   <listitem>
      <para>
	Om te zoeken naar een teken dat een speciale functie 
	heeft, moet je er een <literal>\</literal> voorzetten, 
	bijv. <command>egrep '\\'</command>
      </para>
    </listitem>
   <listitem>
      <para>
	Een reeks tekens tussen vierkante haken wordt gebruikt 
	om te zoeken naar een enkel teken uit deze reeks, 
	zo correspondeert <literal>[0123456789]</literal> met 
	een enkel cijfer.  
      </para>
    </listitem>
   <listitem>
      <para>
	Tussen vierkante haken kan een reeks tekens worden 
	aangegeven met een koppelteken tussen het eerste en 
	laatste teken, bijv. <literal>[0-9]</literal>. 
      </para>
    </listitem>
   <listitem>
      <para>
	Een punt correspondeert met een willekeurig teken, 
	bijv. <literal>.a.b.c..de</literal> 
	met `barbecuede'.
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1</token><token><replaceable>exp</replaceable>2</token> correspondeert met 
	<replaceable>string</replaceable>1<replaceable>string</replaceable>2
	als <token><replaceable>exp</replaceable>1</token> 
	correspondeert met <replaceable>string</replaceable>1 en 
	<token><replaceable>exp</replaceable>2</token> correspondeert 
	met <replaceable>string</replaceable>2, waarbij 
	<replaceable>string</replaceable>1 de langst mogelijke string 
	is waarvoor nog een correspondentie met 
	<token><replaceable>exp</replaceable>2</token> mogelijk is. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token>(<replaceable>exp</replaceable>)</token> correspondeert 
	met alle strings die corresponderen met 
	<token><replaceable>exp</replaceable></token>. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1|<replaceable>exp</replaceable>2</token> 
	correspondeert met alle strings die corresponderen met 
	<token><replaceable>exp</replaceable>1</token> 
	<emphasis>of</emphasis> 
	<token><replaceable>exp</replaceable>2</token>. 
	Iets handiger dan een regeleinde. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1*</token> correspondeert 
	met alle strings die nul of meer keer corresponderen met 
	<token><replaceable>exp</replaceable>1</token>. 
	Zo komt <literal>a.*b.*c.*d.*e</literal> overeen met 
	o.a. `Abcoude' en blijkt bijv. 
	<command>egrep `(bla)*(bla)'</command> dezelfde output op 
	te leveren als <command>fgrep bla</command>. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1+</token> is equivalent met 
	<token><replaceable>exp</replaceable>1(<replaceable>exp1</replaceable>)*</token>. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1?</token> is equivalent met 
	<token><replaceable>exp</replaceable>1|()</token>. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1\{<replaceable>aantal</replaceable>1\}</token> 
	is equivalent met <token><replaceable>exp</replaceable>1</token> 
	<varname><replaceable>aantal</replaceable>1</varname> 
	keer achter elkaar. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1\{<replaceable>aantal</replaceable>1,\}</token> 
	is equivalent met <token><replaceable>exp</replaceable>1</token> 
	<varname><replaceable>aantal</replaceable>1</varname> of meer 
	keer achter elkaar. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1\{<replaceable>aantal</replaceable>1,<replaceable>aantal</replaceable>2\}</token> 
	is equivalent met <token><replaceable>exp</replaceable>1</token> 
	minstens <varname><replaceable>aantal</replaceable>1</varname> 
	en hoogstens <varname><replaceable>aantal</replaceable>2</varname> 
	keer achter elkaar.  
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token>^<replaceable>exp</replaceable>1</token> correspondeert 
	met alle regels waarin <token><replaceable>exp</replaceable>1</token> 
	aan het begin van de regel voorkomt. 
      </para>
    </listitem>
   <listitem>
      <para>
	De reguliere expressie 
	<token><replaceable>exp</replaceable>1$</token> correspondeert 
	met alle regels waarin <token><replaceable>exp</replaceable>1</token> 
	aan het eind van de regel voorkomt. 
      </para>
    </listitem>
  </itemizedlist>
      
  <para>
	Een uitbreiding op de Reguliere Expressies, die oudere Unices 
	missen, zijn de <firstterm>karakter klassen</firstterm> die 
	een uitbreiding vormen van de lijsten karakters. 
  </para>

    <variablelist>
      <varlistentry>
	<term>
	  <token>	[[:alpha:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de letters van het alfabet		</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:upper:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de hoofdletters				</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:lower:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de kleine letters			</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:digit:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de cijfers				</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:xdigit:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de hexadecimale cijfers			</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:punct:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de leestekens				</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:graph:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de zichtbare tekens			</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:print:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de afdrukbare tekens (zichtbare tekens
			plus de spatie				</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:blank:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de spatie en het tabulatie-teken	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:space:]]          			</token>
	</term>
	<listitem>
	  <simpara>	alle witruimte 
			(<token>[[:blank:]]</token> plus 
			<token>vertical tab</token> en
			<token>form feed</token>		</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <token>	[[:cntrl:]]          			</token>
	</term>
	<listitem>
	  <simpara>	de stuurtekens				</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  <para> 
	Welke tekens tot deze klassen behoren is afhankelijk 
	van uw <firstterm>locale</firstterm>. 
	Als <acronym>Unix</acronym> uw moedertaal is, dan typt u 
	<command>export LANG=C</command> of 
	<command>export LANG=POSIX</command>. 
	De klasse <token>[:upper:]</token> bevat dan alleen de 
	<acronym>ASCII</acronym> tekens A - Z, maar met 
	<command> export LANG=nl_NL</command> worden ook de 
	diakritische tekens als 
	&Auml;&Ucirc;&Eacute;&Ograve;&Ntilde;&Aring;&szlig;&Ccedil;&ijlig;&Rcaron;&Omacr;&OElig;&Idot;&inodot; 
	met <acronym>ASCII</acronym> nummers boven 127 toe gerekend. 
	Ook de volgorde van de output van <command>sort -d -f</command> 
	is afhankelijk met de ingestelde locale. 
  </para>
  <para>
	De <firstterm>equivalentie klassen</firstterm> zijn eveneens 
	afhankelijk van de locale en worden door 
	<acronym>GNU</acronym> nog niet goed ondersteund. 
	De notatie <token>[[=<replaceable>letter</replaceable>=]]</token> 
	duidt de verzameling van tekens aan die in het woordenboek 
	op de zelfde plaats komen, zoals hoofdletters en letters 
	met een accent. 
  </para>
  <para>
	De  <acronym>GNU</acronym> versie heeft weer een uitgebreidere 
	set van regels, waaronder de mogelijkheid om terug te refereren 
	naar een eerdere RE tussen haakjes met een backslash gevolgd 
	door het nummer van die expressie, bijv. 
	<literal>([a-z]) is een \1.*"</literal> correspondeert met 
	regels als `a is een aapje, dat eet uit zijn poot', `b is een 
	bakker, die bakt voor ons brood'. 
  </para>
  <para>
	Nog uitgebreider dan egrep is 
	<ulink url="http://www.tgries.de/agrep/">
	  <firstterm>agrep</firstterm>,
	</ulink>
	een algorithme van Sun Wu en Udi Manber.
	Hiermee kun je zoeken op strings die ongeveer gelijk zijn 
	aan het zoekpatroon. 
  </para>
  <para>
	De belangrijkste extra optie is het maximum toegestane aantal 
	fouten (letters die je moet wijzigen, toevoegen, vervangen om 
	ze met het zoekpatroon te laten overeenkomen). 
	Als eerste optie wordt dan <option>-1, -2, ...</option> 
	aangegeven.
  </para>
  <para>
	Een andere extra optie is mogelijkheid te zoeken naar alle 
	strings die een uitbreiding van het zoekpatroon bevatten. 
	In plaats van <command>egrep 'a.*b.*c.*d.*e'</command> 
	schrijf je dan <command>agrep -p 'abcde'</command>.
  </para>
</sect2>
<sect2 id="find">
  <title>	find en xargs					</title>
  <para>
	Een van de meest voorkomende taken van shell scripts is 
	het zoeken naar bepaalde bestanden en het bewerken ervan. 
	Script programmeurs gebruiken hiervoor liever 
	<firstterm>find</firstterm> dan ls. 
	Find zoekt een directory en diens subdirectory's recursief 
	af en levert als uitvoer een reeks padnamen (namen van 
	bestanden plus directory's) die aan bepaalde criteria 
	voldoen. 
	De uitvoer wordt niet gesorteerd. 
  </para>
  <para>
	Om een commando uit te voeren op elk van de gevonden 
	bestanden zou je iets kunnen doen als 

    <informalexample>
      <programlisting>
for bestand in `find ....`
do 
  <replaceable>commando</replaceable> $bestand 
done 								</programlisting>
    </informalexample>

	Dit heeft het nadeel dat de output van find potentieel 
	enorm lang kan zijn, terwijl shells maar een beperkte lengte 
	voor een commandoregel kunnen accepteren. 
	Deze maximale lengte kun je vinden met het commando 
    	<command> find /usr/include -name limits.h -follow -exec grep 
	ARG_MAX \{\} \; 2>>/dev/null </command>
  </para>
  <para>
	De oplossing is de <firstterm>xargs</firstterm> opdracht, 
	die het commando naar wens herhaalt, bijvoorbeeld tien keer 
	met telkens honderd argumenten, als er duizend bestanden 
	zijn gevonden. 
	De syntaxis van deze opdrachten luidt:

    <cmdsynopsis>
      <command> find						</command>
      <arg choice="opt" rep="repeat">
	<replaceable>	file					</replaceable>
      </arg>
      <arg choice="opt">
	<replaceable>	expressie				</replaceable>
      </arg>
      <arg choice="plain"> | \					</arg>
      <command>		xargs					</command>
      <arg choice="opt" rep="repeat">
        <replaceable>	optie					</replaceable>
      </arg>
      <arg>
	<replaceable>	commando				</replaceable>
      </arg>
      <arg choice="opt" rep="repeat">
	<replaceable>	argument				</replaceable>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	Het volgende voorbeeld zoekt alle core dumps in uw home 
	directory en subdirectory's. 
	<command>	find ~ -name "core" -print | xargs file	</command>
  </para>
  <para>
	De lijst van argumenten begint met een reeks directory's 
	die worden doorzocht, gevolgd door een optionele reeks 
	van tests en een of meer <firstterm>akties</firstterm>. 
	De akties worden alleen uitgevoerd als alle opties 
	<literal>true</literal> opleveren; 
	er mag ook <option>-a</option> tussen worden gezet. 
	Als meerdere opties worden verbonden door <option>-o</option> 
	dan zal de combinatie waar (0) opleveren als 
	&eacute;&eacute;n ervan waar is. 
	Het resultaat van een optie kan worden omgekeerd door er een 
	<option>!</option> voor te zetten en opties mogen tussen 
	<option>( )</option> haakjes worden gegroepeerd. 
	De haakjes moeten door een backslash worden beschermd tegen 
	substitutie door de shell. 
  </para>
  <para>
	Find kent de volgende tests: 
    <variablelist>
      <varlistentry>
	<term>
	  <option>	 -name <replaceable>"string"</replaceable></option>
	</term>
	<listitem>
	  <simpara>	waar als de naam van de file overeenkomt; 
			de string mag wildcards bevatten mits er 
			haakjes omheen of backslashes voor staan 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -perm <replaceable>getal</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als de <firstterm>permissie bits</firstterm> 
			overeenkomen met het oktale getal. 
			<command>man chmod</command> geeft meer 
			informatie over deze numerieke modes. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -type <replaceable>t</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand van het type 
			<replaceable>t</replaceable> is; 
			<literal>f</literal> staat voor een 
			gewone file, <literal>d</literal> voor 
			een directory, <literal>b</literal> voor 
			een block special file en 
			<literal>c</literal> voor character special 
			file. 
			Nieuwere systemen kennen ook 
			<literal>p</literal> voor named pipes, 
			<literal>s</literal> voor sockets en 
			<literal>l</literal> voor 
			<firstterm>symbolic links</firstterm> 
			(snelkoppelingen).
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -links <replaceable>n</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand 
			<replaceable>n</replaceable> links bezit.
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -user <replaceable>naam</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand eigendom is van 
			gebruiker <replaceable>naam</replaceable>; 
			dat mag een login naam of nummer zijn.  
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -group <replaceable>naam</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand eigendom is van 
			groep <replaceable>naam</replaceable>; 
			dat mag een groep naam of nummer zijn.
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -size <replaceable>n</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als de grootte van het bestand 
			<replaceable>n</replaceable> 
			<firstterm>disk blocks</firstterm> bedraagt. 
			Een disk block is 512 bytes groot, niet te 
			verwarren met de blokken van 1024 bytes van 
			<command>df</command>. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -inum <replaceable>n</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand <firstterm>inode
			nummer</firstterm> <replaceable>n
			</replaceable> heeft.
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -atime <replaceable>n</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand gedurende de laatste 
			<replaceable>n</replaceable> dagen is
			gebruikt. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -mtime <replaceable>n</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand gedurende de laatste
			<replaceable>n</replaceable> dagen is 
			gewijzigd.
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -newer <replaceable>file</replaceable>	</option>
	</term>
	<listitem>
	  <simpara>	waar als het bestand recenter is gewijzigd
			dan de opgegeven <replaceable>file</replaceable>
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	In de voorafgaande opties kan gehalve <replaceable>n</replaceable> 
	om een aantal aan te duiden ook de notatie 
	+<replaceable>n</replaceable> worden gebruikt voor aantallen 
	groter dan <replaceable>n</replaceable> of
	-<replaceable>n</replaceable> om aantallen kleiner dan 
	<replaceable>n</replaceable> aan te duiden. 
  </para>
  <para>
	Het volgende voorbeeld zoekt naar andermans files in uw home 
	directory.  
	<command>find ~ \! -user $USER -type f -print | xargs ls -l </command>
  </para>
  <para>
	Find kent de volgende akties:
    <variablelist>
      <varlistentry>
	<term>
	  <option>	 -print					</option>
	</term>
	<listitem>
	  <simpara>	drukt de naam van het huidige bestand af 
			op de uitvoer. 
			In de <acronym>GNU</acronym> versie kan 
			deze aktie worden weggelaten. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -exec <replaceable>commando</replaceable></option>
	</term>
	<listitem>
	  <simpara>	waar als de exit status van het 
			<replaceable>commando</replaceable> 
			gelijk is aan nul.  
			Het commando moet worden be&euml;indigd 
			met een puntkomma. 
			Als het commando <option>{}</option> bevat, 
			dan zal dat worden vervangen door de huidige 
			filenaam. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -ok <replaceable>commando</replaceable></option>
	</term>
	<listitem>
	  <simpara>	waar als de exit status van het 
			<replaceable>commando</replaceable> gelijk is 
			aan nul. 
			Find vraagt dan eerst om bevestiging en voert 
			het commando alleen uit als er 
			<userinput>y</userinput> wordt ingevoerd. 
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>

	De <acronym>GNU</acronym> versie heeft nog veel meer opties, 
	onder andere: 

    <variablelist>
      <varlistentry>
	<term>
	  <option>	 -follow				</option>
	</term>
	<listitem>
	  <simpara>	volg symbolische links
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -mount					</option>
	</term>
	<listitem>
	  <simpara>	sla gemounte filesystemen over
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>	 -maxdepth <replaceable>nivo</replaceable></option>
	</term>
	<listitem>
	  <simpara>	daal de directoryboom slechts tot het 
			opgegeven aantal <replaceable>nivo's</replaceable>
			af.
	</simpara>
	</listitem>
      </varlistentry>
  </variablelist>
  </para>
  <para>
	Hieronder een iets andere manier om <firstterm>core</firstterm> 
	files te zoeken. 
	Let op de backslashes.
	<command>find ~ -name core -exec file \{\}\; -print | grep core</command>
	Een handige manier om de inhoud van directory 
	<replaceable>origineel</replaceable> met alle subdirectory's 
	te kopi&euml;ren naar directory <replaceable>bestemming</replaceable> 
	gebruikt de <firstterm>pass-through</firstterm> optie van 
	<firstterm>cpio</firstterm>: 
	<command>find <replaceable>origineel</replaceable> -print | 
	cpio -pdm <replaceable>bestemming</replaceable></command>. 
	<acronym>SCO</acronym> <acronym>Unix</acronym> heeft hiervoor 
	een <firstterm>copy</firstterm> commando. 
  </para>
</sect2>
<sect2 id="du">
  <title>	directory's doorlopen met du			</title>
  <para>
	De <firstterm>du</firstterm> utility geeft een overzicht 
	van de hoeveelheid schijfruimte die een bepaalde 
	directory samen met de onderliggende subdirectory's in beslag 
	neemt. 
	Behalve als een uitgebreide versie van <firstterm>df</firstterm> 
	kun je het ook beschouwen als een snelle variant op find, 
	die alleen directory's weergeeft. 
	De syntaxis luidt: 

    <cmdsynopsis>
      <command> 	du					</command>
      <arg choice="opt">-a					</arg>
      <arg choice="opt">-k					</arg>
      <arg choice="opt">-s					</arg>
      <arg choice="opt">-x					</arg>
      <arg choice="opt" rep="repeat">
        <replaceable>	directory				</replaceable>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	Als er geen directory's opgegeven zijn, bekijkt du de 
	huidige directory. 
	De opties zijn als volgt: 
    <variablelist>
      <varlistentry>
	<term>
	  <option>-a</option> (all)				</term>
	<listitem>
	  <simpara>	geef de grootte van alle files, niet
			alleen directory's
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-k</option> (kilobyte)			</term>
	<listitem>
	  <simpara>	rapporteer de schijfruimte in kilobytes; 
			de standaardeenheid kan 512 bytes of 
			1024 bytes zijn. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-s</option> (summary)				</term>
	<listitem>
	  <simpara>	geef slechts &eacute;&eacute;n regel
			per directory
	</simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>-x</option> (exclude)				</term>
	<listitem>
	  <simpara>	sla directory's op gemounte schijven over
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>
<sect2 id="sed">
  <title>	sed, editen vanuit een script			</title>
  <para>
	Met behulp van egrep kun je informatie zoeken in een 
	tekstbestand. 
	Om regels te wijzigen is er de <firstterm>stream editor 
	sed,</firstterm> een broertje van de <firstterm>ed</firstterm> 
	editor, die weer een voorloper van <firstterm>vi</firstterm> 
	is, die speciaal gemaakt is voor gebruik in scripts. 
	Sed kopi&euml;ert telkens een volgende regel van de invoer 
	naar de <firstterm>patroonbuffer</firstterm>, 
	voert de opdrachten in zijn edit script &eacute;&eacute;n 
	voor &eacute;&eacute;n uit en kopi&euml;ert de buffer 
	naar de uitvoer. 
	De syntaxis luidt:

    <cmdsynopsis>
      <command> 	sed					</command>
      <arg choice="opt">-n					</arg>
      <arg choice="opt">-e <replaceable>script</replaceable>	</arg>
      <arg choice="opt">-f <replaceable>sfile</replaceable>	</arg>
      <arg choice="opt" rep="repeat">
        <replaceable>	file				</replaceable>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	Als de filenaam of -namen ontbreken dan zal sed de 
	standaard invoer verwerken. 
	Het edit script kan op de commandoregel achter de 
	<option>-e</option> vlag tussen aanhalingstekens worden 
	meegegeven of worden gelezen uit de file die met de 
	<option>-f</option> vlag wordt aangeduid. 
	Als de <option>-n</option> vlag wordt gebruikt, dan 
	wordt er alleen uitvoer gegeneerd door de print opdracht. 
  </para>
  <para>
	Onderstaand scriptje print de regels uit het wachtwoordbestand 
	die de letters <literal>rot</literal> of <literal>root</literal> 
	bevatten, net als egrep. 
	Zonder de <option>-n</option> vlag zouden deze dubbel worden geprint. 
	<command>sed -n -e '/ro\+t/p' /etc/passwd 		</command>
  </para>
  <para>
	Sed scripts zien er nog cryptischer uit dan shell scripts; 
	ze bestaan in het algemeen uit regels van de vorm 

  <cmdsynopsis>
    <arg choice="opt">
	<replaceable>adres</replaceable>1 
      <arg choice="opt">, <replaceable>adres</replaceable>2	</arg>
    </arg>
    <arg choice="opt">!						</arg>
    <arg choice="opt" rep="repeat">
	argument						</arg>
  </cmdsynopsis>
  </para>
  <para>
	Een scriptregel zonder adres wordt toegepast op elke 
	regel in de invoer, met &eacute;&eacute;n adres wordt de 
	functie toegepast op elke regel die met 
	<replaceable>adres</replaceable>1 overeenkomt, en met 
	twee adressen op de regels vanaf de eerste die overeenkomt 
	met <replaceable>adres</replaceable>1 tot de volgende die 
	overeenkomt met <replaceable>adres</replaceable>2. 
	Als dat niet geworden wordt, tot aan het eind van de file. 
	Als achter het adres een uitroepteken staat wordt de functie 
	toegepast op alle regels die niet geselecteerd zijn. 
  </para>
  <para>
	Een adres kan een decimaal regelnummer zijn, cat vanaf 1 
	geteld wordt, <literal>$</literal> voor de laatste 
	regel of een reguliere expressie tussen schuine strepen. 
	De <acronym>GNU</acronym> versie staat toe de reguliere 
	expressie te begrenzen met een ander teken dan de slash. 
	Het volgende voorbeeld retourneert de regels tussen 
	'root' en `bin' uit hter wachtwoordbestand.
	<command>sed -e '\#root#,\#bin#!d' /etc/passwd 		</command>
  </para>
  <para>
	Sed kent onder andere de volgende functies:
   <variablelist>
      <varlistentry>
	<term>
	  <option>p</option> (print)				</term>
	<listitem>
	  <simpara>	kopi&euml;er de inhoud van de 
			patroonbuffer naar de uitvoer; zonder de 
			<option>-n</option> optie kan dat 
			resulteren in dubbel afgedrukte regels. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>n</option> (next)				</term>
	<listitem>
	  <simpara>	drukt de inhoud van de patroonbuffer af 
			op de uitvoer en leest de volgende 
			regel van de invoer in de patroonbuffer. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>d</option> (delete)				</term>
	<listitem>
	  <simpara>	maak de patroonbuffer leeg en ga verder 
			met de volgende regel. 
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
          <cmdsynopsis>
	    <arg choice="plain">
			a \ </arg>				<sbr>
	    <arg choice="plain">	
			<replaceable>tekst</replaceable>	</arg>
	  </cmdsynopsis>
	</term>
	<listitem>
	  <simpara>	plaats een regel tekst in de uitvoer 
			voordat de volgende regel wordt gelezen.
	</simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
          <cmdsynopsis>
	    <arg choice="plain">
			c \ </arg>				<sbr>
	    <arg choice="plain">	
			<replaceable>tekst</replaceable>	</arg>
	  </cmdsynopsis>
	</term>
	<listitem>
	  <simpara>	Maak de patroonbuffer leeg, schrijf de 
			tekst naar de uitvoer en lees de volgende 
			regel in. 
	</simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
          <cmdsynopsis>
	    <arg choice="plain">
			i \ </arg>				<sbr>
	    <arg choice="plain">	
			<replaceable>tekst</replaceable>	</arg>
	  </cmdsynopsis>
	</term>
	<listitem>
	  <simpara>	plaats een regel tekst in de uitvoer. 
			Append en insert hebben hooguit 
			&eacute;&eacute;n adres. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>q</option> (quit)				</term>
	<listitem>
	  <simpara>	be&euml;indig het programma zonder de 
			rest van de invoer te lezen. 
			Quit gebruikt hooguit &eacute;&eacute;n adres. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>=</option> (regelnummer)			</term>
	<listitem>
	  <simpara>	schrijf het regelnummer naar de uitvoer op een 
			aparte regel.  
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>w <replaceable>file</replaceable></option>	</term>
	<listitem>
	  <simpara>	voeg de inhoud van de patroonbuffer toe 
			aan het opgegeven bestand. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>r <replaceable>file</replaceable></option>	</term>
	<listitem>
	  <simpara>	lees de inhoud van het opgegeven bestand 
			en schrijf die naar de uitvoer alvorens 
			de volgende invoerregel te lezen. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>h</option> (hold)				</term>
	<listitem>
	  <simpara>	vervang de inhoud van de 
			<firstterm>houdbuffer</firstterm> door 
			die van de patroonbuffer. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>g</option> (get)				</term>
	<listitem>
	  <simpara>	vervang de patroonbuffer door de inhoud 
			van de houdbuffer.
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>x</option> (exchange)				</term>
	<listitem>
	  <simpara>	verwissel de inhoud van de patroonbuffer 
			en de houdbuffer. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>y/<replaceable>string</replaceable>1/<replaceable>string</replaceable>2/</option> (yield)</term>
	<listitem>
	  <simpara>	vervang tekens uit <replaceable>string</replaceable>1 
			door overeenkomstige tekens van 
			<replaceable>string</replaceable>2; 
			beide strings moeten even lang zijn.
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>N</option> (next)				</term>
	<listitem>
	  <simpara>	voeg de volgende regel toe aan de patroonbuffer 
			met een regeleinde (<literal>\n</literal>) 
			ertussen. 
			Normaliter bevat de buffer geen 
			<literal>\n</literal>. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>D</option> (delete)				</term>
	<listitem>
	  <simpara>	Verwijder de eerste regel van de patroonbuffer 
			en ga verder met de volgende invoerregel. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>G</option> (get)				</term>
	<listitem>
	  <simpara>	plaats een regel text in de uitvoer voordat 
			de volgende regel wordt gelezen.
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>P</option> (print)				</term>
	<listitem>
	  <simpara>	kopi&euml;er de eerste regel van de 
			patroonbuffer naar de standaard uitvoer.  
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>H</option> (hold)				</term>
	<listitem>
	  <simpara>	voeg de inhoug van de patroonbuffer toe 
			aan de houdbuffer.
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>#	<replaceable>commentaar</replaceable></option></term>
	<listitem>
	  <simpara>	Na een hekje wordt de rest van de regel 
			genegeerd, net als een lege regel 
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
          <cmdsynopsis>
	    <arg choice="plain">
			{ <replaceable>functie</replaceable>1	</arg><sbr>
	    <arg choice="plain" rep="repeat">	
			<replaceable>functie</replaceable>2	</arg><sbr>
	    <arg choice="plain">
			}					</arg>
	  </cmdsynopsis>
	</term>
	<listitem>
	  <simpara>	In plaats van een functie wordt de hele 
			groep uitgevoerd. 
			Functies op &eacute;&eacute;n regel 
			mogen ook door puntkomma's worden afgesloten. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>s/<replaceable>regul. expressie</replaceable>/<replaceable>vervanging</replaceable>/[<replaceable>flags</replaceable>]</option> (substitute)</term>
	<listitem>
	  <simpara>	zoek tekst en vervang die. 
			Als voor het adres reeds een zoekexpressie is 
			gebruikt, kan achter de <literal>s</literal> 
			een lege expressie staan. 
			De flags kunnen een <literal>g</literal> 
			omvatten als er meerdere substituties in een regel 
			kunnen voorkomen, een <literal>p</literal> om de 
			patroonbuffer te printen als er een vervanging 
			is gemaakt en 
			<literal>w <replaceable>file</replaceable></literal> 
			om de inhoud van de patroonbuffer naar de file te 
			schrijven als er iets is vervangen. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>:<replaceable>naam</replaceable></option> (label)</term>
	<listitem>
	  <simpara>	doet niets, maar markeert een positie om 
			naar toe te springen. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>b [<replaceable>naam</replaceable>]</option> (branch)</term>
	<listitem>
	  <simpara>	ga verder met de volgende functie achter 
			het label <replaceable>naam</replaceable>. 
			Als de naam is weggelaten, spring naar het 
			eind van het script en ga verder met de 
			volgende invoerregel. 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>t [<replaceable>naam</replaceable>]</option> (test)</term>
	<listitem>
	  <simpara>	ga verder met de volgende functie achter 
			het label <replaceable>naam</replaceable> 
			als er sinds het inlezen van de invoerregel 
			of sinds de vorige test opdracht een succesvolle 
			substitutie heeft plaatsgevonden. 
			Als de naam ontbreekt wordt er naar het eind 
			van het script gesprongen. 
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Het volgende voorbeeld zet regelnummers voor de invoer; 
	<acronym>BSD</acronym> en <acronym>gnu</acronym> systemen 
	bereiken hetzelfde met <command>cat -n</command>.  
	Omdat de regelnummers op aparte regels komen, wordt een 
	tweede sed commando gebruikt om ze samen te voegen en de 
	regeleinden te vervangen door spaties. 

    <informalexample>
      <programlisting>
sed -n -e '=; p' | sed -n -e 'N; s/\n/ /p' 			</programlisting>
    </informalexample>
  </para>
  <para>
	De volgende variant illustreert hoe met tweetal adressen 
	meerdere regelbereiken worden gevonden. 

    <informalexample>
      <programlisting>
ls /bin | sed -n -e '/name/,/t/{=;p;}' | \
  sed -n -e 'N; s/\n/ /p'					</programlisting>
    </informalexample>
  </para>
  <para>
	Het volgende voorbeeld zet een spatie achter ieder teken en 
	een lege regel achter iedere regel en vervangt alle kleine 
	letters door hoofdletters. 

    <informalexample>
      <programlisting>
sed -e 's/\(.\)/\1 /g 
y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/
G'								</programlisting>
    </informalexample>
  </para>
  <para>
	Voor meer informatie en voorbeelden, zie 
	<ulink url="http://seders.icheme.org/"> the seders' grab-bag.</ulink> 
	Hierna volgt een wat uitgebreider shell script dat gebruik 
	maakt van sed om commentaar in C<superscript>++</superscript> 
	stijl te veranderen in standaard C code. 
	Het maakt gebruik van ledige substituties om te testen of 
	een bepaald patroon in de invoerregel voorkomt. 
	De functie <firstterm>extension</firstterm> behoeft wellicht 
	verbetering voor namen als <filename>app-1.0.0.tar.gz</filename>. 

    <informalexample>
      <programlisting>
<command>subst()</command>
{ sed -e '
         //\*/s/$//
         t loop
         b cont

:loop
         /\*//s/$//
         t cont
         n
         b loop
:cont
         /\/\//s/$//
         t found
         b
:found
         /\".*\/\/.*\"/s/$//
         t
         /\*\/\/\*/s/$//
         t
         /\/\*.*\/\/.*\*\//s/$//
         t
         /\/\//s/$/ \*\//
         /\/\/.*\/\*.*\*\//s/\*\///
         /\/\//s//\/\*/
         t
         ' $1
}

<command>stringlen()</command>
{ if [ "$1" = "" ]
  then
    echo "0"
  else
    expr length "$1"
  fi
}

<command>substring()</command>
{ if [ "$1" = "" ]
  then
    echo ""
  else
    expr substr "$1" "$2" "$3"
  fi
}

<command>lastindex()</command>
{ name="$1"
  DotPos1=0
  DotPos2=`expr index "$name" "$2"`
  while [ "$DotPos2" -gt "0" ]
  do
    DotPos1=`expr $DotPos1 + $DotPos2`
    DotPos2=`expr $DotPos2 + 1`
    name=`substring "$name" $DotPos2 999`
    DotPos2=`expr index "$name" "$2"`
  done
  echo $DotPos1
}

<command>extension()</command>
{ DotPos=`lastindex "$1" "."`
  if [ "$DotPos" -gt "0" ]
  then
   substring "$1" `expr $DotPos + 1` `stringlen "$1"`
  else
    echo ""
  fi
}

<replaceable># main loop - find files to be modified </replaceable>
find . -print \
| while read i
  do
    if [ -f "$i" ] && [ -r "$i" ]
    then
      if [ -w "$i" ]
      then
        if [ "`extension $i`" = "c" ] || \
           [ "`extension $i`" = "h" ]
        then
          if grep '//' $i &gt;&thinsp;&gt;/dev/null
          then
            echo "File $i is modified."
            mv "$i" "$i"~
            subst "$i"~ &gt;$i
          fi
        fi
      else
        echo "File $i is not writable!"
      fi
    fi
  done								</programlisting>
    </informalexample>
  </para>
</sect2>
<sect2 id="awk">
  <title>	tabellen verwerken met awk			</title>
  <para>
	De scripttaal <firstterm>awk</firstterm> (klinkt als 
	<literal>`look awk`</literal>) is genoemd naar haar 
	makers, Aho, Weinberger en Kernighan van A, T & T. 
	Awk is uitgebreider dan sed en vooral geschikt voor het 
	verwerken van tabellen. 
	Veel Unix commando's als ls, ps, en who produceren tabellen, 
	platte tekstfiles bestaaande uit kolommen met een vaste breedte. 
	De syntaxis luidt:
 
   <cmdsynopsis>
      <command> awk						</command>
      <arg choice="opt" rep="repeat">
		<replaceable>optie</replaceable>
      </arg>
      <arg choice="opt">
		-f <replaceable>sfile</replaceable>	
      </arg>
      <arg choice="plain"> 
		<replaceable>'script'</replaceable>	
      </arg>
      <arg choice="opt" rep="repeat">
		<replaceable>file</replaceable>
      </arg>
    </cmdsynopsis>
  </para>
  <para> 
	De belangrijkste optie is 
	<option>-F<replaceable>t</replaceable></option>, waarmee 
	het teken <replaceable>t</replaceable> als 
	<firstterm>field separator</firstterm> wordt ingesteld. 
	Het script zelf kan weer als een groot argument op de 
	commandoregel worden meegegeven of in een aparte file 
	met <option>-f</option>, en als er geen verdere filenamen 
	zijn meegegeven, dan zal awk de standaard invoer verwerken. 
	Awk scripts hebben over het algemeen de vorm 

    <synopsis>
[<command>BEGIN</command> {<replaceable>actie</replaceable>}]
[<replaceable>patroon</replaceable>] [{<replaceable>actie</replaceable>}] 
&hellip;
[<command>END</command>     {<replaceable>actie</replaceable>}] </synopsis>
  </para>
  <para>
	Net als bij sed zal elke invoerregel &eacute;&eacute;n voor 
	&eacute;&eacute;n met de patronen worden vergeleken en 
	voor elk patroon dat overeenkomt zal de bijbehorende actie 
	worden uitgevoerd. 
	Als er geen patroon is opgegeven wordt de actie altijd 
	uitgevoerd en als er geen actie staat, dan wordt de 
	invoerregel afgedrukt. 
	De eventuele actie achter begin wordt voor het inlezen 
	van de eerste regel uitgevoerd en de actie achter end na 
	het eind van de laatste regel. 
	Het eerste voorbeeld verwijdert lege regels uit de invoer: 
	<command>awk '$0'					</command> 
  </para>  
  <para>
	Hierin staat <literal>$0</literal> voor de invoerregel. 
	De invoerregel wordt door awk gesplitst in velden, 
	gescheiden door witruimte of een ander scheidingsteken, 
	genaamd <literal>$1</literal>, <literal>$2</literal>, &hellip;. 
	<literal>NF</literal> is het aantal velden en 
	<literal>NR</literal> het aantal records c.q regelnummer. 
	Het toevoegen van regelnummers aan de input gaat met awk 
	eenvoudiger dan met sed: 
	<command>awk '{print NR " " $0}'			</command> 
  </para>
  <para>
	De patronen kunnen boolese combinaties van reguliere 
	expressies en&thinsp;/&thinsp;of relationele expressies 
	zijn. 
	De boolese combinatoren zijn <command>!</command> (niet), 
	<command>&&</command> (en), <command>||</command> (of) 
	en de <command>( )</command> haakjes; de reguliere expressies 
	zijn eerder besproken; 
	de relationele combinatoren zijn <command>&lt;</command> 
	(kleiner), <command>&gt;</command> (groter), 
	<command>&lt;=</command> (kleiner of gelijk), 
	<command>&gt;=</command> (groter of gelijk), 
	<command>==</command> (gelijk), <command>!=</command> 
	(ongelijk), <command>~</command> (komt overeen met 
	reguliere expressie) en <command>!~</command> (komt niet 
	overeen met RE). 
  </para>
  <para>
	Expressies kunnen verder bestaan uit variabelen, numerieke 
	constanten (gehele getallen of drijvende komma) en string 
	constanten (tussen dubbele aanhalingstekens) en de 
	rekenkundige operatoren <command>+</command> (optellen), 
	<command>-</command> (aftrekken), <command>*</command> 
	(vermenigvuldigen), <command>/</command> (delen), 
	<command>%</command> (rest), <command>^</command> of 
	<command>**</command> (machtsverheffen), 
	<command>++</command> (1 optellen) en <command>--</command> 
	(1 aftrekken) als in de programmeertaal C en de string 
	operator <command>' '</command> (samenvoeging). 
  </para>
  <para>
	Behalve enkelvoudige patronen kunnen net als bij sed reeksen 
	regels worden opgegeven met een tweetal patronen. 
	De volgende regel selecteert de regels 10 t&thinsp;/&thinsp;m 
	20 van een bestand. 
	<command>awk 'FNR==10, FNR==20' /etc/hosts		</command> 
  </para>
  <para>
	Een awk script kan ook variabelen aanmaken; 
	declareren is niet nodig. 
	Een variabele kan zowel als string als getal worden 
	gebruikt en wordt automatisch ge&iuml;nitialiseerd met 
	waarden <literal>0</literal> en <literal>""</literal>. 
	De operatoren bepalen het type van het resultaat: 
	zo levert <literal>("3x" + 1)</literal> 4 op maar 
	<literal>("x3" + 1)</literal> 1. 
	Behalve een constante tussen schuine strepen kan ook 
	een variabele als reguliere expressie worden gebruikt. 
	De eenvoudigste acties zijn 
	<literal><replaceable>variabele</replaceable> = 
	<replaceable>expressie</replaceable></literal> en 
	<literal>print <replaceable>expressie</replaceable></literal>. 
	Het is ook mogelijk om de <firstterm>veldvariabelen</firstterm> 
	$1, $2,&hellip; een andere waarde toe te kennen. 
  </para>
  <para>
	Moderne awk varianten kennen associatieve arrays. 
	Arrays hoeven niet gedeclareerd te worden: 
	het is voldoende een element van een array een waarde te geven 
	met <literal><replaceable>naam</replaceable>[ 
	<replaceable>index</replaceable>] = 
	<replaceable>waarde</replaceable></literal>. 
	Voor de index kunnen gehele getallen of willekeurige strings 
	worden gebruikt, zelfs meerdere getallen zijn toegestaan om 
	pseudo-multidimensionale arrays te maken. 
	De waarden van de index hoeven niet opeenvolgend te zijn. 
  </para>
  <para>
	Awk kent een aantal rekenkundige functies. 

    <informaltable frame=none>
      <tgroup cols=2>
	<colspec colwidth="1*">
	<colspec colwidth="3*">
	<tbody>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>sin(<replaceable>x</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      berekent de sinus van x, met x in radialen
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>cos(<replaceable>x</replaceable>)</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      berekent de cosinus van x
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>exp(<replaceable>x</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      berekent de e-macht van x
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>int(<replaceable>x</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      berekent de entier van x 
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>log(<replaceable>x</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      berekent de natuurlijke logarithme van x
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>sqrt(<replaceable>x</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      berekent de wortel van x
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>rand</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      berekent een toevalsgetal tussen 0 en 1
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>srand(<replaceable>x</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      maakt x tot generator van een reeks toevalsgetallen
	    </entry>
	  </row>
	</tbody>
      </tgroup>
    </informaltable>
  </para>
  <para>
	Awk kent verschillende string functies. 

    <informaltable frame=none>
      <tgroup cols=2>
	<colspec colwidth="1*">
	<colspec colwidth="3*">
	<tbody>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>gsub(<replaceable>r,s,t</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
		vervangt in de string <replaceable>t</replaceable> 
		overal de substring <replaceable>r</replaceable> 
		door <replaceable>s</replaceable> en retourneert
		het aantal malen dat de substitutie is uitgevoerd
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>index(<replaceable>s,t</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
		retourneert de positie van substring 
		<replaceable>t</replaceable>in <replaceable>s</replaceable> 
		of 0 is die niet is gevonden
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>length(<replaceable>s</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
			retourneert de lengte van de string
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>substr(<replaceable>s,p,n)</replaceable></literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
		retourneert de substring van <replaceable>s</replaceable>, 
		vanaf positie <replaceable>p</replaceable> van 
		<replaceable>n</replaceable> tekens lang
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>tolower(<replaceable>s</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
		retourneert <replaceable>s</replaceable> met alle 
		hoofdletters vervangen door kleine 
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>toupper(<replaceable>s</replaceable>)</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
		retourneert <replaceable>s</replaceable> met alle 
		kleine letters vervangen door hoofdletters 		
	    </entry>
	  </row>
	</tbody>
      </tgroup>
    </informaltable>
  </para>
  <para>
	Awk lijkt een beetje op C. 
	Acties c.q. statements worden gegroepeerd door accolades en 
	afgesloten door een puntkomma of nieuwe regel. 
	Een lang statement kan worden voortgezet door de regel met een 
	backslash te be&euml;indigen. 
	Na een <literal>#</literal> hekje wordt de rest van de regel 
	als commentaar beschouwd. 
	Het <firstterm>if-statement</firstterm> heeft de volgende syntaxis. 
 
     <synopsis>
<command>if</command>( <replaceable>expressie</replaceable> ) <replaceable>statement</replaceable>1 [<command>else</command> <replaceable>statement</replaceable>2] </synopsis>
  </para>
  <para>
	Als de expressie ongelijk is aan 0 c.q. "", dan wordt het 
	eerste statement uitgevoerd en anders het optionele tweede. 
	Voor herhaling bestaan er twee varianten van 
	<firstterm>while</firstterm> en de 
	<firstterm>for-lus</firstterm>.
 
    <synopsis>  
<command>while(</command> <replaceable>expressie</replaceable>) <replaceable>statement</replaceable>
<command>do</command> <replaceable>statement</replaceable> <command>while</command> (<replaceable>expressie</replaceable>) 
<command>for</command>( <replaceable>expressie</replaceable>1; <replaceable>expressie</replaceable>2; <replaceable>expressie</replaceable>3) <replaceable>statement</replaceable> </synopsis>
  </para>
  <para> 
	De eerste expressie achter for initialiseert de lus, de 
	tweede test of de lus be&euml;indigd moet worden en de derde 
	wordt na elke doorgang uitgevoerd. 
	Om tot tien te tellen gebruik je
	<command>awk 'BEGIN {} {} END {for( i = 1;i <= 10;i++) print i}'</command>
  </para>
  <para>
	De volgende vorm van de for-lus loopt alle elementen van 
	een array af:
 
    <synopsis>
<command>for</command> (<replaceable>variabele</replaceable> <command>in</command> <replaceable>array</replaceable>) <replaceable>statement</replaceable> </synopsis>
  </para>
  <para> 
	Met <command>break</command> kan een lus voort&ijlig;dig worden 
	verlaten; 
	met <command>continue</command> wordt de rest van de inhoud 
	van de lus overgeslagen en met <command>exit</command> 
	wordt de rest van de invoer overgeslagen en gaat awk verder 
	met de eventuele actie achter <command>end</command>; 
	in de end-sectie kan weer een <command>exit</command> 
	opdracht volgen met een exit status. 
  </para>
  <para>
	In moderne versies van awk kunnen in een script eigen 
	functies gedefinieerd worden met

    <synopsis>
<command>function</command> <replaceable>naam</replaceable>( <replaceable>parameter</replaceable>1,&thinsp;&hellip; ) { <replaceable>statements</replaceable> } </synopsis>
  </para>
  <para>
	Functies moeten worden gedeclareerd voordat ze kunnen 
	worden gebruikt. 
	Met de <command>return</command> opdracht kunnen ze 
	een waarde teruggeven. 
	Als in een functie de waarde van een parameter gewijzigd 
	wordt, dan zal dit geen effekt hebben op de waarde van 
	een variabele die als argument is meegeven, behalve voor 
	arrays. 
  </para>
  <para>
	Het is mogelijk om met <firstterm>print</firstterm> naar 
	een willekeurige file te schrijven met de notatie

    <synopsis> 
<command>print</command> <replaceable>waarde</replaceable> &gt;"<replaceable>file</replaceable>" </synopsis>

	Zonder de aanhalingstekens is file een variabele die de 
	naam van het bestand bevat. 
	Om de uitvoer achter de bestaande inhoud van het bestand 
	te plakken wordt het volgende gebruikt:

    <synopsis>
<command>print</command> <replaceable>waarde</replaceable> &gt;&thinsp;&gt;"<replaceable>file</replaceable>" </synopsis>

	Het is ook mogelijk om binnen een awk script een extern 
	commando te starten dat de uitvoer van print leest 
	met de notatie 

    <synopsis>
<command>print</command> <replaceable>waarde</replaceable> | "<replaceable>commando</replaceable>" </synopsis>

	Om de output van een extern commando in te lezen kun je iets 
	als <command>system( "<replaceable>commando</replaceable>" | 
	getline)</command> gebruiken. 
  </para>
  <para	id="printf" xreflabel="paragraaf 3.7">
	Om nette tabellen te maken wordt het <firstterm>printf</firstterm> 
	statement gebruikt met de volgende syntaxis:

    <synopsis>
<command>printf</command> "<replaceable>formaat</replaceable>", <replaceable>expressie</replaceable>1,&thinsp;&hellip; </synopsis>
  </para>
  <para>
	De formaat string wordt gewoon afgedrukt, afgezien van 
	formaat specificaties, die worden vervangen door 
	&eacute;&eacute;n van de volgende expressies. 
	Anders dan voor print moet de formaat string worden afgesloten 
	met een regeleinde (<literal>\n</literal>). 
	Een formaat specificatie geeft aan in welk formaat de 
	bijbehorende expressie moet worden afgedrukt en heeft de vorm 

    <synopsis>
%[-][0][<replaceable>breedte</replaceable>[.<replaceable>precisie</replaceable>]]<replaceable>type</replaceable> </synopsis>
  </para>
  <para>
	De expressie wordt afgedrukt in <replaceable>breedte</replaceable> 
	kolommen, mits het daarin past, en eventueel aangevuld met 
	spaties, maar als de breedte met 0 begint, worden er 
	voorloopnullen gebruikt. Een eventueel min-teken geeft aan 
	dat de waarde links moet worden aangelijnd. 
	Voor getallen geeft de <replaceable>precisie</replaceable> 
	het aantal cijfers achter de komma c.q. decimale punt weer; 
	voor strings is dat de lengte waarop de string wordt afgekapt, 
	waarna het resultaat wordt aangevuld tot de opgegeven breedte. 
	Het afkappen van relevante informatie kan een bug in een script 
	vormen. 
	De volgende formaattypen zijn mogelijk. 

    <informaltable frame=none>
      <tgroup cols=2>
	<colspec colwidth="1*">
	<colspec colwidth="3*">
	<tbody>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>%%</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een enkel procentteken
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%c</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een enkel letterteken
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%c</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een enkel letterteken
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%s</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een string
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%d</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een geheel getal; breuken worden niet afgerond
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%o</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een positief geheel getal in octale stelsel
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%x</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een positief geheel getal in hexadecimale stelsel
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%f</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een decimale breuk
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%e</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      een getal in drijvende-komma notatie
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	     <listitem>
		<literallayout>%g</literallayout>								
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      de best leesbare notatie voor het getal
	    </entry>
	  </row>
	</tbody>
      </tgroup>
    </informaltable>
  </para>
  <para>
	Zo zullen de volgende opdrachten

    <informalexample>
      <programlisting>
{ printf "%10.3s\n", 3.1415692}
{ printf "%10.3f\n", 3.1415692} 				</programlisting>
    </informalexample>
	als output geven:
    <screen>
       3.1
     3.142							</screen>
  </para>
</sect2>
<sect2 id="expect">
  <title>	 expect en andere scripttalen			</title>
  <para>
	De behandeling van awk is hier vrij kort gehouden 
	ondanks de vrij complexe materie. 
	De clou is dat een van de belangrijkste redenen om awk 
	binnen een shell script te gebruiken, de printf functie, 
	ook in de korn en bourne again shells is ingebouwd. 
	Ook de andere scripttalen als Perl, TCL, PHP3 en Python, 
	zijn te uitgebreid om hier te behandelen. 
	Perl lijkt enigszins op awk, met nog meer mogelijkheden. 
	Tk maakt in combinatie met TCL of Perl GUI scripts mogelijk. 
  </para>
  <para>
	C programmeurs gebruiken make files, die aangeven welke 
	source files met welke opties moeten worden gecompileerd 
	om binaries en libraries te maken. 
	Make files bevatten weer shell commando's. 
	De m4 macroprocessor is een geval apart, dat te vergelijken 
	is met de C preprocessor, en handig is voor assembly 
	programmeurs. 
	Een m4 file kan willekeurige tekst bevatten plus 
	macrodefinities en macro's. M4 vervangt dan de macro's 
	door hun definitie. 
  </para>
  <para>
	Postscript&trade; van Adobe wordt een 
	paginabeschrijvingstaal genoemd. 
	Postscript programma's worden geschreven door 
	opmaakprogramma's en uitgevoerd door printers, 
	resulterend in een of meer pagina's gedrukt tekst. 
	Elementen die op elke pagina terugkomen worden eenmalig 
	als een functie gedefinieerd. Verder heeft het wat
	van Forth weg. 
	Het voordeel is dat de taal onafhankelijk van het type printer is. 
  </para>
  <para>
	Om een script te schrijven dat interactie, zowel in- als 
	uitvoer, pleegt met een ander programma, kun je gebruik 
	maken van 
	<ulink url="http://expect.nist.gov"><firstterm>Expect</firstterm>,</ulink> 
	dat weer gebruik maakt van John Ousterhout's Tool Command 
	Language. 
	De syntaxis luidt 

  <cmdsynopsis>
    <command>		expect					</command>
    <arg choice="opt">	-di					</arg>
    <arg choice="opt">	-c <replaceable>script</replaceable>	</arg>
    <arg choice="opt">	-f <replaceable>sfile</replaceable>	</arg>
    <arg choice="plain" rep="repeat">				</arg>
  </cmdsynopsis>
  </para>
  <para>
	De <option>-d</option> optie geeft een hoop diagnostische 
	uitvoer. 
	Met de <option>-i</option> optie gedraagt expect zich als 
	een interactieve shell. 
	Achter <option>-c</option> kan in een heel script (tussen 
	aanhalingstekens) worden opgegeven en met <option>-f</option> 
	kan de naam van de file met het script worden meegegeven. 
	Hieronder volgt een voorbeeld waarin expect wordt gebruikt 
	om een bestand te downloaden via ftp, wat met de shell niet 
	zou lukken. 
  </para>
  <para>
    <informalexample>
      <programlisting>						<command>
#!/usr/bin/expect -f						</command>

<replaceable># zoals aangegeven in paragraaf 1.3 wordt hierboven
# expect gestart en de rest zijn expect commando's		</replaceable>

spawn ftp localhost
								<replaceable>
# Met spawn wordt een extern programma gestart 			</replaceable>

expect -re "Connected.*\n"
expect -re "220.*\n"
expect -re "Name.*:.?"
								<replaceable>
# Het expect commando laat expect wachten totdat het
# het externe programma de opgegeven strings uitprint
# of er een time-out of end-of-file optreedt. 
# Na de -re optie volgt een reguliere expressie. 
# \n staat voor een nieuwe regel en \r voor return. 		</replaceable>

send "anonymous\r"
expect "anonymous\r\n"

								<replaceable>
# Het send commando stuurt de user naam naar het ftp
# proces. Dat zal de invoer terug echoen.			</replaceable>

expect  {
          -re 331.*\nPassword: {
                                 expect_user -re.*\n
                               }
         }

								<replaceable>
# We wachten op de password-prompt van de ftp server
# en dan vraagt het script de gebruiker om zelf 
# het wachtwoord in te vullen. 					</replaceable>

send "$expect_out(0,string)\r"
expect "\r\n"

								<replaceable>
# We sturen de invoer van de gebruiker naar de ftp
# server. Die zal het wachtwoord niet laten zien. 		</replaceable>

expect  {
        -re (230.*\n)+.*\n.*\n  {}
        -re (530.*.n)+.*\n      exit
        }
}

								<replaceable>
# Nu zijn er twee mogelijk heden: 230. User anonymous
# logged in, of 530. Login incorrect; in het eerste
# geval doen we niets en in het tweede geval stoppen
# we de expect sessie. 						</replaceable>

expect -re "ftp>.?"
send "cd pub\r"
expect "cd pub\r\n"
expect -re "(250.*\n)*250.*successful.*\n"

								<replaceable>
# We wachten op de ftp prompt en sturen "cd pub" 
								</replaceable>
expect -re "ftp>.?"
send "ls\r"
expect "ls\r\n"
expect -re "200.*\n150.*\ntotal(.*\n)+226.*\n"

								<replaceable>
# We sturen "ls" en krijgen een aantal regels terug, 
# en na de prompt sturen we "get README" 			</replaceable>

expect -re "ftp>.?"
send "get README\r"
expect "get README\r\n"
expect {
 -re local.*\n200.*\n150.*\n226.*\n.*received.*\n {}
 -re local.*\n200.*\n550.*\n                       exit

}								</programlisting>
    </informalexample>

	De rest van dit hoofdstuk wordt besteed aan een korte 
	beschrijving van enkele handige 
	<acronym>Unix</acronym> commando's. 
  </para>
</sect2>
<sect2 id="at">
  <title>	 at en batch					</title>
  <para>
	De <firstterm>at</firstterm> faciliteit zorgt ervoor dat 
	opdrachten op een later tijdstip worden uitgevoerd. 
	De syntaxis luidt: 

  <cmdsynopsis>
    <command>		at					</command>
    <arg choice="opt">	-m					</arg>
    <arg choice="opt">	-l					</arg>
    <arg choice="opt">	-f <replaceable>file</replaceable>	</arg>
    <arg choice="opt">	-q <replaceable>letter</replaceable>	</arg>
    <arg choice="opt">	-r <replaceable>job</replaceable>	</arg>
    <arg choice="plain">   <replaceable>tijdstip</replaceable>	</arg>
  </cmdsynopsis>
  </para>
  <para>
	De <option>-f</option> optie wordt gevolgd door de naam 
	van het uit te voeren script; 
	als deze optie ontbreekt, dan worden commando's van de 
	standaard invoer gelezen. 
	De uitvoer van het script wordt de gebruiker toegemaild, 
	dus die hoeft op het moment van uitvoering niet ingelogd 
	te zijn. 
	Op de meeste systemen hebben ook gewone gebruikers 
	toestemming om at te gebruiken. 
  </para>
  <para>
	De <option>-m</option> optie zorgt ervoor dat er ook 
	mail wordt verzonden als de opdracht geen uitvoer 
	produceerde. 
	Er wordt voor gezord dat de commando's dezelfde 
	omgevingsvariabelen meekrijgen als op het moment dat 
	at werd aangeroepen. 
  </para>
  <para>
	Het <firstterm>batch</firstterm> commando doet hetzelfde 
	als at, behalve dat commando's pas worden uitgevoerd 
	wanneer de belasting van het systeem voldoende laag is. 
	Die belasting krijg je te zien met 
	<command>uptime</command>. 
	De <option>-q</option> vlag geeft aan in welke queue 
	(wachtrij) de job terecht komt. 
	De queue bepaalt de prioriteit waarmee een taak wordt 
	uitgevoerd: 
	<literal>a</literal> is de default at queue, 
	<literal>b</literal> de default batch queue. 
  </para>
  <para>
	De tijd kan worden opgegeven als 
	<replaceable>uumm</replaceable> of <replaceable>uu:mm</replaceable>, 
	desgewenst met <literal>am</literal> of <literal>pm</literal> 
	erachter. 
	De liefhebber mag ook <literal>now</literal>, 
	<literal>midnight</literal>, <literal>noon</literal> of 
	<literal>teatime</literal> gebruiken. 
	Daarachter komt de eventuele datum, die bijvoorbeeld 
	<literal>today</literal> of <literal>tomorrow</literal> 
	mag luiden. 
	Als het tijdstip al voorbij is, wordt aangenomen dat het 
	morgen moet zijn en als de dag al geweest is, dan zal de 
	gebruiker wel volgend jaar bedoelen. Enkele voorbeelden: 

    <informalexample>
      <programlisting>
at 0815am Jan 24, 2002 
at 8:15am Jan 24 
at now + 1 day 
at 5 pm Friday next week  					</programlisting>
    </informalexample>
  </para>
  <para>   
	Met de <option>-l</option> optie krijg je een lijst van 
	de geplande taken te zien. 
	Met de <option>-r</option> optie kun je een taak 
	verwijderen. 
	Alleen <literal>root</literal> mag andermans taken annuleren. 
  </para>
</sect2>
<sect2 id="cron">
  <title>	 cron						</title>
  <para>
	<firstterm>Cron</firstterm> is een <acronym>Unix</acronym> 
	daemon, een systeemprogramma dat op de achtergrond loopt, 
	die op gezette tijden opgegeven programma's start, 
	terwijl at voor eenmalige opdrachten is; 
	op sommige systemen start cron elke minuut een programma 
	dat kijkt of er nog at jobs te doen zijn. 
	Cron wordt meestal gebruikt door de systeembeheerder om 
	bijvoorbeeld 's nachts backups te draaien, maar is vaak 
	ook voor de andere gebruikers beschikbaar. 
  </para>
  <para>
	Net als at zal cron eventuele uitvoer van een opdracht 
	naar de opdrachtgever mailen, tenzij je de standaard 
	uitvoer omleidt; 
	er wordt doorgaans een regel in een log file geschreven 
	voor uitgevoerde jobs. 
	Een nadeel van cron is dat taken die niet op het aangegeven 
	tijdstip uitgevoerd kunnen worden, bijvoorbeeld omdat de 
	computer down is, zullen worden overgeslagen. 
	Een ander verschil met at is dat je de omgevingsvariabelen 
	mist die worden ingesteld als je inlogt. 
  </para>
  <para>
	De gebruiker maakt gebruik van de <firstterm>crontab</firstterm> 
	opdracht om zijn/haar lijst met cron taken te wijzigen. 
	De syntaxis luidt:
  <cmdsynopsis>
    <command>		cron					</command>
    <arg choice="opt">  -u <replaceable>user</replaceable>	</arg>
    <group>
      <arg>		-e					</arg>
      <arg>		-l					</arg>
      <arg>		-r					</arg>
    </group>
  </cmdsynopsis>
  </para>
  <para>
	De verticale balk <literal>|</literal> geeft in onze 
	syntaxis-notatie aan dat <emphasis>of</emphasis> de 
	<option>-e</option> vlag, <emphasis>of</emphasis> 
	<option>-l</option> <emphasis>of</emphasis> 
	<option>-u</option> moeten worden gebruikt: 
	u dient het evenmin als de rechterhaken over te typen. 
	Met de <option>-u</option> optie kan root andermans cron 
	tabel wijzigen; 
	deze optie kan ook handig zijn in combinatie met 
	<firstterm>su</firstterm>. 
	Met de <option>-r</option> optie wordt een cron tabel 
	verwijderd. 
	Met de <option>-e</option> optie wordt de cron tabel 
	gewijzigd; 
	voor dit doel wordt <firstterm>vi</firstterm> opgestart 
	tenzij de inhoud van de omgevingsvariabele 
	<envar>$EDITOR</envar> iets anders vermeldt. 
  </para>
  <para>
	Een cron tabel bestaat uit een aantal regels, die afgezien 
	van blanco of commentaarregels een zestal velden bezitten. 

    <informaltable frame=none>
      <tgroup cols=2>
	<colspec colwidth="1*">
	<colspec colwidth="3*">
	<tbody>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>minuut</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      (0&thinsp;-&thinsp;59)
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>uur</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      (0&thinsp;-&thinsp;23)
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>datum</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      (1&thinsp;-&thinsp;31)
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>maand</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      (1&thinsp;-&thinsp;12)
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>dag</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      (maandag&thinsp;=&thinsp;0, 
		zondag&thinsp;=&thinsp;0 of 7)
	    </entry>
	  </row>
	  <row>
	    <entry><itemizedlist>
	      <listitem>
		<literallayout>opdracht</literallayout>
	      </listitem>
	    </itemizedlist></entry>
	    <entry>
	      (gewone <filename>/bin/sh</filename> commandoregel)
	    </entry>
	  </row>
	</tbody>
      </tgroup>
    </informaltable>
  </para>
  <para>
	De dag van de week <emphasis>of</emphasis> de dag van 
	de maand moeten overeenkomen; 
	het volgende voorbeeld zal op elke vrijdag de 
	13<superscript>e</superscript> tussen elf uur en middernacht 
	elke minuut de inhoud van de <filename>/tmp</filename> 
	directory wissen <emphasis>en</emphasis> op 13 november 
	ongeacht de dag van de week. 
	In de plaats van een getal mogen er meerdere voorkomen 
	met komma's, maar zonder spaties ertussen. 
    <informalexample>
      <programlisting>  
<replaceable># een voorbeeld cron tabel				</replaceable>
* 23 13 11 5 find /tmp -exec rm -f {} 2&gt;/dev/null		</programlisting>
    </informalexample>
  </para>
</sect2>
<sect2 id="basename">
  <title>	 basename en dirname				</title>
  <para>
	Het <firstterm>basename</firstterm> commando verwijdert 
	het directory pad uit een filenaam en eventueel de 
	<firstterm>extensie</firstterm>. De syntaxis luidt:
  <cmdsynopsis>
    <command>		basename				</command>
    <arg choice="plain"><replaceable>padnaam</replaceable>	</arg>
    <arg choice="opt">	<replaceable>extensie</replaceable>	</arg> 
  </cmdsynopsis>
  </para>
  <para>
	Als de filenaam niet eindigt op de extensie dan wordt 
	de hele naam weergegeven en ook als de filenaam gelijk 
	is aan de extensie. 
	Die extensie kan een willekeurige string zijn. 
	Er wordt niet gecontroleerd of de file bestaat. 
	Het volgende voorbeeld geeft de voornaam van alle html-bestanden. 

    <informalexample>
      <programlisting>
for file in `find . print | fgrep .html`
do
  basename $file .html
done								</programlisting>
    </informalexample>
  </para>
  <para>
	Het <firstterm>dirname</firstterm> commando geeft het 
	directory pad van een filenaam. 
	De syntaxis luidt:
  <cmdsynopsis>
    <command>		dirname					</command>
    <arg choice="plain"><replaceable>padnaam</replaceable>	</arg>
  </cmdsynopsis>
  </para>
  <para>
	Als er geen slash (<literal>/</literal>) in de padnaam 
	voorkomt, wordt de huidige directory (<literal>.</literal>) 
	geretourneerd. 
	Het volgende voorbeeld geeft alle directory's die 
	html-bestanden bevatten, met dien verstande dat 
	alleen de naam en niet de inhoud van de file wordt getest. 

    <informalexample>
      <programlisting>
find . -print | fgrep .html | xargs -l1 dirname | uniq -c 	</programlisting>
    </informalexample>
  </para>
</sect2>

<sect2 id="clear">
  <title>	 clear						</title>
  <para>
	Het commando <command>clear</command> wist de inhoud 
	van het scherm en zet de cursor in de linker bovenhoek. 
	De omgevingsvariabele <envar>TERM</envar> bevat het type 
	van uw terminal; 
	als clear niet werkt, kijk of uw terminal wordt ondersteund. 
  </para>
</sect2>

<sect2 id="sort">
  <title>	 sort en uniq					</title>
  <para>
	Met <firstterm>sort</firstterm> kunnen bestanden worden 
	gesorteerd en&thinsp;/&thinsp;of samengevoegd. 
	De sorteervolgorde wordt bepaald door de ingestelde taal 
	en de standaardinstelling is dat de hele regel als 
	sorteersleutel wordt gebruikt. De syntaxis luidt: 

  <cmdsynopsis>
    <command>		sort					</command>
    <arg choice="opt">	-c					</arg>
    <arg choice="opt">	-m					</arg>
    <arg choice="opt">	-u					</arg> 
    <arg choice="opt">	-t<replaceable>teken</replaceable>	</arg>
    <arg choice="opt">	+<replaceable>pos</replaceable>1
      <arg>		-<replaceable>pos</replaceable>2	</arg>
    </arg>							<sbr>
    <arg choice="opt">	-o <replaceable>file</replaceable>	</arg> 
    <arg choice="opt">	-T <replaceable>directory</replaceable>	</arg>
    <arg choice="opt" rep="repeat">	file			</arg>
  </cmdsynopsis>
  </para>
  <para>
	De volgende opties zijn mogelijk:

   <variablelist>
      <varlistentry>
	<term>
	  <option>-c</option> (check)				</term>
	<listitem>
	  <simpara>	alleen controleren of de invoer reeds 
			gesorteerd is 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-m</option> (merge)				</term>
	<listitem>
	  <simpara>	samenvoegen van bestanden die reeds 
			gesorteerd zijn
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-u</option> (unique)				</term>
	<listitem>
	  <simpara>	neem identieke regels slechts 
			&eacute;&eacute;n keer op in de uitvoer 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry> 
	<term>
	  <option>-t</option> (tab)				</term>
	<listitem>
	  <simpara>	het volgende teken wordt gebruikt 
			om velden te scheiden; 
			gebruik een teken dat niet in de invoer 
			voorkomt als u puur op positie wildt 
			sorteren. 
			Standaard worden tabs en spaties gebruikt 
			om velden te scheiden en na een 
			spatie worden volgende spaties als deel 
			van een veld beschouwd.  
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-o</option> (output)				</term>
	<listitem>
	  <simpara>	hiermee wordt aangegeven naar welk bestand 
			de uitvoer wordt geschreven; 
			de uitvoer mag een invoerbestand overschrijven
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-T</option> (temporary)			</term>
	<listitem>
	  <simpara>	hiermee kan de directory voor tijdelijke 
			bestanden worden opgegeven 
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Verder kan worden opgegeven dat de velden vanaf 
	<replaceable>pos</replaceable>1 tot en zonder 
	<replaceable>pos</replaceable>2 de sorteersleutel vormen. 
	Als <replaceable>pos</replaceable>2 ontbreekt dan vormt 
	de hele rest van de regel de zoeksleutel. 
	Er wordt geteld vanaf 0. 
	Regels waarvan de eerste <replaceable>i</replaceable> 
	velden gelijk zijn worden gesorteerd op basis van het 
	<replaceable>i&thinsp;+&thinsp;1<superscript>e</superscript></replaceable> 
	veld. 
	De posities kunnen van de vorm <replaceable>m.n</replaceable> 
	zijn, waarin <replaceable>m</replaceable> het veldnummer is 
	en <replaceable>n</replaceable> de positie binnen het veld. 
	De volgende opties zijn globaal geldig als ze voor 
	<replaceable>pos</replaceable>1 staan, maar als ze achter een 
	positie staan hebben ze betrekking op dat veld. 

    <variablelist>
      <varlistentry>
	<term>
	  <option>-b</option> (blanks)				</term>
	<listitem>
	  <simpara>	negeer voorloopspaties 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-d</option> (check)				</term>
	<listitem>
	  <simpara>	alleen letters, cijfers en spaties zijn
			bepalend voor de volgorde 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-i</option> (ignore)				</term>
	<listitem>
	  <simpara>	negeer tekens die niet tot het 7-bits
			<acronym>ASCII</acronym> alfabet behoren
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-f</option> (fold)				</term>
	<listitem>
	  <simpara>	verander hoofdletters in kleine letters; 
			hoofdletters verschijnen wel gewoon in 
			de uitvoer
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-n</option> (numeric)				</term>
	<listitem>
	  <simpara>	de invoer sorteren op getalswaarde i.p.v. 
			alfabetische volgorde; 
			dit maakt de <option>b</option> optie 
			automatisch aktief. De invoer moet rechts
			aangelijnd zijn, wat met <command>printf</command> 
			kan, zie <xref linkend="printf">.
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-r</option> (reverse)				</term>
	<listitem>
	  <simpara>	sorteer in omgekeerde volgorde	
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Het volgende voorbeeld sorteert het wachtwoordbestand op 
	<firstterm>Group ID</firstterm> en binnen een groep worden 
	de <firstterm>User IDs</firstterm> in omgekeerde volgorde 
	gezet en per UID op het <firstterm><acronym>GCOS</acronym></firstterm>
	alias comment veld, dat vaak de volledige naam van de 
	gebruiker en evt. kamernummer en telefoontoestel bevat. 

    <informalexample>
      <programlisting>
sort -bdft: +3n +2nr -5 /etc/passwd 				</programlisting>
    </informalexample>
  </para>
  <para> 
	Het <firstterm>uniq</firstterm> commando kan in veel 
	gevallen worden weggelaten en <command>`sort -u'</command> 
	worden gebruikt om dubbele regels te verwijderen. 
	De syntaxis luidt:

  <cmdsynopsis>
    <command>		uniq					</command>
      <group>
	<arg>		-u					</arg>
	<arg>		-c					</arg>
	<arg>		-d					</arg>
      </group>
    <arg choice="opt">	-<replaceable>kolommen</replaceable>	</arg>
    <arg choice="opt">	+<replaceable>tekens</replaceable>	</arg>
    <arg choice="opt">	<replaceable>in</replaceable>
      <arg>		<replaceable>uit</replaceable>		</arg>
    </arg>
   </cmdsynopsis>
  </para>
  <para>
	De <option>-u</option> optie zorgt ervoor dat enkel de 
	regels die niet dubbel voorkomen worden afgedrukt, 
	terwijl de <option>-d</option> optie elke vaker voorkomende 
	regel een keer in de uitvoer verschijnt en met 
	<option>-c</option> worden alle regels 
	voorafgegaan door het aantal keren dat ze voorkomen. 
  </para>
  <para>
	Achter het <literal>-</literal> teken komt een eventueel 
	aantal kolommen dat voor de vergelijking wordt overgeslagen; 
	achter het <literal>+</literal> teken komt een aantal 
	tekenposities dat wordt overgeslagen, nadat de voorafgaande 
	kolommen zijn overgeslagen. 
  </para>
  <para>
	Veel commando's geven eerst een titelregel, die we niet mee 
	willen sorteren. 
	In plaats van <firstterm>head</firstterm> (zie 
	<xref linkend="head">) en <firstterm>tail</firstterm>
	te gebruiken kan het ook met het scriptje `knip'. 

    <informalexample>
      <programlisting>
read LINE
echo "$LINE" 1&gt;&2
while read LINE
do
  echo "$LINE"
done								</programlisting>
    </informalexample>
	Dit leidt de eerste regel om naar het standaard error 
	kanaal; 
	na het sorteren kunnen we beide kanalen weer samenvoegen. 
	Het <command>w</command> commando geeft een tabel van ingelogde 
gebruikers met twee titelregels. 
    <informalexample>
      <programlisting>
w | knip | knip | sort -f 2>&1 					</programlisting>
    </informalexample>
  </para>
</sect2>

<sect2 id="diff">
  <title>	 cmp, comm en diff				</title>
  <para>
	Met het <firstterm>cmp</firstterm> commando kunnen twee 
	files worden vergeleken. De syntaxis luidt: 
  <cmdsynopsis>
    <command>		cmp					</command>
      <group>
	<arg>		-l					</arg>
	<arg>		-s					</arg>
      </group>
    <arg choice="plain"><replaceable>file</replaceable>1	</arg>
    <arg choice="plain"><replaceable>file</replaceable>2	</arg>
   </cmdsynopsis>
  </para>
  <para>
	Standaard wordt het nummer en de inhoud van het eerste 
	byte getoond dat verschilt als octaal getal. 
	Met de <option>-s</option> (silent) optie is er geen 
	uitvoer en kan slechts de exit status worden getest, 
	terwijl <option>-l</option> alle bytes die verschillenden 
	weergeeft. 
  </para>
  <para>
	Cmp is geschikt voor binaire files; 
	<firstterm>comm</firstterm> vergelijkt twee bestanden 
	regel voor regel. De bestanden dienen gesorteerd te zijn. 
	De syntaxis luidt: 

  <cmdsynopsis>
    <command>		comm					</command>
    <arg choice="opt">	-1					</arg>
    <arg choice="opt">	-2					</arg>
    <arg choice="opt">	-3					</arg>
    <arg choice="plain"><replaceable>file</replaceable>1	</arg>
    <arg choice="plain"><replaceable>file</replaceable>2	</arg>
   </cmdsynopsis>
  </para>
  <para>
	Zonder vlaggen wordt de uitvoer weergegeven in drie 
	kolommen: 
	in de eerste regels die alleen in file1 voorkomen, in 
	de tweede regels die in file2 voorkomen, en in de derde 
	kolom de gemeenschappelijke regels. 
	De kolommen worden gemarkeerd door de regel met nul, 
	een of twee tab-tekens te beginnen; 
	de uitvoer is niet bijster overzichtelijk. 
	De vlaggen geven de optie een of meerdere kolommen weg 
	te laten, bijv. <command>comm -12 &hellip;</command> 
	om alleen gemeenschappelijke regels te zien. 
  </para>
  <para>
	Het <firstterm>diff</firstterm> commando zoekt naar de 
	verschillen tussen twee bestanden. 
	De syntaxis luidt:
 
  <cmdsynopsis>
    <command>		diff					</command>
    <arg choice="opt">	-b					</arg>
    <arg choice="opt">	-r					</arg>
    <arg choice="opt">	-e					</arg>
    <arg choice="plain"><replaceable>file</replaceable>1	</arg>
    <arg choice="plain"><replaceable>file</replaceable>2	</arg>
   </cmdsynopsis>
  </para>
  <para>
	Met de optie <option>-b</option> worden spaties aan het 
	eind van een regel genegeerd. 
	Met de optie <option>-r</option> worden&mdash;als 
	<replaceable>file</replaceable>1 en 
	<replaceable>file</replaceable>2 directory's zijn&mdash;alle 
	files in die directory's vergeleken. 
	Met de optie <option>-e</option> wordt de uitvoer in de
	vorm van commando's voor de <firstterm>ed</firstterm> 
	editor (grootvader van vi) geschreven. 
  </para>
  <para>
	De uitvoer van diff kan worden gebruikt om met het 
	<firstterm>patch</firstterm> tool 
	<replaceable>file</replaceable>1 te veranderen in 
	<replaceable>file</replaceable>2 of andersom. 
	Als een programmeur aan een groot programma een paar 
	regels heeft veranderd, hoeft hij&thinsp;/&thinsp;zij 
	slechts de patch te verspreiden. 
	De uitvoer van diff heeft de volgende vorm:

<screen>
n1a n3,n4 	<lineannotation>(regels toevoegen) </lineannotation>
n1,n2d n3 	<lineannotation>(regels verwijderen) </lineannotation>
n1,n2c n3,n4	<lineannotation>(regels wijzigen) </lineannotation> </screen> 
  </para>
  <para>
	Achter een edit commando volgt een lijst van de betroffen 
	regels in <replaceable>file</replaceable>1 met telkens een 
	<literal>&lt;</literal> ervoor en een lijst regels uit 
	<replaceable>file</replaceable>2 voorafgegaan door een 
	<literal>&gt;</literal>; 
	bijv. als in de ene file op regel 13 een fiets staat waar 
	de andere een rijwiel heeft: 

<screen>
13c13
< fiets

---

> rijwiel							</screen>
 </para>
</sect2>

<sect2 id="column">
  <title>	 column						</title>
  <para>
	Het column commando (<acronym>BSD</acronym>, Linux) kan 
	tekst in kolommen verdelen om een nette uitvoer te geven. 
	De syntaxis luidt:

  <cmdsynopsis>
    <command>		column					</command>
    <arg choice="opt">	-t					</arg>
    <arg choice="opt">	-x					</arg>
    <arg choice="opt">	-c <replaceable>kolommen</replaceable>	</arg>
    <arg choice="opt">	-s <replaceable>teken</replaceable>	</arg>
    <arg choice="opt" rep="repeat"><replaceable>file</replaceable></arg>
   </cmdsynopsis>
  </para>
  <para>
	De opties zijn:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-c</option> (count)				</term>
	<listitem>
	  <simpara>	hiermee geef je de breedte van het 
			scherm op. 
			In de meeste gevallen is dat niet nodig 
			omdat de omgevingsvariabele 
			<envar>$COLUMNS</envar> de juiste 
			breedte bevat. 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-s</option> (separator)			</term>
	<listitem>
	  <simpara>	geeft het scheidingsteken tussen de 
			kolommen (bijv <literal>:</literal> 
			voor <filename>/etc/passwd</filename>) 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-x</option> (cross)				</term>
	<listitem>
	  <simpara>	vult de uitvoer regel voor regel op in 
			plaats van kolom voor kolom 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-t</option> (table)				</term>
	<listitem>
	  <simpara>	bepaalt het aantal kolommen in de 
			invoertekst in maakt deze netjes op 
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Op de volgende manier kan de uitvoer van 
	<command>find</command> op een 
	ls-achtige manier in kolommen worden gezet. 

    <informalexample>
      <programlisting>
find . -mindepth 1 -print | xargs -l1 basename | \
  sort -u | column 						</programlisting> 
    </informalexample>
  </para>
  <para>
	In het volgende voorbeeld wordt de uitvoer van 
	<command>ls</command> van een titelregel voorzien. 

    <informalexample> 
      <programlisting>
( printf \
  "PERM LINKS OWNER GROUP SIZE MONTH DAY HH:MM/YEAR NAME\n" 
  /bin/ls -l | sed 1d
) | column -t							</programlisting>
    </informalexample>
  </para>
</sect2>

<sect2 id="cut">
  <title>	 colrm, cut, paste, join			</title>
  <para>
	Het <firstterm>colrm</firstterm> commando van 
	<acronym>BSD</acronym> <acronym>Unix</acronym> verwijdert 
	kolommen uit elke regel van de standaard invoer. 
	Met kolommen worden hier tekenposities bedoeld. 
	De syntaxis luidt:

  <cmdsynopsis>
    <command>		colrm					</command>
    <arg choice="opt">	<replaceable>startpositie</replaceable>
      <arg choice="opt"><replaceable>eindpositie</replaceable>	</arg>
    </arg>
   </cmdsynopsis>
  </para>
  <para>
	De posities worden geteld vanaf 1. 
	Als alleen de startpositie wordt opgegeven wordt de 
	rest van de regel verwijderd, anders van start tot en 
	met eind. 
  </para>
  <para>
	System V <acronym>Unix</acronym> kent een <firstterm>cut</firstterm> 
	commando dat ongeveer hetzelfde doet, met de volgende syntaxis:

    <cmdsynopsis>
      <command>		cut					</command>
      <group>
	<arg>		-b					</arg>
	<arg>		-c					</arg>
	<arg>		-f					</arg>
      </group>
      <arg choice="plain"><replaceable>lijst</replaceable>	</arg>
      <arg choice="opt">-d <replaceable>teken</replaceable>	</arg>
      <arg choice="opt" rep="repeat">
			<replaceable>file</replaceable>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	De opties zijn als volgt:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-b</option> (bytes)				</term>
	<listitem>
	  <simpara>	de kolommen worden opgegeven als 
			byte-posities
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-c</option> (character)			</term>
	<listitem>
	  <simpara>	de kolommen worden aangegeven als tekenposities; 
			in Oostaziatische en Unicode alfabetten 
			kan een teken meer dan een byte lang zijn
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-f</option> (field)				</term>
	<listitem>
	  <simpara>	de kolommen zijn velden gescheiden door
			tabulatie-tekens
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-d</option> (delimiter)			</term>
	<listitem>
	  <simpara>	geeft een alternatief scheidingsteken aan; 
			alleen toegestaan in combinatie met de 
			<option>-f</option> optie  
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Achter de <option>-b</option>, <option>-c</option> of 
	<option>-f</option> optie volgt een lijst met veldnummers 
	die in de uitvoer moeten worden meegenomen. 
	Dit kan een reeks nummers zijn, gescheiden door komma's 
	zonder spaties ertussen. 
	Voor een enkel getal kan ook een bereik 
	<replaceable>start-eind</replaceable> staan, waarbij de 
	start of het eind ook mogen worden weggelaten om de rest 
	van de regel aan te duiden. 
	Zo doen de volgende twee regels hetzelfde 

    <informalexample>
      <programlisting>
ls -al | colrm 42 54   
ls -al | cut -b -41,55-						</programlisting>
    </informalexample>
  </para>
  <para>
	De volgende opdrachten doen niet hetzelfde, omdat de uitvoer 
	van <command>ls</command> niet door tabulatie-tekens 
	gescheiden is, maar door rijen spaties. 

    <informalexample>
      <programlisting>
ls -al | awk '{ print $9}' 
ls -al | cut -f 9 -d ' ' 					</programlisting>
    </informalexample
  </para>
  <para>
Om het effekt van de awk regel te bereiken doe je 

    <informalexample>
      <programlisting>
ls -al | sed -e 's/[ ][ ]*/ /g' | cut -f 9 -d ' ' 		</programlisting>
    </informalexample>
  </para>
  <para>
	Op de volgende manier kun je een directory listing 
	sorteren op extensie, waarbij functies uit een voorbeeld 
	in <xref linkend="sed"> worden gebruikt. 
	Voor bash is de optie <option>-e</option> vereist. 

    <informalexample>
      <programlisting>
<replaceable># optioneel argument: directory naam</replaceable> 

  ls $1 | while read
  	  do
	    echo -e "`extension "$REPLY"`""\t""$REPLY"
	  done | sort -df | cut -f 2 				</programlisting>
    </informalexample>
  </para>
  <para>
	Het omgekeerde van cut is <firstterm>paste</firstterm>. 
	Hiermee worden regels uit meerdere files samengevoegd tot 
	een regel, gescheiden door tabs. 
	Paste is wat beperkter dan het join commando. 
	De syntaxis luidt: 

    <cmdsynopsis>
      <command>		paste					</command>
      <arg>
	<arg>		-s					</arg>
      			-d <replaceable>lijst</replaceable>
      </arg>
      <arg choice="plain" rep="repeat">
			<replaceable>file</replaceable>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	De opties zijn als volgt:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-d</option>	(delimiter)			</term>
	<listitem>
	  <simpara>	gebruik een element uit de lijst als 
			veld-scheidingstekens; 
			er wordt telkens een volgend teken uit 
			de lijst gebruikt, om aan het eind weer 
			het eerste te nemen
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-s</option>	(serial)			</term>
	<listitem>
	  <simpara>	geeft een alternatief scheidingsteken aan; 
			alleen toegestaan in combinatie met de 
			optie <option>-f</option>  
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Het volgende voorbeeld geeft een lijst bestanden in 
	drie kolommen. 
  
    <informalexample>
      <programlisting>
ls | paste - - - | column -t 					</programlisting>
    </informalexample>
  </para>
  <para>
	Met <firstterm>join</firstterm> worden twee tekstbestanden 
	samengevoegd, die vooraf gesorteerd moeten zijn. 
	Join voegt regels uit beide bestanden samen met dezelfde 
	inhoud van het <firstterm>sleutelveld</firstterm>. 
	Het sleutelveld is standaard het eerste veld; 
	velden worden gescheiden door spaties of tabulatie-tekens. 
	Join is een standaard operatie voor databases. 
  </para>
  <para>
	De uitvoer bevat alle velden van beide bestanden, en het 
	sleutelveld wordt maar &eacute;&eacute;n keer gekopieerd. 
	Als een sleutelveld in de eerste file <replaceable>n</replaceable> 
	keer voorkomt en <replaceable>m</replaceable> keer in de 
	tweede, dan zal de uitvoer <replaceable>n &times; 
	m</replaceable> regels met deze waarde bevatten. 
	De syntaxis luidt: 

    <cmdsynopsis>
      <command>		join					</command>
      <group>
	<arg>	-a <replaceable>filenr</replaceable>		</arg>
	<arg>	-v <replaceable>filenr</replaceable>		</arg>
      </group>
      <arg choice="opt">-e <replaceable>string</replaceable>	</arg>
      <arg choice="opt">-o <replaceable>lijst</replaceable>	</arg>
      <arg choice="opt">-t <replaceable>teken</replaceable>	</arg>
      <sbr>
      <group>
	<arg>	-j<arg><replaceable>filenr</replaceable></arg> 
		<replaceable>veldnr</replaceable></arg>
	<arg>	-1 <replaceable>veldnr</replaceable>
		-2 <replaceable>veldnr</replaceable>		</arg>
      </group>
      <arg choice="plain"><replaceable>file</replaceable>1	</arg>
      <arg choice="plain"><replaceable>file</replaceable>2	</arg> 
    </cmdsynopsis>
  </para>
  <para>
	Join bezit een aantal opties:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-a</option>	(all)				</term>
	<listitem>
	  <simpara>	produceer ook een regel in de uitvoer 
			voor iedere regel in 
			<replaceable>filenr</replaceable> die geen 
			corresponderende regel in het andere 
			bestand heeft; 
			<replaceable>filenr</replaceable> is een 
			<literal>1</literal> of <literal>2</literal> 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-e</option>	(empty)				</term>
	<listitem>
	  <simpara>	vul lege velden met de opgegeven string 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-j</option>	(join)				</term>
	<listitem>
	  <simpara>	geef het nummer op van het veld, 
			dat als sleutelveld moet worden 
			gebruikt; 
			<replaceable>filenr</replaceable> is een 
			<literal>1</literal> of <literal>2</literal> 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-1, -2</option>				</term>
	<listitem>
	  <simpara>	<option>-1</option> is een synomiem 
			voor <option>-j1</option> en 
			<option>-2</option> voor 
			<option>-j2</option>
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-o</option>	(output)			</term>
	<listitem>
	  <simpara>	geeft een lijst van velden die 
			in de uitvoer moeten komen, wat 
			een cut bespaart; 
			een veld wordt aangeduid met 
			<replaceable>filenr.veldnr</replaceable> 
			en velden worden gescheiden door komma's
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-t</option>	(tab)				</term>
	<listitem>
	  <simpara>	geeft aan welk teken wordt gebruikt 
			om de velden te scheiden 
			(helaas is <acronym>Unix</acronym> 
			niet erg consequent in de naamgeving 
			van de opties) 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-v</option>					</term>
	<listitem>
	  <simpara>	produceer uitsluitend een regel 
			in de uitvoer voor iedere regel 
			in <replaceable>filenr</replaceable> 
			die geen corresponderende regel 
			in het andere bestand heeft;
			<replaceable>filenr</replaceable> is een 
			<literal>1</literal> of <literal>2</literal> 
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Met behulp van join maken we een korte variant op het 
	voorbeeld van <xref linkend="voorbeelden">.

    <informalexample>
      <programlisting>
<replaceable># sorteer de wachtwoord file op login naam		</replaceable>
sort &lt;/etc/passwd &gt;een
<replaceable># knip de titelregels uit lijst van gebruikers, 
	# scheid de velden door dubbele punt en sorteer 	</replaceable>
w | ( read; read; cat) | sed -e 's/[ ][ ]*/:/g' \
| sort &gt;twee
<replaceable># voeg de bestanden samen en maak er nette tabel van</replaceable>
(echo "USER:FULL NAME:TTY"; join een twee -t ':' \
  -o 1.1,1.5,2.2 ) | column -t -s ':'; rm -f een twee		</programlisting>
    </informalexample>
  </para>
</sect2

<sect2 id="head">
  <title>	 head en tail					</title>
  <para>
	Na een aantal opdrachten die velden uit bestanden 
	manipuleren, zijn er nog een paar die regels uit tekst 
	filteren. 
	Naast grep hebben we <firstterm>head</firstterm> en 
	<firstterm>tail</firstterm> die respectievelijk de eerste 
	en de laatste paar regels van een bestand laten zien; 
	standaard zijn dat tien (10) regels. 
	De syntaxis luidt: 

    <cmdsynopsis>
      <command>		head					</command>
      <group>
	<arg>		-<replaceable>aantal</replaceable>	</arg>
	<arg>		-n <replaceable>aantal</replaceable>	</arg>
      </group>
      <arg choice="opt" rep="repeat">
		<replaceable>file</replaceable>	
      </arg>
      <sbr>
      <command>		tail					</command>
      <arg choice="opt">
	<group>
	  <arg>		+					</arg>
	  <arg>		-					</arg>
	</group>
			<replaceable>aantal</replaceable><group>
	  <arg>		l					</arg>
	  <arg>		b					</arg>
	  <arg>		c					</arg>
	</group>
      </arg>
      <arg choice="opt">-f					</arg>
      <arg choice="opt">-r					</arg>
      <arg choice="opt"><replaceable>file</replaceable>		</arg>
      <sbr>
      <command>		tail					</command>
      <group>
      	<arg>		-c <replaceable>aantal</replaceable>	</arg>
	<arg>		-n <replaceable>aantal</replaceable>	</arg>
      </group>
      <arg choice="opt"><replaceable>file</replaceable>		</arg>
    </cmdsynopsis>
  </para>
  <para>
	De opties zijn als volgt:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-n</option>	(number)			</term>
	<listitem>
	  <simpara>	het aantal regels dat wordt weergegeven;
			dit is hetzelfde als de optie 
			<option>-aantal</option>
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>+<replaceable>aantal</replaceable>[l|b|c]</option></term>
	<listitem>
	  <simpara>	alleen voor tail; 
			er wordt nu vanaf het begin van de file 
			geteld in plaats vanaf het eind: 
			dit is hetzelfde als 
			<option>-n +<replaceable>aantal</replaceable></option>, 
			terwijl 
			<option>-n -<replaceable>aantal</replaceable></option> 
			equivalent is met 
			<option>-n <replaceable>aantal</replaceable></option> 
			en head geen teken voor het aantal krijgt
	</simpara>
	<simpara>	de optionele <option>l</option> achter 
			het aantal betekent dat er regels geteld 
			worden; 
			als er <option>c</option> staat worden 
			bytes geteld en een <option>b</option> 
			staat voor disk blokken van 512 bytes 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-c</option>	(character)			</term>
	<listitem>
	  <simpara>	Een alternatieve notatie voor 
			<option>+&thinsp;/&thinsp;-<replaceable>aantal</replaceable>c</option>
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-r</option>	(reverse)			</term>
	<listitem>
	  <simpara>	de regels worden in omgekeerde volgorde 
			afgedrukt; 
			alleen voor <acronym>BSD</acronym> 
			<acronym>Unix</acronym>
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-f</option>	(follow)			</term>
	<listitem>
	  <simpara>	laat het programma niet be&euml;indigen 
			als het eind van het bestand is bereikt, 
			maar kijkt om de zoveel seconden of de 
			file is gegroeid en drukt nieuwe regels
			af; 
			handig voor log files. 
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	De <acronym>GNU</acronym> versie van head kent een 
	aantal van de opties van tail. 
	Het eerste voorbeeld geeft alleen de namen van de bestanden; 
	het tweede is equivalent met 
	<command>(read; read; cat)</command>. 

    <informalexample>
      <programlisting>
head -0 * 
tail -n +3l							</programlisting>
    </informalexample>
  </para>
</sect2

<sect2 id="split">
  <title>	 split en dd					</title>
  <para>
	Een heel andere manier om een bestand in regels 
	te splitsen is <firstterm>split</firstterm>, dat meerdere 
	output files aanmaakt van gelijke lengte. 
	De syntaxis luidt:

    <cmdsynopsis>
      <command>		split					</command>
      <group>
	  <arg>		-<arg choice="opt">l</arg><replaceable>aantal</replaceable>	</arg>
	  <arg>		<arg choice="opt">-b</arg><replaceable>aantal</replaceable><group><arg>k</arg><arg>m</arg></group></arg>
      </group>
      <arg choice="opt"><replaceable>file</replaceable>
	<arg choice="opt"><replaceable>prefix</replaceable>	</arg>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	De namen van de output files beginnen met de opgegeven prefix. 
	Zonder prefix heten ze <filename>xaa, xab, &hellip;</filename> 
	De opties zijn: 

    <variablelist>
      <varlistentry>
	<term>
	  <option>-l</option>	(lines)				</term>
	<listitem>
	  <simpara>	geeft het aantal regels per 
			uitvoer file; 
			de letter <option>l</option> mag 
			worden weggelaten; 
			standaard worden files van 1000 
			regels gemaakt
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-b</option>	(bytes)				</term>
	<listitem>
	  <simpara>	maakt files met het opgegeven 
			aantal bytes; 
			als er <option>k</option> achter staat, 
			worden het kilobytes en met 
			<option>m</option> megabytes: 
			handig als de uitvoer een vaste grootte 
			moet hebben voor bijvoorbeeld floppy disks.  
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Een gesplitste file kan worden samengevoegd met 
	<command>cat x* &gt;<replaceable>file</replaceable></command>.
  </para>
  <para>
	De functie van <firstterm>dd</firstterm> wordt omschreven 
	als `convert and copy', maar omdat cc al bestond, is 
	voor `disk dumper' gekozen. 
	Het wordt vooral gebruikt voor direkte in- en uitvoer naar 
	een fysiek randapparaat, omdat het niet regels maar records 
	met vaste lengte kopieert. 
	De syntaxis luidt:

    <cmdsynopsis>
      <command>		dd					</command>
      <arg choice="opt" rep="repeat">
			<replaceable>optie</replaceable>=<replaceable>waarde</replaceable></arg>
    </cmdsynopsis>
  </para>
  <para>
	Zonder verdere argumenten lijkt het op cat, maar dd kent 
	een respektabele lijst opties: 

    <variablelist>
      <varlistentry>
	<term>
	  <option>if=<replaceable>file</replaceable></option>	</term>
	<listitem>
	  <simpara>	lees van de opgegeven file c.q. randapparaat
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>of=<replaceable>file</replaceable></option>	</term>
	<listitem>
	  <simpara>	schrijf naar de opgegeven file c.q. randapparaat 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>ibs=<replaceable>bytes</replaceable>[w|b|k]</option></term>
	<listitem>
	  <simpara>	geeft het aantal bytes dat in 
			&eacute;&eacute;n keer gelezen wordt 
			(record grootte) op,
			standaard 512 bytes;
			als achtervoegsel kan de eenheid worden 
			opgegeven: 
			een woord is twee bytes, een disk-blok 
			512 bytes, een kilobyte 1024 bytes 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>obs=<replaceable>bytes</replaceable>[w|b|k]</option></term>
	<listitem>
	  <simpara>	geeft het aantal bytes dat in 
			&eacute;&eacute;n keer weggeschreven 
			wordt (record grootte) op
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>bs=<replaceable>bytes</replaceable>[w|b|k]</option></term>
	<listitem>
	  <simpara>	geeft het aantal bytes dat in 
			&eacute;&eacute;n keer gelezen en 
			geschreven wordt; 
			<option>ibs</option> en <option>obs</option>
			worden genegeerd als <option>bs</option>
			is opgegeven 			
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>cbs=<replaceable>bytes</replaceable></option></term>
	<listitem>
	  <simpara>	geeft de grootte van de conversie-buffer aan
			voor conversie naar of van <acronym>IBM</acronym>
			of <acronym>EBCDIC</acronym> formaat
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>skip=<replaceable>records</replaceable></option></term>
	<listitem>
	  <simpara>	geeft het aantal records dat van de invoer 
			wordt gelezen maar niet naar de uitvoer
			wordt geschreven
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>seek=<replaceable>records</replaceable></option></term>
	<listitem>
	  <simpara>	geeft het aantal records in de uitvoerfile
			dat wordt overgeslagen voordat dd begint
			met kopi&euml;ren
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>iseek=<replaceable>records</replaceable></option></term>
	<listitem>
	  <simpara>	net als <option>skip</option>, maar dd
			springt over de records heen, wat tijd
			bespaart
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>oseek=<replaceable>records</replaceable></option></term>
	<listitem>
	  <simpara>	net als seek
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>count=<replaceable>aantal</replaceable></option></term>
	<listitem>
	  <simpara>	kopieert slechts een 
			<option><replaceable>aantal</replaceable></option>
			records
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>files=<replaceable>aantal</replaceable></option></term>
	<listitem>
	  <simpara>	voegt een aantal bestanden met <token>EOF</token>
			ertussen samen;
			alleen handig voor tape 
	</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>conv=<replaceable>code</replaceable>,&hellip;</option></term>
	<listitem>
	  <informaltable frame=none>
	    <tgroup cols=2>
	    <colspec colwidth="1*">
	    <colspec colwidth="4*">
	    <tbody>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>ascii</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	converteer van <acronym>EBCDIC</acronym>
			naar <acronym>ASCII</acronym> 
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>ebcdic</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	converteer van <acronym>ASCII</acronym>
			naar <acronym>EBCDIC</acronym> 
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>ibm</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	converteer van <acronym>IBM</acronym>
			<acronym>EBCDIC</acronym>
			naar <acronym>ASCII</acronym> 
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>block</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	converteer tekstbestand met regels van 
			variabele lengte naar records van 
			<option>cbs</option> bytes door regels 
			aan te vullen met spaties
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>unblock</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	haal spaties aan het eind weg en sluit regel 
			af met <token>newline</token>
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>lcase</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	vervang hoofdletters door kleine letters
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>ucase</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	vervang kleine letters door hoofdletters
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>swab</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	verwissel even en oneven bytes
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>sync</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	als het invoer record kleiner is dan 
			<option>ibs</option>, dan wordt het
			aangevuld met <token>NULL</token> bytes
			of&mdash;als de optie <option>block</option>
			gekozen is&mdash;bytes
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>noerror</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	ga door als er een fout optreedt
		</entry>
	      </row>
	      <row>
		<entry><itemizedlist>
		  <listitem>
		    <literallayout>notrunc</literallayout>
		  </listitem>
		</itemizedlist></entry>
		<entry>	maak het uitvoer bestand niet leeg
			alvorens ernaar te schrijven 
		</entry>
	      </row>
	    </tbody>
	    </tgroup>
	  </informaltable>
	</listitem>
      </varlistentry>  
    </variablelist>
  </para>
  <para>
	De <acronym>GNU</acronym> versie kent de opties
	<option>files=</option>, <option>iseek=</option> en 
	<option>oseek=</option> niet. 
	Het volgende voorbeeld misbruikt dd voor string manipulatie. 

    <informalexample>
      <programlisting>
echo "Hello, world" | dd bs=1 skip=7 count=6 2&gt;&thinsp;&gt;/dev/null </programlisting>
    </informalexample>
  </para>
</sect2

<sect2 id="env">
  <title>	 env						</title>
  <para>
	Het commando <firstterm>env</firstterm> is een aanvulling 
	op <firstterm>set</firstterm>, waarmee een 
	omgevingsvariabele kan worden ingesteld voor de duur van 
	&eacute;&eacute;n commando. 
	De syntaxis luidt: 

   <cmdsynopsis>
      <command>		env					</command>
      <group>
	<arg>		-					</arg>
	<arg>		-i					</arg>
      </group>
      <arg choice="opt" rep="repeat">
			<replaceable>naam</replaceable>=<replaceable>waarde</replaceable></arg>
      <arg choice="opt"><replaceable>programma</replaceable>
	<arg choice="opt"><replaceable>argumenten</replaceable>	</arg>
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	Env start het programma, dat de opgegeven namen met de 
	bijbehorende waarden als omgevingsvariabelen meekrijgt. 
	Met de optie <option>-</option> alias <option>-i</option> 
	worden de bestaande omgevingsvariabelen ontzichtbaar voor 
	het programma. 
  </para>
  <para>
	Env zonder argumenten geeft de waarde van alle 
	omgevingsvariabelen, net als het commando 
	<firstterm>printenv</firstterm> 
	(zie <xref linkend="printenv">). 
  </para>
</sect2

<sect2 id="expand">
  <title>	 expand, unexpand en tabs			</title>
  <para>
	Expand is een hulpmiddel om tabulatie-tekens in een 
	tekstbestand te vervangen door spaties met behoud van 
	paginaindeling.
	Programmeurs gebruiken het bijvoorbeeld als een 
	printer tabs niet goed verwerkt. 
	Unexpand vervangt reeksen spaties door tab-tekens, wat 
	ruimte bespaart. 
	De syntaxis luidt 

    <cmdsynopsis>
      <command>		expand					</command>
      <arg choice="opt">	-<arg choice="opt">t</arg><replaceable>tabstops</replaceable></arg>
      <arg choice="opt" rep="repeat">
			<replaceable>file</replaceable>		</arg>
      <sbr>
      <command>		unexpand				</command>
      <arg choice="opt">
	<group choice="plain">
	<arg choice="plain">
			-a					</arg>
	<arg choice="plain">
			-t					</arg>
	</group>
			<replaceable>tabstops</replaceable>	
      </arg>
      <arg choice="opt" rep="repeat">
			<replaceable>file</replaceable>		</arg>
    </cmdsynopsis>
  </para>
  <para>
	Posities worden geteld vanaf 1. 
	Standaard wordt een tabstop om de 8 posities aangenomen. 
	Met de optie <option>-t</option> kan een andere waarde 
	worden opgegeven. 
	Het is ook mogelijk om de lijst van tabstops expliciet 
	op te geven, gescheiden door komma's, als ze op ongelijke 
	afstanden voorkomen. 
	Unexpand vervangt alleen de spaties totaan het eerste 
	afdrukbare teken, of alles als de optie <option>-a</option> 
	is gespecificeerd. 
  </para>
  <para>
	In <firstterm>vi</firstterm> kun je de tabstops zetten 
	met <command>:set ts=n</command>; 
	gerelateerde instellingen zijn <command>:set ai</command> 
	(automatisch inspringen) en 
	<command>:set sw=<replaceable>m</replaceable></command> 
	(inspringdiepte). 
	Om de tab-instellingen te wijzigen op terminals die dit 
	ondersteunen wordt het commando <firstterm>tabs</firstterm>  
	gebruikt, met de syntaxis: 

    <cmdsynopsis>
      <command>		tabs					</command>
      <group>
	<arg>		-<replaceable>code</replaceable>	</arg>
	<arg>		-<replaceable>n</replaceable>		</arg>
	<arg rep="repeat"><replaceable>n</replaceable>1,&hellip;</arg>
      </group>
      <arg choice="opt">-T<replaceable>term</replaceable>	</arg>
      <arg choice="opt">+m<replaceable>n</replaceable>		</arg>
      <sbr>
      <command>		tabs					</command>
      <arg choice="opt">-T<replaceable>term</replaceable>	</arg>
      <arg choice="opt">+m<arg><replaceable>n</replaceable></arg></arg>
      <arg choice="plain"><replaceable>n</replaceable>1</arg><arg choice="opt" rep="repeat">,<replaceable>n</replaceable>2</arg>
    </cmdsynopsis>
  </para>
  <para>
	De opties zijn als volgt:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-T</option>	(terminal)			</term>
	<listitem>
	  <simpara>	geef het terminaltype op, als 
			<acronym>Unix</acronym> dat niet in de 
			omgevingsvariabele <envar>TERM</envar> 
			vindt
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>+m</option>	(margin)			</term>
	<listitem>
	  <simpara>	geef de linker marge op; 
			in de tweede notatie mag <option>m</option> 
			zonder getal gebruikt worden voor de 
			standaardwaarde van 10
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-<replaceable>n</replaceable></option>	</term>
	<listitem>
	  <simpara>	geef een repeterende tabstop op. 
			In de tweede vorm wordt de 
			<option>-</option> weggelaten 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option><replaceable>n</replaceable>1,&hellip;</option></term>
	<listitem>
	  <simpara>	geef de lijst van tabstops expliciet op
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option><replaceable>code</replaceable></option>	</term>
	<listitem>
	  <simpara>	een aantal sets tabstops zijn 
			voorgedefinieerd, 
			bijv. <option>-a</option> voor S/370 
			assembler, <option>-c</option> voor Cobol, 
			<option>-f</option> voor Fortran, etc. 
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="file">
  <title>	 file						</title>
  <para>
	Het commando <firstterm>file</firstterm> onderzoekt het 
	begin van een file en probeert daaruit af te leiden wat 
	voor type bestand het is. 
	Dit is iets betrouwbaarder dan op de extensie van de 
	filenaam af te gaan, maar het blijft gissen. 
	Als uw systeem een bepaald soort document niet herkent, 
	kunt u zelf patronen toevoegen aan 
	<filename>/etc/magic</filename>. 
	De syntaxis luidt:

    <cmdsynopsis>
      <command>		file					</command>
      <arg>		-c					</arg>
      <arg>		-f <replaceable>ffile</replaceable>	</arg>
      <arg>		-m <replaceable>mfile</replaceable>	</arg>
      <arg rep="repeat"><replaceable>file</replaceable>		</arg>
    </cmdsynopsis>
  </para>
  <para>
	De opties zijn als volgt:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-c</option>	(check)				</term>
	<listitem>
	  <simpara>	controleer het formaat van de magic file
	  </simpara>
	</listitem>
     </varlistentry>
     <varlistentry>
	<term>
	  <option>-f</option>	(files)				</term>
	<listitem>
	  <simpara>	onderzoek de files waarvan de 
			namen in 
			<option><replaceable>ffile</replaceable></option> 
			staan
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-m</option>	(magic)				</term>
	<listitem>
	  <simpara>	lees de zoekpatronen uit 
			<option><replaceable>mfile</replaceable</option>
			in plaats van de standaard locatie
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="fold">
  <title>	 fold en fmt					</title>
  <para>
		Fold breekt lange tekstregels af, zodat de rest 
	op de volgende regel terechtkomt. 
	De syntaxis luidt:

    <cmdsynopsis>
      <command>		fold					</command>
      <arg choice="opt">-bs					</arg>
      <arg choice="opt">-w <replaceable>lengte</replaceable>	</arg>
      <arg rep="repeat"><replaceable>file</replaceable>		</arg>
    </cmdsynopsis>
  </para>
  <para>
	De volgende opties worden herkend:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-b</option>	(backspace)			</term>
	<listitem>
	  <simpara>	de speciale behandeling van 
			<token>backspace</token>, 
			<token>tab</token> en 
			<token>carriage return</token> wordt 
			opgeheven, zodat ze als gewone tekens 
			met breedte 1 tellen
	</simpara>
	</listitem>
      </varlistentry>
     <varlistentry>
	<term>
	  <option>-s</option>	(spaces)			</term>
	<listitem>
	  <simpara>	breek de regel af na een spatie in plaats 
			van midden in een woord
	</simpara>
	</listitem>
      </varlistentry>
     <varlistentry>
	<term>
	  <option>-w</option>	(width)				</term>
	<listitem>
	  <simpara>	hanteer de opgegeven regellengte in plaats 
			van de standaardwaarde 80
	</simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para> 
	Fmt is een simpel programma uit <acronym>BSD</acronym> 
	<acronym>Unix</acronym> om een tekstbestand wat netter 
	op te maken met een standaard regellengte van 72 (75 
	voor <acronym>GNU</acronym>). 
	Blanco en ingesprongen regels blijven behouden. 
	Het programma <firstterm>pr</firstterm> is gemaakt om 
	tekst in kolommen te zetten met kop- en voetregels voor 
	het afdrukken. 
	Voor C code is er <firstterm>indent</firstterm>, dat de 
	lay-out van een programma helemaal kan omgooien. 
	De syntaxis luidt: 

    <cmdsynopsis>
      <command>		fmt					</command>
      <arg choice="opt">-<replaceable>opties</replaceable>	</arg>
      <arg rep="repeat"><replaceable>file</replaceable>		</arg>
    </cmdsynopsis>
  </para>
  <para>
	De oude <acronym>BSD</acronym> versie kent geen opties; 
	de <acronym>GNU</acronym> versie heeft o.a.: 

   <variablelist>
      <varlistentry>
	<term>
	  <option>-c</option>	(crown-margin)			</term>
	<listitem>
	  <simpara>	de inspringing van de eerste twee regels
			van elke alinea blijft bewaard en de
			rest springt evenveel in als de tweede regel; 
			bedoeld voor wie alinea's begint met in 
			te springen
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-t</option>	(tagged)			</term>
	<listitem>
	  <simpara>	als de optie <option>-c</option>, maar 
			de eerste twee regels moeten verschillend 
			inspringen
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-u</option>	(uniform)			</term>
	<listitem>
	  <simpara>	vervangt meervoudige spaties door een 
			enkele, behalve aan het eind van een 
			regel, waar een enkele spatie blijft 
			staan, maar meerdere spaties door twee  
			worden vervangen
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-w=<replaceable>lengte</replaceable></option>	(width)</term>
	<listitem>
	  <simpara>	geeft de regellengte op
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="install">
  <title>	install						</title>
  <para>
	Het commando <firstterm>install</firstterm> commando 
	wordt het meest gebruikt in <firstterm>make</firstterm> 
	files om bestanden naar hun bestemming te kopi&euml;ren. 
	De vergelijking van de man pages laat zien dat de System 
	V en <acronym>GNU</acronym> uitvoeringen sterk verschillen. 
	De syntaxis luidt ongeveer:

    <cmdsynopsis>
      <command>		install					</command>
      <arg choice="opt">-f					</arg>
      <arg choice="opt">-m <replaceable>mode</replaceable>	</arg>
      <arg choice="opt">-u <replaceable>user</replaceable>	</arg>
      <arg choice="opt">-g <replaceable>groep</replaceable>	</arg>
      <arg choice="plain"><replaceable>file</replaceable>	</arg>
      <arg choice="plain"><replaceable>directory</replaceable>	</arg>
    </cmdsynopsis>
  </para>
  <para>
	Enkele van de opties:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-f</option>	(force)				</term>
	<listitem>
	  <simpara>	overschrijf een eventueel bestaand bestand 
			in de doeldirectory
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-m</option>	(mode)				</term>
	<listitem>
	  <simpara>	de toegangsrechten van de kopie worden 
			ingesteld op de opgegeven 
			<firstterm>mode</firstterm>, die zowel 
			als octaal getal als in symbolische vorm 
			kan worden opgegeven (voor meer info:
			<command>man chmod</command>)
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-u</option>	(user)				</term>
	<term>
	  <option>-o</option>	(owner)				</term>
	<listitem>
	  <simpara>	stelt de eigenaar van de kopie in: 
			dit mag een naam of nummer uit 
			<filename>/etc/passwd</filename> zijn; 
			install wordt doorgaans door 
			<foreignphrase>root</foreignphrase> uitgevoerd 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-g</option>	(groep)				</term>
	<listitem>
	  <simpara>	geeft de groep op die de kopie zal bezitten
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="look">
  <title>	 look						</title>
  <para>
	<firstterm>Look</firstterm> print alle regels in een 
	gesorteerd tekstbestand die met de opgegeven string 
	beginnen. 
	Het maakt gebruik van een binair zoekalgorithme, waardoor 
	het veel sneller is dan fgrep, maar ook beperkter in zijn 
	functionaliteit. 
	De syntaxis luidt: 

    <cmdsynopsis>
      <command>		look					</command>
      <arg choice="opt">-d					</arg>
      <arg choice="opt">-f					</arg>
      <arg choice="plain"><replaceable>string</replaceable>	</arg>
      <arg choice="opt"><replaceable>file</replaceable>		</arg>
    </cmdsynopsis>
  </para>
  <para>
	Tenzij een bestand is opgegeven, kijkt look in het 
	standaardwoordenboek, bijv. 
	<filename>/usr/dict/words</filename> of
	<filename>/usr/share/dict/words</filename>. 
	Enkele opties zijn:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-d</option>	(dictionary)			</term>
	<listitem>
	  <simpara>	houdt lexigrafische volgorde aan en 
			vergelijkt enkel letters, cijfers en 
			witruimte
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-f</option>	(fold)				</term>
	<listitem>
	  <simpara>	maakt geen onderscheid tussen hoofd- en 
			kleine letter
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="mail">
  <title>	 mail						</title>
  <para>
	<firstterm>Mail</firstterm> is het standaard interactieve 
	e-mail programma voor <acronym>Unix</acronym> gebruikers. 
	Er zijn inmiddels e-mail clients met heel wat meer features, 
	maar mail kan gebruikt worden om berichten te versturen 
	vanuit een programma. 
	De sterk vereenvoudigde syntaxis luidt: 

    <cmdsynopsis>
      <command>		mail					</command>
      <arg choice="opt">-s <replaceable>onderwerp</replaceable>	</arg>
      <arg rep="repeat"><replaceable>adres</replaceable>	</arg>
    </cmdsynopsis>
  </para>
  <para>
	Als het adres ontbreekt, dan wordt mail gebruikt om 
	interactief te binnengekomen post te lezen en eventueel 
	te wissen; 
	met een adres zal mail een bericht van de standaard 
	invoer lezen en versturen met de eventuele onderwerp-regel 
	(graag tussen aanhalingstekens als er spaties in voorkomen). 
	Als er meerdere ontvangers zijn, moeten de adressen 
	met komma's worden gescheiden. 
  </para>
</sect2>

<sect2 id="mesg">
  <title>	 mesg						</title>
  <para>
	<firstterm>Mesg</firstterm> wordt meestal in 
	<filename>~/.profile</filename> (zie <xref linkend="hallo">) 
	gebruikt om het ontvangen van berichten op de terminal 
	met <firstterm>talk</firstterm> of 
	<firstterm>write</firstterm> toe te staan of te blokkeren. 
	De syntaxis luidt: 
  
   <cmdsynopsis>
      <command>		mesg					</command>
      <group>
	<arg>		n					</arg>
	<arg>		y					</arg>
      </group>
    </cmdsynopsis>
  </para>
  <para>
	Met <option>y</option> worden berichten aan u doorgegeven, 
	met <option>n</option> niet. 
	Zonder argument geeft mesg de momentane instelling. 
	De volgende listing laat zien dat er van twee ingelogde 
	gebruikers een mesg aan heeft staan en de ander uit. 
    <screen>
crw-rw-rw- 1 root  root  3, 0 Jun  5 19:29 /dev/ttyp0
crw--w---- 1 daniel tty  3, 1 Jun  5 19:26 /dev/ttyp1
crw------- 1 radical tty 3, 2 Jun  5 19:31 /dev/ttyp2
crw-rw-rw- 1 root   root 3, 3 May 18 00:44 /dev/ttyp3		</screen>
  </para>
</sect2>

<sect2 id="od">
  <title>	 od en strings					</title>
  <para>
	<firstterm>Od</firstterm> wordt gebruikt om de inhoud van 
	binaire files in octaal of andere formaten weer te geven. 
	De vereenvoudigde syntaxis luidt: 

    <cmdsynopsis>
      <command>		od					</command>
      <arg choice="opt">-		
	<arg>		b					</arg>
	<arg>		c					</arg>
	<arg>		d					</arg>
	<arg>		h					</arg>
	<arg>		o					</arg>
	<arg>		x					</arg>
      </arg>
      <arg choice="opt">-A <replaceable>radix</replaceable>	</arg>
      <arg choice="opt">-j <replaceable>bytes</replaceable>	</arg>
      <arg choice="opt">-N <replaceable>bytes</replaceable>	</arg>
      <arg choice="plain">\					</arg><sbr>
      <arg choice="opt">-t <replaceable>formaat</replaceable>	</arg>
      <arg choice="opt"><replaceable>file</replaceable>		</arg>
    </cmdsynopsis>
  </para>
  <para>
	Er zijn onder andere de volgende opties: 

    <variablelist>
      <varlistentry>
	<term>
	  <option>-b</option>	(bytes)				</term>
	<listitem>
	  <simpara>	bytes worden weergegeven als octaal getal 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-c</option>	(character)			</term>
	<listitem>
	  <simpara>	bytes worden weergegeven in 
			<acronym>ASCII</acronym>, met onzichtbare 
			tekens als escape 
			(zie <xref linkend="aanhaling">)
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-d</option>	(decimal)			</term>
	<listitem>
	  <simpara>	woorden van twee bytes worden weergegeven 
			als positief decimaal getal 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-x</option>	(hexadecimal)			</term>
	<listitem>
	  <simpara>	woorden worden weergeven in hexadecimale notatie
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>-v</option>	(verbose)			</term>
	<listitem>
	  <simpara>	als een regel meerdere keren herhaald 
			wordt, dan wordt-ie ook net zo vaak 
			afgedrukt
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>-A</option>	(address)			</term>
	<listitem>
	  <simpara>	geef het getallenstelsel op dat voor de 
			adressen moet worden gebruikt
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>-j</option>	(jump)				</term>
	<listitem>
	  <simpara>	geeft aan dat een aantal bytes moet 
			worden overgeslagen alvorens de rest af 
			te drukken; 
			het aantal wordt in het decimale stelsel 
			genoteerd, tenzij het met een 
			<literal>0</literal> (octaal) of 
			<literal>0x</literal> (hexadecimaal) begint;
	  </simpara>
	  <simpara> 
			achter het aantal kan nog de eenheid 
			<literal>b</literal> (blokken van 512 
			bytes), <literal>k</literal> (1024 bytes) 
			of <literal>m</literal> (1048576 bytes) 
			volgen; 
			oudere versies van od zetten dit aantal 
			achter de filenaam met een 
			<literal>+</literal> ervoor in octale 
			notatie of decimaal met een punt achter 
			het getal
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>-N</option>	(number)			</term>
	<listitem>
	  <simpara>	geef het aantal bytes aan dat van iedere 
			file moet worden afgedrukt;
			achter het aantal kan nog de eenheid 
			<literal>b</literal> (blokken van 512 
			bytes), <literal>k</literal> (1024 bytes) 
			of <literal>m</literal> (1048576 bytes) 
			volgen 
	  </simpara>
	</listitem>
      </varlistentry>
       <varlistentry>
	<term>
	  <option>-t</option>	(type)				</term>
	<listitem>
	  <simpara>	een alternatieve manier om het formaat 
			aan te geven: 
			het type kan met <literal>a</literal>, 
			<literal>c</literal>, <literal>d</literal>, 
			<literal>f</literal>, <literal>o</literal>, 
			<literal>u</literal> of <literal>x</literal> 
			worden aangeduid, 
			waarin <literal>a</literal> staat voor 
			<acronym>ASCII</acronym>, <literal>f</literal> 
			voor <foreignphrase>floating point</foreignphrase>,
			<literal>d</literal> voor decimaal en 
			<literal>u</literal> voor een positief decimaal
			getal;
			achter de letter kan nog de lengte worden 
			opgegeven met <literal>1</literal>, 
			<literal>2</literal>, <literal>4</literal> 
			of <literal>8</literal> bytes
	  </simpara>
	</listitem>
      </varlistentry>
     </variablelist>
  </para>
  <para>
	<firstterm>Strings</firstterm> is een ruw tooltje om 
	tekstfragmenten uit binaire bestanden, met name 
	programma's, te filteren. 
	De syntaxis luidt:  

   <cmdsynopsis>
      <command>		strings					</command>
      <arg choice="opt">-<arg choice="opt">a</arg>		</arg>
      <arg choice="opt">-<arg choice="opt">n</arg><replaceable>lengte</replaceable></arg>
      <arg choice="opt">-t
	<group choice="plain">
	  <arg>		d					</arg>
	  <arg>		o					</arg>
	  <arg>		x					</arg>
	</group>
      </arg>
      <arg choice="opt" rep="repeat">
			file					
      </arg>
    </cmdsynopsis>
  </para>
  <para>
	De opties luiden: 

    <variablelist>
      <varlistentry>
	<term>
	  <option>-a</option>	(all)				</term>
	<listitem>
	  <simpara>	doorzoek hele bestand in plaats van 
			alleen de <firstterm>data sectie</firstterm> 
			van een programma;
			deze optie kan worden afgekort tot een 
			enkel min-teken
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-n</option>	(number)			</term>
	<listitem>
	  <simpara>	geeft aan dat alle strings met minimum 
			<replaceable>lengte</replaceable> worden 
			geretourneerd in plaats van de standaard 
			waarde 4; 
			deze optie mag worden afgekort tot 
			<option>-<replaceable>lengte</replaceable></option>
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-t</option>	(type)				</term>
	<listitem>
	  <simpara>	zorgt ervoor dat voor elke gevonden string 
			de positie in de file wordt afgedrukt 
			in decimale, octale, of hexadecimale notatie
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="printenv">
  <title>	 printenv					</title>
  <para>
	<firstterm>Printenv</firstterm> drukt de waarde 
	van omgevingsvariabelen af. 
	De syntaxis luidt:
  
   <cmdsynopsis>
      <command>		printenv				</command>
	<arg choice="opt" rep="repeat">
			variabele				</arg>
    </cmdsynopsis>
  </para>
  <para>
	Zonder argumenten worden alle variabelen afgedrukt, 
	net als met <command>set</command>; 
	als de namen van variabelen worden meegegeven, 
	dan worden die afgedrukt. 
	<command>printenv TERM</command> doet vrijwel
	hetzelfde als <command>echo $TERM</command>. 
  </para>
  <para>
	De exit status is <literal>0</literal> (true) als 
	alle variabelen bestaan en <literal>1</literal> (false) 
	als er &eacute;&eacute;n ongedefinieerd is. 
  </para>
</sect2>

<sect2 id="sleep">
  <title>	 sleep						</title>
  <para>
	<firstterm>Sleep</firstterm> onderbreekt de uitvoering 
	van een programma tijdelijk. 
	De syntaxis luidt:
   <cmdsynopsis>
      <command>		sleep					</command>
	<arg choice="plain">
			<replaceable>seconden</replaceable>	</arg>
    </cmdsynopsis>
  </para>
  <para>
	Sleep wordt vooral gebruikt om in een oneindige lus de 
	processor niet nodeloos te belasten in de trant van 

    <informalexample>
      <programlisting>
while true
do
  if [ <replaceable>er_is_post</replaceable> ] 
  then
    <replaceable>lees_post</replaceable>
    break
  sleep 10
done								</programlisting>
    </informalexample>
  </para>
</sect2>

<sect2 id="su">
  <title>	 su						</title>
  <para>
	Met het <firstterm>substitute user</firstterm> kan een 
	nieuwe shell worden opgestart onder een andere naam;
	standaard is dat root, ook wel eens als superuser aangeduid. 
	Na een <command>exit</command> commando komt u weer terug 
	in de oude shell. 
	Su vraagt uiteraard om het wachtwoord, tenzij het door 
	root wordt uitgevoerd. 
	Het wordt ook vaak gebruikt om een programma juist 
	minder privileges te geven voor de veiligheid. 
	De syntaxis luidt:

   <cmdsynopsis>
      <command>		su					</command>
      <arg choice="opt">-					</arg>
      <arg choice="opt"><replaceable>naam</replaceable>		</arg>
      <arg choice="opt">-c <replaceable>commando</replaceable>	</arg> 
    </cmdsynopsis>
  </para>
  <para>
	Standaard erft de nieuwe shell de oude omgeving 
	(directory en variabelen), maar de <option>-</option> 
	optie maakt een <firstterm>login shell</firstterm> en 
	voert <filename>~/.profile</filename> uit e.d. 
	Met de <option>-c</option> optie wordt in plaats van een 
	interactieve shell een enkel commando uitgevoerd. 
	Vergelijk eens de volgende twee opdrachten. 

    <informalexample>
      <programlisting>
su -c "whoami "
su -c "who am i" 						</programlisting>
    </informalexample>
  </para>
</sect2>

<sect2 id="tee">
  <title>	 tee						</title>
  <para>
	<firstterm>Tee</firstterm> vormt een t-stuk in een 
	pijpleiding. 
	Het is een eenvoudig filter dat de standaard invoer 
	behalve naar de uitvoer ook naar de opgegeven files 
	kopieert. Zie ook <xref linkend="pijpleidingen">. 
	De syntaxis luidt: 
 
    <cmdsynopsis>
      <command>		tee					</command>
      <arg choice="opt">-a					</arg>
      <arg choice="opt">-i					</arg>
      <arg choice="opt" rep="repeat">
			<replaceable>file</replaceable>	
      </arg> 
    </cmdsynopsis>
  </para>
  <para>
	De opties luiden: 

    <variablelist>
      <varlistentry>
	<term>
	  <option>-a</option>	(append)			</term>
	<listitem>
	  <simpara>	plakt de uitvoer achter de file(s) in 
			plaats van ze te overschrijven
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-i</option>	(ignore)			</term>
	<listitem>
	  <simpara>	Negeer een eventueel <literal>SIGINT</literal> 
			signaal
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
</sect2>

<sect2 id="time">
  <title>	 time						</title>
  <para>
	<firstterm>Time</firstterm> kan zowel een intern 
	shell commando als extern programma zijn. 
	Het voert een programma uit en geeft weer hoeveel tijd 
	het gekost heeft als verstreken tijd en het aantal 
	seconden dat de computer eraan heeft besteed in de 
	<foreignphrase>user</foreignphrase> en 
	<foreignphrase>system</foreignphrase> modus. 
	De syntaxis luidt:  

     <cmdsynopsis>
      <command>		time					</command>
      <arg choice="plain">
			<replaceable>commando</replaceable> 
      </arg>
      <arg choice="opt" rep="repeat">
			<replaceable>argument</replaceable>	
      </arg> 
    </cmdsynopsis>
  </para>
</sect2>

<sect2 id="tr">
  <title>	 tr						</title>
  <para>
	<firstterm>Tr</firstterm> is een eenvoudig filter 
	waarmee tekens in een tekstbestand door andere vervangen 
	kunnen worden zonder de kracht of complexiteit van 
	bijvoorbeeld sed; 
	de bewerkte standaard invoer verschijnt op de standaard 
	uitvoer. 
	De Sytem V, <acronym>BSD</acronym> en <acronym>GNU</acronym> 
	versies lopen nogal uiteen. 
	De syntaxis luidt ongeveer: 

     <cmdsynopsis>
      <command>		tr					</command>
      <arg choice="opt">-c					</arg>
      <arg choice="opt">-s					</arg>
      <arg choice="opt">-d					</arg>
      <arg choice="plain"><replaceable>string</replaceable>1	</arg> 
      <arg choice="opt"><replaceable>string</replaceable>2	</arg>
    </cmdsynopsis>
  </para>
  <para>
	De opties zijn:

    <variablelist>
      <varlistentry>
	<term>
	  <option> </option>	(geen)				</term>
	<listitem>
	  <simpara>	Vervang alle tekens in de verzameling 
			<replaceable>string</replaceable>1 door 
			het corresponderende teken in 
			<replaceable>string</replaceable>2, 
			die even lang moeten zijn, bijvoorbeeld 
			<command>tr '[:upper:]' '[:lower:]'</command> 
			om alle hoofdletters door kleine te 
			vervangen
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-c</option>	(complement)			</term>
	<listitem>
	  <simpara>	Vervang alle tekens in 
			<replaceable>string</replaceable>1 door 
			tekens die niet in 
			<replaceable>string</replaceable>1 voorkomen; 
			het resultaat kan per besturingssysteem
			verschillen
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-d</option>	(delete)			</term>
	<listitem>
	  <simpara>	Verwijder alle tekens die voorkomen in
			<replaceable>string</replaceable>1
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-s</option>	(squeeze)			</term>
	<listitem>
	  <simpara>	als een teken uit 
			<replaceable>string</replaceable>1 meerdere 
			keren achter elkaar voorkomt, dan blijft er 
			maar &eacute;&eacute;n over in de output, 
			bijvoorbeeld 
			<command>tr -s '\000-\040'</command> verwijdert 
			dubbele spaties, lege regels e.d.
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	De opties kunnen ook gecombineerd worden. 
	In de strings mogen de backslash escapes van 
	<xref linkend="aanhaling"> en de karakter klassen van 
	<xref linkend="grep"> worden gebruikt. 
	Tevens kunnen reeksen tekens worden aangegeven met 
	<option><replaceable>begin-eind</replaceable></option> en 
	<option>[<replaceable>teken</replaceable>*<replaceable>aantal</replaceable>]</option>. 
  </para>
</sect2>

<sect2 id="wc">
  <title>	 wc						</title>
  <para>
	<firstterm>Wc</firstterm> is een eenvoudig tooltje om de 
	lengte van een tekst te tellen. 
	De syntaxis luidt: 

     <cmdsynopsis>
      <command>		wc					</command>
      <arg choice="opt">-l					</arg>
      <arg choice="opt">-w					</arg>
      <arg choice="opt">-c					</arg>
      <arg choice="opt" rep="repeat">
			<replaceable>file</replaceable>	
      </arg> 
    </cmdsynopsis>
  </para>
  <para>
	De opties zijn:

    <variablelist>
      <varlistentry>
	<term>
	  <option>-l</option>	(lines)				</term>
	<listitem>
	  <simpara>	tel het aantal regels 
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-w</option>	(words)				</term>
	<listitem>
	  <simpara>	tel het aantal woorden
	  </simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term>
	  <option>-c</option>	(characters)			</term>
	<listitem>
	  <simpara>	telt het aantal <emphasis>bytes</emphasis>; 
			sommige versies hebben een optie
			<option>-m</option> die karakters telt
	  </simpara>
	</listitem>
      </varlistentry>
    </variablelist>
  </para>
  <para>
	Standaard worden regels, woorden en bytes of tekens geteld. 
	Als er meerdere files worden opgegeven, dan volgt nog een 
	regel met het totaal over alle files (verwarrend als u een 
	bestand <filename>total</filename> hebt :-) 
  </para>
</sect2>

<sect2 id="yes">
  <title>	 yes						</title>
  <para>
	<firstterm>Yes</firstterm> is een simpel programmaatje, 
	dat zolang <computeroutput>y</computeroutput> of een 
	andere string produceert totdat het wordt afgebroken. 
	De syntaxis luidt: 

     <cmdsynopsis>
      <command>		yes					</command>
      <arg choice="opt"><replaceable>string</replaceable> 	</arg>
    </cmdsynopsis>
  </para>
  <para>
	Het wordt vooral gebruikt in pijpleidingen, zoals 
	<command>yes n | fsck /</command> 
	Fsck zal vragen of u wel zeker weet dat u het root file 
	systeem wilt controleren; 
	omdat dat riskant is op een aktief systeem wordt die 
	vraag automatisch met <literal>n</literal>(ee) beantwoord. 
  </para>
</sect2>

</sect1>
<!-- eind derde hoofdstuk 					-->
</article>