/// <summary>
/// Log output to the transcript file.
/// Do this only if the transcript is on, and the port is the current output port.
/// </summary>
/// <param name="str">The output to log.</param>
/// <param name="port">The port that it was written to.</param>
internal void LogOutput(string str, OutputPort port)
{
if (this.transcriptWriter == null || port != this.interp.CurrentOutputPort)
{
return;
}
this.transcriptWriter.Write(str);
}
/// <summary>
/// Initializes a new instance of the EvaluateCallWithOutputFile class.
/// </summary>
/// <param name="args">A pair, containing a filename and a proc to evaluate.</param>
/// <param name="env">The evaluation environment</param>
/// <param name="caller">The caller. Return to this when done.</param>
/// <param name="port">The output port.</param>
private EvaluateCallWithOutputFile(SchemeObject args, Environment env, Evaluator caller, OutputPort port)
: base(InitialStep, args, env, caller)
{
this.port = port;
}
/// <summary>
/// Determine the port object to use with the OutputPort primitives.
/// The port is optional: if supplied, it is the port to use.
/// Otherwise, the current output port is used instead.
/// </summary>
/// <param name="port">The port to use, if supplied. If is is not empty list, then it is an output port.</param>
/// <param name="curr">The current output port.</param>
/// <returns>The port to use.</returns>
private static OutputPort Port(SchemeObject port, OutputPort curr)
{
return port is EmptyList ? curr : (OutputPort)port;
}
/// <summary>
/// Read from the input port and evaluate whatever is there.
/// Done for the side effect, not the result.
/// Since the result is never tested, asynchronous suspensions do not prevent the rest
/// of the file from being loaded.
/// </summary>
/// <param name="inp">The input port.</param>
/// <param name="outp">If not null, input and results are written here.</param>
/// <returns>Undefined instance.</returns>
internal SchemeObject Load(InputPort inp, OutputPort outp)
{
while (true)
{
SchemeObject input;
if ((input = inp.Read()) is Eof)
{
inp.Close();
return Undefined.Instance;
}
if (outp != null)
{
outp.WriteLine("> " + input);
}
var res = this.Eval(input);
if (outp != null)
{
outp.WriteLine(res.ToString());
}
}
}
/// <summary>
/// Load a file.
/// Open the file and read it.
/// Evaluate whatever it contains.
/// This may be one or more expressions.
/// If any of them are asynchronous, then the evaluation is NOT blocked, but continues on.
/// </summary>
/// <param name="fileName">The filename.</param>
/// <param name="outp">If not null, input and results are written here.</param>
public void LoadFile(SchemeObject fileName, OutputPort outp)
{
string name = string.Empty;
try
{
name = fileName.ToString();
using (var fs = new FileStream(name, FileMode.Open, FileAccess.Read))
{
this.Load(InputPort.New(new StreamReader(fs), this), outp);
}
}
catch (IOException)
{
ErrorHandlers.IoError("Can't load " + name);
}
}
/// <summary>
/// Dump the counters on the console.
/// </summary>
/// <param name="port">The port to dump to.</param>
/// <returns>The result is unspecified.</returns>
private SchemeObject DumpCounters(OutputPort port)
{
Contract.Requires(port != null);
var sb = new StringBuilder();
this.Dump(sb);
port.WriteLine(sb.ToString());
return Undefined.Instance;
}