INPUT EN OUTPUT

Een programma laden

Tot hiertoe zij we er van uitgegaan dat alle functiedefinities en functie-aanroepen in het Lispinteractiesysteem plaatsvinden. In praktijk gaat het er natuurlijk anders aan toe. Programma's worden geschreven in een aangepaste editor die specifieke Lisp ondersteuning biedt (bijv. haakjesmatching, automatische indentatie, evaluatie van definities en functieaanroepen vanuit de editor). Wanneer een programma klaar is kan het ingeladen worden met behulp van de procedure (LOAD string), waarbij de string de naam van de in te laden file is. De preciese semantiek van LOAD hangt af van de Scheme versie waarmee gewerkt wordt, en van het operating systeem van de machine waarop de Scheme werkt.

Bij een file die wordt geladen is het alsof alle definities en aanroepen in de file ingetikt zouden worden in het Lisp interactiesysteem. Commentaar (al wat ; volgt op een regel) wordt genegeerd.

File input en output

Poorten (ports) zijn speciale datatypes die characters kunnen produceren (input ports) en accepteren (output ports). Meestal zijn ports geassocieerd met files, hoewel in principe ook bijv. printers of beeldschermen verbonden kunnen zijn met ports.

• (CALL-WITH-INPUT-FILE string procedure). Het string argument refereert naar de naam van een file (die moet bestaan, zoniet wordt een fout gemeld), de procedure heeft één argument, de naam van de port die naar de file verwijst waar de input vandaan zal komen.
• (CALL-WITH-OUTPUT-FILE string procedure). Zoals bij de vorige procedure, maar dan voor output van characters naar een file. Wat er gebeurt als de file al bestaat hangt af van de specifieke Scheme implementatie.
• (INPUT-PORT? port) en (OUTPUT-PORT? port). retourneren #t als hun argument respectievelijk een input en een output port zijn.
• (CURRENT-INPUT-PORT) en (CURRENT-OUTPUT-PORT) zijn functies die de port retourneren die verbonden is aan de standaard input en output. Dit zijn per default de poorten die naar input en output in het Lisp interactiesysteem verwijzen.
• (WITH-INPUT-FROM-FILE string procedure). String verwijst hier naar een bestaande input file, en de procedure mag geen argumenten hebben (zo'n procedure wordt wel eens een thunk genoemd). In de context van die procedure is de standaard input gebonden aan de door string genoemde inputfile.
• (WITH-OUTPUT-TO-FILE string procedure). String verwijst naar een output file waarin alle output die naar standaard output wordt gestuurd in de context van de argumentloze procedure terecht zal komen.
• (OPEN-INPUT-FILE string) en (OPEN-OUTPUT-FILE string) retourneren een port (te binden aan een variabele) voor respectievelijk file input en file output.
• (CLOSE-INPUT-PORT port) en (CLOSE-OUTPUT-PORT port) sluiten de file geassocieerd met de port.

(call-with-output-file "junk" (lambda (out)
                                 (do ((c 0 (+ c 1)))
                                     ((= c 10))
                                   (write c out)
                                   (newline out))))

; Resulteert in een file met naam junk en inhoud:
0
1
2
3
4
5
6
7
8
9

Input

• (READ [port]). Leest een Lisp expressie uit inputkanaal waar port naar verwijst. Als port niet gegeven is wordt gelezen van de standaard input (het Lisp interactie systeem). ``Lezen'' betekent dat een externe representatie van een Lisp object wordt omgezet in dat object zelf. Een neveneffect van READ is dat de input poort verwijst naar het eerste character na het pasgelezen Lisp object.
• (READ-CHAR [port]). Leest een character via de port of standaardinput als port niet gegeven is. Weer wordt de port zodanig aangepast dat ze naar het het eerste character na het pas gelezen character verwijst.
• (PEEK-CHAR [port]). Zoals READ-CHAR, maar de port wordt niet aangepast.
• (EOF-OBJECT? expressie). Wanneer geen verdere input van bijvoorbeeld een file mogelijk is (End Of File), wordt bij een leesoperatie het EOF symbool geretourneerd. Dat kan bijvoorbeeld

  #<EOF>

  zijn. Dit predikaat test of een Lisp expressie het EOF symbool is.

Output

• (WRITE expressie [port]). Schrijft een externe representatie van de Lisp expressie naar het outputmedium dat geassocieerd is met de port. Wanneer de port niet wordt gespecificeerd wordt de standaard output gebruikt.
• (DISPLAY expressie [port]). Schrijft een representatie van expressie naar port.
• (NEWLINE [port]). Stuurt een End Of Line naar de port (of naar standaard output als port niet gegeven is).
• (WRITE-CHAR character [port]). Schrijft character naar port of standaard output als port niet gegeven is.

> (read)
> (appels en peren)
(appels en peren)
> (read-char)appel
#\a
ERROR: unbound variable:  ppel
> (read-char)                ; representatie van newline is #\nl
#\nl
> (read-char)&
#\&
> (peek-char)&
#\&
ERROR: unbound variable:  &
> (peek-char)12
#\1
12
> (newline)


> (write "appelflap")
"appelflap"
> (display "appelflap")
appelflap
> (write-char #\A)
A#

Het volgende programma leest een tekst uit een input file, en telt hoeveel keer elke letter van het alfabet voorkomt in die tekst.

(define (tel-letters file-naam)
  (with-input-from-file file-naam
     (lambda ()
        (let ((results (make-vector 26 0)))
          (do ((c (read-char) (read-char)))
              ((eof-object? c) (vector->list results))
             (if (char-alphabetic? c)
                 (if (char-upper-case? c)
                     (let ((index (- (char->integer c) 65)))
                        (vector-set! results index
                                     (+ 1 (vector-ref results index))))
                 (let ((index (- (char->integer c) 97)))
                    (vector-set! results index
                                 (+ 1 (vector-ref results index)))))))))))

(tel-letters "chapter-1")  ; Sectie 1 van dit document, inclusief opmaakcodes
                           ; van a/A ot z/Z

(950 192 276 533 2374 161 369 189 983 133 205 581 475 1226 717 368 0
832 653 891 271 305 124 27 47 88)