inScheme : get the variables defined a loaded file

Laurent,

The documentation for load makes this clear:

Opens a file, repeatedly calls lineread to read in the file,
immediately evaluating each form after it is read in. Uses the
file extension to determine the language mode (.il/.ile for SKILL
and .ils/.ilse for SKILL++) for processing the language expressions
contained in the file. By default, the loaded code is evaluated
in dynamic scoping. However, if the extension is .ils/.ilse,
lexical scoping is used. For a SKILL++ file, the loaded code
is always evaluated in the top level environment.

Since your extension is .txt, it will be loaded using SKILL semantics (dynamic scoping)

Andrew

Trying the suggested workaround code instead:

(inScheme
  (defglobalfun myfunSch2 ()
    (let ( A B C (myfile "./myfile.txt") port data)
      (setq port (infile myfile))
      (while (setq data (read port))
	     (eval data (theEnvironment)))
      (close port)
      (printf "inScheme : \n")
      (println A)
      (println B)
      (println C)
    )
  )
(myfunSch2)
)

I was struggling to get it to post (I kept getting an error). Anyway, the workaround code uses read to read each form from the file, then eval with the lexical environment passed as the second (optional) argument. That way the evaluation is done in the lexical environment and the output from myfunSch2 is:

inScheme :
1
"toto"
(1 2 "test")

Andrew

Hello Andrew,

Indeed the documentation is clear. But as my file has not an .ils extension, I was stuck in the dynamic scoping and didn't find the way to retrieve my data in the lexical scoping.

Thank you for the answer. It helps much.

Laurent.

Laurent,

I also meant to point out that even if you had the .ils suffix, it still wouldn't have done as you expect - because the contents of the file being loaded would be treated as their own lexical scope (or rather evaluated in the top level lexical scope).

Anyway, glad to have cleared things up.

Regards,

Andrew

Thanks for the information complement.

Finally, I updated my code like that

(inScheme
(defun readinSkillFile (file @optional (env (theEnvironment)))
  "Retrieve the data from a file in the scoping defined in env"
  (let ( (port (infile file)) data)
    (while (setq data (read port)) (eval data env))
))

(defglobalfun myfunSch ()
  (let ( A B C (myfile "./myfile.txt") )
    (readinSkillFile myfile (theEnvironment))
    (printf "inScheme : \n")
    (println A)
    (println B)
    (println C)
) )
(myfunSch)
)

Note that in this example, there's no difference between using defun and defglobalfun - both functions are in the top-level scope and so are global. This would only make a difference if they were in a lexical scope (e.g. both within the same let().

Andrew

Thanks for the remark.

In my "real" code, the two functions are in the same let.