If anyones interested…
When
loading a source, the function ##read-all-as-a-begin-expr-from-psettings is
called which reads the whole file using the reader as if it started with a 
'begin' form. 
Unlike
some common lisp parsers, it does not read a toplevel and then macroexpand it.
But you can evaluate a form during reading using the #. macro form (well, you 
have
to enable this. see below).
Unfortunately,
##read-all-as-a-being-expr-from-port (another function in the chain of calls) 
makes a copy of the ##current-readtable (the default readtable) 
and
then passes it around to other reader macros. So we cant just modify that.  
In
_io.scm
(define-prim
(##read-all-as-a-begin-expr-from-port
             
port
             
readtable
             
wrap
             
unwrap
             
start-syntax
             
close-port?)
 
(##with-exception-catcher
  
(lambda (exc)
    
(if close-port?
      
(##close-input-port port))
    
(macro-raise exc))
  
(lambda ()
    
(let ((rt
           
(##readtable-copy-shallow readtable)))
      
(macro-readtable-start-syntax-set! rt start-syntax)
      
(let* ((re
              
(##make-readenv port rt wrap unwrap 'script))
             
(head
              
(##cons (wrap re '##begin)
                      
'())) ;; tail will be replaced with expressions read
    
         (expr
              
(wrap re head))
             
(first
              
(##read-datum-or-eof re))
             
(script-line
              
(and (##eq? first (##script-marker))
                   
(##read-line port #\newline #f ##max-fixnum)))
             
(language-and-tail
              
(##extract-language-and-tail script-line)))
        
(if language-and-tail
          
(let ((language (##car language-and-tail)))
            
(##readtable-setup-for-language! rt language)))
        
(let* ((rest
                
(if (##eof-object? first)
                  
'()
                  
(##read-all re ##read-datum-or-eof)))
               
(port-name
                
(##port-name port)))
          
(if close-port?
            
(##close-input-port port))
          
(cond ((##eof-object? first)
                 
(##vector #f expr port-name))
                
((##eq? first (##script-marker))
                 
(##set-cdr! head rest)
                 
(##vector script-line expr port-name))
               
 (else
                 
(##set-cdr! head (##cons first rest))
                 
(##vector #f expr port-name)))))))))
----------------------------------------------------------------------
So.
Solutions to being able to redefine the reader table while the file is being
read. 
(1)
Redefine ##read-all-as-a-begin-expr-from-psettings to not make a copy of the
readtable. Probably  not a good idea.
(2)
Create a special reader syntax which imports the current readtable/environment
as a paramter into the special reader when one loads/compiles a file. 
I
like this one. So instead of doing #.(begin (func-1) (func-2)) you redefine #.
to behave the same way except (current-file-readtable) now references the
actual 
readtable/environment
being used.
Note
that you can change the current-readtable parameter value as shown below and
thus change the reader macro when loading non scripts (regular .scm files). I think
what
happens
if the file is declared to be a script is that first the default readtable is
passed in but is then copied and then modified to fit the appropriate language.
If
it is a regular scheme file, i don't think the default readtable is modified,
but i haven't looked into this.
 (parameterize
 
((current-readtable 
   
(let ((readtab 
       
(readtable-keywords-allowed?-set (readtable-eval-allowed?-set
(current-readtable) #t) #f)))
     
(##readtable-char-class-set! readtab  ;;changing  reader macro as a
demonstration. look at _io.scm for more examples
      
#\; #\t (lambda (re c)
            (display
c) (display "GOOFY!")
            (error
"IM NOT a comment!")))
     
readtab)))
 
(load "tar.scm")
 ;....save
the current-readtable which has been modified
)
tar.scm:
;'yodel
Output:
 ;GOOFY!***
ERROR IN ##load -- IM NOT a comment!
OK,
but what if we want to change the readtable in the actual file instead of
before loading it?
Well,
now all we have to figure out is, given a environment object and readtable, how
do we go about 'injecting' a parameter into the environment?
Well,
in _io.scm, heres the definition of the read-sharp-dot macro. And thats about
far as I went. I imagine youde have to find out how to pass a environment to
the #eval.
(define
(##read-sharp-dot re next start-pos)
 
(if (not (macro-readtable-eval-allowed? (macro-readenv-readtable re)))
   
(begin
     
(##raise-datum-parsing-exception 'invalid-token re)
  
   (##read-datum-or-label-or-none-or-dot re)) ;; skip error
   
(begin
     
(macro-read-next-char-or-eof re) ;; skip char after #\#
     
(let* ((expr
             
(##read-expr-from-port
              
(macro-readenv-port re)))
            
(val
       
      (##eval expr)))
       
(macro-readenv-filepos-set! re start-pos) ;; set pos to start of datum
       
(macro-readenv-wrap re val)))))