5. Bigloo -- Standard Library<BR>5.2 Input and output

5. Bigloo -- Standard Library
5.2 Input and output

Browsing

Home: Bigloo
A ``practical Scheme compiler''
for Bigloo version 2.5a
April 2002

Previous chapter: Core Language
Next chapter: Pattern Matching


Standard Library

5.1 Scheme Library
5.2 Input and output
5.3 Structures and Records
5.4 Serialization
5.5 Bit manipulation
5.6 Hash Tables
5.7 System programming
5.8 Process support
5.9 Socket support
5.10 Posix Regular Expressions


Chapters

Copyright
Acknowledgements
1. Table of contents
2. Overview of Bigloo
3. Modules
4. Core Language
5. Standard Library
6. Pattern Matching
7. Object System
8. Threads
9. Regular parsing
10. Lalr(1) parsing
11. Errors and Assertions
12. Eval and code interpretation
13. Macro expansion
14. Command Line Parsing
15. Explicit typing
16. The C interface
17. The Java interface
18. Bigloo Libraries
19. SRFIs
20. DSSSL support
21. Compiler description
22. User Extensions
23. Bigloo Development Environment
24. Global Index
25. Library Index
Bibliography


call-with-input-file string proclibrary procedure
call-with-output-file string proclibrary procedure
These two procedures call proc with one argument, a port obtained by opening string. See
r5rs, Ports, for more details.

(call-with-input-file "/etc/passwd"
   (lambda (port)
      (let loop ((line (read-line port)))
         (if (not (eof-object? line))
             (begin
                (print line)
                (loop (read-line port)))))))

input-port? obj procedure
output-port? objprocedure
port? objprocedure

input-port-name objbigloo procedure
Returns the file name for which obj has been opened.

input-port-reopen! objbigloo procedure
Re-open the input port obj. That is, re-start reading from the first character of the input port.

input-port-position objbigloo procedure
Returns the current position (character number) of the input port obj.

file-exists? stringbigloo procedure
This procedure returns #t if the file string exists. Otherwise it returns #f.

delete-file stringbigloo procedure
Deletes the file named string. The result of this procedure is unspecified.

rename-file string1 string2bigloo procedure
Renames the file string1 as string2. The two files have to be located on the same file system. If the renaming succeeds, the result is #t, otherwise it is #f.

directory? stringbigloo procedure
This procedure returns #t if the file string exists and is a directory. Otherwise it returns #f.

make-directory stringbigloo procedure
Creates a new directory named string. It returns #t if the directory was created. It returns #f otherwise.

make-directories stringbigloo procedure
Creates a new directory named string, including any necessary but nonexistent parent directories. It returns #t if the directory was created. It returns #f otherwise. Note that if this operation fails it may have succeeded in creating some of the necessary parent directories.

delete-directory stringbigloo procedure
Deletes the directory named string. The directory must be empty in order to be deleted. The result of this procedure is unspecified.

directory->list stringbigloo procedure
If file string exists and is a directory, this function returns the list of files in string.

file-modification-time stringbigloo procedure
The date (in second) of the last modification for file string.

file-size stringbigloo procedure
Returns the size (in bytes) for file string.

chmod string [option]bigloo procedure
Change the access mode of the file named string. The option must be either read, write and execute. If the operation succeeds, chmod returns #t. It returns #f otherwise.

Example:

(chmod (make-file-name (getenv "HOME") ".bigloorc") 'read 'write)

current-input-portprocedure
current-output-portprocedure
current-error-portbigloo procedure

with-input-from-file string thunkoptional procedure
with-input-from-string string thunkoptional procedure
with-output-to-file string thunkoptional procedure
with-error-to-file string thunkbigloo procedure
with-output-to-string thunkbigloo procedure
with-error-to-string thunkbigloo procedure
A port is opened from file string. This port is made the current input port (resp. the current output port or the current error port) and thunk is called. See
r5rs, Ports, for more details.

(with-input-from-file "/etc/passwd"
   (lambda ()
      (let loop ((line (read-line (current-input-port))))
         (if (not (eof-object? line))
             (begin
                (print line)
                (loop (read-line (current-input-port))))))))

with-input-from-port port thunkbigloo procedure
with-output-to-port port thunkbigloo procedure
with-error-to-port port thunkbigloo procedure
with-input-from-port, with-output-to-port and with-error-to-port all suppose port to be a legal port. They call thunk making port the current input (resp. output or error) port. None of these functions close port on the continuation of thunk.

(with-output-to-port (current-error-port) 
   (lambda () (display "hello")))

open-input-file file-nameprocedure
If file-name is a regular file name, open-input-file behaves as the function defined in the Scheme report. If file-name starts with special prefixes it behaves differently. Here are the recognized prefixes:

  • | (a string made of the characters #\| and #\space) Instead of opening a regular file, Bigloo opens an input pipe. The same syntax is used for output file.

    (define pin (open-input-file "| cat /etc/passwd"))
    (define pout (open-output-file "| wc -l"))
    
    (display (read pin) pout)
    (close-input-port pin)
    (newline pout)
    (close-output-port pout)
    
  • pipe: Same as | .

  • file: Opens a regular file.

  • string: Opens a port on a string. This is equivalent to open-input-string. Example:

    (with-input-from-file "string:foo bar Gee"
       (lambda ()
          (print (read))
          (print (read))
          (print (read))))
       -| foo
       -| bar
       -| Gee
    
  • http:server/path Opens an http connection on server and open an input file on file path.

  • http:server:port-number/path Opens an http connection on server, on port number port and open an input file on file path.

  • ftp:server/path Opens an http connection on server and open an input file on file path.


open-input-string stringbigloo procedure
Returns an input-port able to deliver characters from string.

open-input-c-string stringbigloo procedure
Returns an input-port able to deliver characters from C string string. The buffer used by the input port is the exact same string as the argument. That is, no buffer is allocated.

open-output-file file-nameprocedure
The same syntax as open-input-file for file names applies here. When a file name starts with | , Bigloo opens an output pipe instead of a regular file.

append-output-file file-namebigloo procedure
If file-name exists, this function returns an output-port on it, without removing it. New output will be appended to file-name. If file-name does not exist, it is created.

open-output-stringbigloo procedure
This function returns an output string port. This object has almost the same purpose as output-port. It can be used with all the printer functions which accept output-port. An output on a output string port memorizes all the characters written. An invocation of flush-output-port or close-output-port on an output string port returns a new string which contains all the characters accumulated in the port.

get-output-string output-portbigloo procedure
Given an output port created by open-output-string, returns a string consisting of the characters that have been output to the port so far.

close-input-port input-portprocedure
close-output-port output-portprocedure
According to R5RS, the value returned is unspecified. However, if output-port was created using open-output-string, the value returned is the string consisting of all characters sent to the port.

input-port-position input-portbigloo procedure
Returns the current position (a number), in the input-port.

input-port-name input-portbigloo procedure
Returns the name of the file used to open the input-port.

read [input-port]procedure
read/case case [input-port]bigloo procedure
read-case-sensitive [input-port]bigloo procedure
read-case-insensitive [input-port]bigloo procedure
Read a lisp expression. The case sensitivity of read is unspecified. If have to to enforce a special behavior regarding the case, use read/case, read-case-sensitive or read-case-insensitive. Let us consider the following source code: The value of the read/case's case argument may either be upcase, downcase or sensitive. Using any other value is an error.

(define (main argv)
   (let loop ((exp (read-case-sensitive)))
      (if (not (eof-object? exp))
          (begin
             (display "exp: ")
             (write exp)
             (display " [")
             (display exp)
             (display "]")
             (print " eq?: " (eq? exp 'FOO) " " (eq? exp 'foo))
             (loop (read-case-sensitive))))))
Thus:
> a.out
foo
  -| exp: foo [foo] eq?: #f #t
FOO
  -| exp: FOO [FOO] eq?: #t #f

read/rp grammar portbigloo procedure
read/lalrp lalrg rg port [emptyp]bigloo procedure
These functions are fully explained in
Regular Parsing, and Lalr Parsing.

read-char [port]procedure
peek-char [port]procedure
eof-object? objprocedure
char-ready? [port]procedure

read-line [input-port]bigloo procedure
Reads characters from input-port until a #\Newline, a #\Return or an end of file condition is encountered. read-line returns a newly allocated string composed of the characters read.

read-of-strings [input-port]bigloo procedure
Reads a sequence of non-space characters on input-port, makes a string of them and returns the string.

write obj [output-port]library procedure
display obj [output-port]library procedure
print obj ...bigloo procedure
This procedure allows several objects to be displayed. When all these objects have been printed, print adds a newline.

display* obj ...bigloo procedure
This function is similar to print but does not add a newline.

fprint output-port obj ...bigloo procedure
This function is the same as print except that a port is provided.

newline [output-port]procedure
write-char char [output-port]procedure
flush-output-port output-portbigloo procedure
This procedure flushes the output port output-port.

set-write-length! lenbigloo procedure
Sets to len the maximum number of atoms that can be printed by write and display. This facility is useful in preventing the printer from falling into an infinite loop when printing circular structures.

get-write-lengthbigloo procedure
Gets the current length of the printer. That is, get-write-length returns the maximum number of Bigloo objects that are allowed to be printed when printing compound objects. This function is useful in preventing the system from looping when printing circular data structures.

set-printer! procbigloo procedure
Set the current printer to be proc; proc has to be a procedure expecting at least one argument: an expression to print; an output port is an optional, second argument.

native-printerbigloo procedure
Returns the native Bigloo's printer.

pp obj [output-port]bigloo procedure
Pretty print obj on output-port.

*pp-case*bigloo variable
Sets the variable to respect, lower or upper to change the case for pretty-printing.

*pp-width*bigloo variable
The width of the pretty-print.

write-circle obj [output-port]bigloo procedure
Display recursive object obj on output-port. Each component of the object is displayed using the write library function.

display-circle obj [output-port]bigloo procedure
Display recursive object obj on output-port. Each component of the object is displayed using the display library function.

For instance:
(define l (list 1 2 3))
(set-car! (cdr l) l)
(set-car! (cddr l) l)
(display-circle l)  -| #0=(1 #0# #0#)


This
Scribe page has been generated by scribeinfo.
Last update Thu Apr 25 09:40:15 2002