
;; on va voir ce qui se passe si on fait des trucs comme ca


"titi"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

;; on va voir ce qui se passe si on fait des trucs comme ca


"foo"

#\newline

toto

456

"toto n'est pas content"

(1 2 3 toto)

#(toto n est pas content)

(5 6 . 7)

;;;; foo

toto_n_est_pas_content

#( (1 2 3) "toto" (4 . 5) )(1 2)

;*---------------------------------------------------------------------*/
;*    serrano/prgm/project/bigloo/Test/read/read.scm ...               */
;*                                                                     */
;*    Author      :  Manuel Serrano                                    */
;*    Creation    :  Fri May 22 16:17:03 1992                          */
;*    Last change :  Fri May 22 21:22:53 1992  (serrano)               */
;*                                                                     */
;*    Un essai de reader                                               */
;*---------------------------------------------------------------------*/

;*---------------------------------------------------------------------*/
;*    Le module                                                        */
;*---------------------------------------------------------------------*/
(module read
   (export (main (lambda (a)))))

;*---------------------------------------------------------------------*/
;*    main ...                                                         */
;*---------------------------------------------------------------------*/
(define (main argv)
   (if (null? (cdr argv))
       (begin
	  (print "usage: read [name]")
	  -1)
       (let ((stream (open-stream (cadr argv))))
	  (let ((npair   0)
		(nint    0)
		(nstring 0)
		(nvector 0)
		(nchar   0)
		(nsymbol 0))
	     (if (not (stream? stream))
		 (begin
		    (print "can't open file " (cadr argv))
		    -2)
		 (let loop ((sexp   (read stream))
			    (n      0))
		    (if (eof? sexp)
			(begin
			   (print "nsymbol: " nsymbol)
			   (print "nchar  : " nchar)
			   (print "nvector: " nvector)
			   (print "nstring: " nstring)
			   (print "nint   : " nint)
			   (print "npair  : " npair)
			   (print "n      : " n)
			   0)
			(begin
			   (cond
			      ((pair? sexp)
			       (set! npair (+ 1 npair)))
			      ((integer? sexp)
			       (set! nint (+ 1 nint)))
			      ((string? sexp)
			       (set! nstring (+ 1 nstring)))
			      ((vector? sexp)
			       (set! nvector (+ 1 nvector)))
			      ((char? sexp)
			       (set! nchar (+ 1 nchar)))
			      (else
			       (set! nsymbol (+ 1 nsymbol))))
			   (loop (read stream)
				 (+ 1 n))))))))))

(+ 1 2)
