public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 2)
{
string subCommand = arguments[1];
bool tried = false;
code = ScriptOps.TryExecuteSubCommandFromEnsemble(
interpreter, this, clientData, arguments, true,
false, ref subCommand, ref tried, ref result);
if ((code == ReturnCode.Ok) && !tried)
{
switch (subCommand)
{
case "decode":
{
if (arguments.Count >= 3)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.MustHaveEncodingValue, Index.Invalid, Index.Invalid, "-encoding", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) &&
((argumentIndex + 1) == arguments.Count))
{
Variant value = null;
Encoding encoding = null;
if (options.IsPresent("-encoding", ref value))
{
encoding = (Encoding)value.Value;
}
if (code == ReturnCode.Ok)
{
try
{
string stringValue = null;
code = StringOps.GetString(encoding,
Convert.FromBase64String(arguments[argumentIndex]),
EncodingType.Binary, ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
result = stringValue;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"base64 decode ?options? string\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"base64 decode ?options? string\"";
code = ReturnCode.Error;
}
break;
}
case "encode":
{
if (arguments.Count >= 3)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.MustHaveEncodingValue, Index.Invalid, Index.Invalid, "-encoding", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) && ((argumentIndex + 1) == arguments.Count))
{
Variant value = null;
Encoding encoding = null;
if (options.IsPresent("-encoding", ref value))
{
encoding = (Encoding)value.Value;
}
if (code == ReturnCode.Ok)
{
try
{
byte[] bytes = null;
code = StringOps.GetBytes(
encoding, arguments[argumentIndex],
EncodingType.Binary, ref bytes, ref result);
if (code == ReturnCode.Ok)
{
result = Convert.ToBase64String(bytes,
Base64FormattingOptions.InsertLineBreaks);
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"base64 encode ?options? string\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"base64 encode ?options? string\"";
code = ReturnCode.Error;
}
break;
}
default:
{
result = ScriptOps.BadSubCommand(
interpreter, null, null, subCommand, this, null, null);
code = ReturnCode.Error;
break;
}
}
}
}
else
{
result = "wrong # args: should be \"base64 option ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
string channelId = arguments[1];
Channel channel = interpreter.GetChannel(channelId, ref result);
if (channel != null)
{
Encoding encoding = null;
if (interpreter.GetChannelEncoding(channel, ref encoding) == ReturnCode.Ok)
{
try
{
ByteList buffer = null;
code = channel.Read(ref buffer, ref result);
if (code == ReturnCode.Ok)
{
string stringValue = null;
code = StringOps.GetString(
encoding, buffer.ToArray(), EncodingType.Binary,
ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
if (arguments.Count == 3)
{
code = interpreter.SetVariableValue(
VariableFlags.None, arguments[2], stringValue,
null, ref result);
if (code == ReturnCode.Ok)
{
int length = stringValue.Length;
if (length > 0)
{
result = length;
}
else
{
bool canSeek = channel.CanSeek;
if ((canSeek && channel.EndOfStream) ||
(!canSeek && channel.HitEndOfStream))
{
result = Channel.EndOfFile;
}
else
{
result = length; /* ZERO */
}
}
}
}
else
{
result = stringValue;
}
}
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"failed to get encoding for channel \"{0}\"",
channelId);
code = ReturnCode.Error;
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"gets channelId ?varName?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 2)
{
string subCommand = arguments[1];
bool tried = false;
code = ScriptOps.TryExecuteSubCommandFromEnsemble(
interpreter, this, clientData, arguments, true,
false, ref subCommand, ref tried, ref result);
if ((code == ReturnCode.Ok) && !tried)
{
switch (subCommand)
{
case "deserialize":
{
if (arguments.Count >= 4)
{
#if SERIALIZATION
OptionDictionary options = ObjectOps.GetDeserializeOptions();
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) == arguments.Count))
{
bool verbose;
bool strictType;
bool noCase;
ObjectOps.ProcessGetTypeOptions(
options, out verbose, out strictType, out noCase);
Type returnType;
ObjectFlags objectFlags;
string objectName;
string interpName;
bool create;
bool dispose;
bool alias;
bool aliasRaw;
bool aliasAll;
bool aliasReference;
bool toString;
ObjectOps.ProcessFixupReturnValueOptions(
options, null, out returnType, out objectFlags,
out objectName, out interpName, out create,
out dispose, out alias, out aliasRaw, out aliasAll,
out aliasReference, out toString);
if (noCase)
{
objectFlags |= ObjectFlags.NoCase;
}
Variant value = null;
Encoding encoding = null;
if (options.IsPresent("-encoding", ref value))
{
encoding = (Encoding)value.Value;
}
if (code == ReturnCode.Ok)
{
Type objectType = null;
ResultList errors = null;
code = Value.GetType(interpreter,
arguments[argumentIndex], null, interpreter.GetAppDomain(),
Value.GetTypeValueFlags(strictType, verbose, noCase),
interpreter.CultureInfo, ref objectType, ref errors);
if (code == ReturnCode.Ok)
{
byte[] bytes = null;
code = StringOps.GetBytes(
encoding, arguments[argumentIndex + 1],
EncodingType.Default, ref bytes, ref result);
if (code == ReturnCode.Ok)
{
object @object = null;
code = XmlOps.Deserialize(
objectType, bytes, ref @object, ref result);
if (code == ReturnCode.Ok)
{
ObjectOptionType objectOptionType =
ObjectOptionType.Deserialize |
ObjectOps.GetOptionType(aliasRaw, aliasAll);
code = MarshalOps.FixupReturnValue(
interpreter, interpreter.Binder, interpreter.CultureInfo,
returnType, objectFlags, ObjectOps.GetInvokeOptions(
objectOptionType), objectOptionType, objectName, interpName,
@object, create, dispose, alias, aliasReference, toString,
ref result);
}
}
}
else
{
errors.Insert(0, String.Format(
"type \"{0}\" not found",
arguments[argumentIndex]));
result = errors;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"xml deserialize ?options? type xml\"";
}
code = ReturnCode.Error;
}
}
#else
result = "not implemented";
code = ReturnCode.Error;
#endif
}
else
{
result = "wrong # args: should be \"xml deserialize ?options? type xml\"";
code = ReturnCode.Error;
}
break;
}
case "serialize":
{
if (arguments.Count >= 4)
{
#if SERIALIZATION
OptionDictionary options = ObjectOps.GetSerializeOptions();
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) == arguments.Count))
{
bool noCase = false;
if (options.IsPresent("-nocase"))
{
noCase = true;
}
bool strictType = false;
if (options.IsPresent("-stricttype"))
{
strictType = true;
}
bool verbose = false;
if (options.IsPresent("-verbose"))
{
verbose = true;
}
Variant value = null;
Encoding encoding = null;
if (options.IsPresent("-encoding", ref value))
{
encoding = (Encoding)value.Value;
}
if (code == ReturnCode.Ok)
{
Type objectType = null;
ResultList errors = null;
code = Value.GetType(interpreter,
arguments[argumentIndex], null, interpreter.GetAppDomain(),
Value.GetTypeValueFlags(strictType, verbose, noCase),
interpreter.CultureInfo, ref objectType, ref errors);
if (code == ReturnCode.Ok)
{
IObject @object = null;
code = interpreter.GetObject(
arguments[argumentIndex + 1], LookupFlags.Default,
ref @object, ref result);
if (code == ReturnCode.Ok)
{
byte[] bytes = null;
code = XmlOps.Serialize(
(@object != null) ? @object.Value : null,
objectType, null, ref bytes, ref result);
if (code == ReturnCode.Ok)
{
string stringValue = null;
code = StringOps.GetString(
encoding, bytes, EncodingType.Default,
ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
result = stringValue;
}
}
}
}
else
{
errors.Insert(0, String.Format(
"type \"{0}\" not found",
arguments[argumentIndex]));
result = errors;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"xml serialize ?options? type object\"";
}
code = ReturnCode.Error;
}
}
#else
result = "not implemented";
code = ReturnCode.Error;
#endif
}
else
{
result = "wrong # args: should be \"xml serialize ?options? type object\"";
code = ReturnCode.Error;
}
break;
}
case "validate":
{
if (arguments.Count == 4)
{
XmlDocument document = null;
code = XmlOps.LoadString(
arguments[3], ref document, ref result);
if (code == ReturnCode.Ok)
{
code = XmlOps.Validate(
arguments[2], document, ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
}
else
{
result = "wrong # args: should be \"xml validate schemaXml documentXml\"";
code = ReturnCode.Error;
}
break;
}
default:
{
result = ScriptOps.BadSubCommand(
interpreter, null, null, subCommand, this, null, null);
code = ReturnCode.Error;
break;
}
}
}
}
else
{
result = "wrong # args: should be \"xml option ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IExecute Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 3)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.MustHaveIntegerValue, Index.Invalid, Index.Invalid, "-size", null),
new Option(null, OptionFlags.MustHaveValue | OptionFlags.Unsupported, Index.Invalid, Index.Invalid, "-command", null),
new Option(typeof(EventFlags), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-eventflags",
new Variant(interpreter.EngineEventFlags)),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
if (arguments.Count > 3)
{
code = interpreter.GetOptions(options, arguments, 0, 3, Index.Invalid, true, ref argumentIndex, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
if (argumentIndex == Index.Invalid)
{
Variant value = null;
int size = _Size.Invalid;
if (options.IsPresent("-size", ref value))
{
size = (int)value.Value;
//
// NOTE: All negative values become "invalid",
// which means "read until end-of-file".
//
if (size < 0)
{
size = _Size.Invalid;
}
}
#if MONO_BUILD
#pragma warning disable 219
#endif
string command = null; // NOTE: Flagged by the Mono C# compiler.
#if MONO_BUILD
#pragma warning restore 219
#endif
if (options.IsPresent("-command", ref value))
{
command = value.ToString(); /* NOT YET IMPLEMENTED */
}
EventFlags eventFlags = interpreter.EngineEventFlags;
if (options.IsPresent("-eventflags", ref value))
{
eventFlags = (EventFlags)value.Value;
}
string inputChannelId = arguments[1];
Channel inputChannel = interpreter.GetChannel(inputChannelId, ref result);
if (inputChannel != null)
{
if (inputChannel.CanRead)
{
Encoding inputEncoding = null;
if (interpreter.GetChannelEncoding(inputChannel, ref inputEncoding) == ReturnCode.Ok)
{
string outputChannelId = arguments[2];
Channel outputChannel = interpreter.GetChannel(outputChannelId, ref result);
if (outputChannel != null)
{
if (outputChannel.CanWrite)
{
Encoding outputEncoding = null;
if (interpreter.GetChannelEncoding(outputChannel, ref outputEncoding) == ReturnCode.Ok)
{
try
{
BinaryWriter binaryWriter = null; /* NOTE: Output channel. */
int outputBytes = 0;
//
// NOTE: Reset the end-of-file indicator here because we may
// need to use it to terminate the loop.
//
inputChannel.HitEndOfStream = false;
do
{
if (inputChannel.CanSeek && inputChannel.EndOfStream)
{
break;
}
else if (inputChannel.HitEndOfStream)
{
break;
}
ByteList inputBuffer = null;
int readSize = size;
if ((readSize != _Size.Invalid) && (readSize > MaximumReadSize))
{
readSize = MaximumReadSize;
}
if (readSize == _Size.Invalid)
{
code = inputChannel.Read(null, false, ref inputBuffer, ref result);
}
else
{
code = inputChannel.Read(readSize, null, false, ref inputBuffer, ref result);
}
if (code == ReturnCode.Ok)
{
//
// NOTE: Grab the input byte array from the input
// buffer byte list.
//
byte[] inputArray = inputBuffer.ToArray();
//
// NOTE: Update the total input byte count with the
// number of bytes we just read.
//
if (size != _Size.Invalid)
{
size -= inputArray.Length;
}
if (outputChannel.IsVirtualOutput)
{
//
// NOTE: Virtual output means that we must get
// the text for the input bytes.
//
string stringValue = null;
code = StringOps.GetString(
inputEncoding, inputArray, EncodingType.Binary,
ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
//
// NOTE: The encoding is ignored, because this is
// directly from the input string, which is
// already Unicode.
//
outputChannel.AppendVirtualOutput(stringValue);
//
// NOTE: Update the total output byte count with
// the number of bytes we just wrote.
//
code = StringOps.GetByteCount(
inputEncoding, stringValue, EncodingType.Binary,
ref outputBytes, ref result);
}
}
else
{
if (binaryWriter == null)
{
binaryWriter = interpreter.GetChannelBinaryWriter(
outputChannel);
}
if (binaryWriter != null)
{
//
// NOTE: Convert the input bytes into output
// bytes based on both the input and
// output encodings, if any. If both
// encodings are null, the input bytes
// are used verbatim.
//
byte[] outputArray = null;
code = StringOps.ConvertBytes(
inputEncoding, outputEncoding, EncodingType.Binary,
EncodingType.Binary, inputArray, ref outputArray,
ref result);
if (code == ReturnCode.Ok)
{
//
// NOTE: Ready the output channel for "append"
// mode, if necessary.
//
outputChannel.CheckAppend(); /* throw */
//
// NOTE: Attempt to write the output bytes to
// the output channel.
//
binaryWriter.Write(outputArray); /* throw */
#if MONO || MONO_HACKS
//
// HACK: *MONO* As of Mono 2.8.0, it seems that
// Mono "loses" output unless a flush is
// performed right after a write. So far,
// this has only been observed for the
// console channels; however, always using
// flush here on Mono shouldn't cause too
// many problems, except a slight loss in
// performance.
// https://bugzilla.novell.com/show_bug.cgi?id=645193
//
if (CommonOps.Runtime.IsMono())
{
binaryWriter.Flush(); /* throw */
}
else
#endif
{
//
// NOTE: Check if we should automatically
// flush the channel after each write
// done by this command.
//
/* IGNORED */
outputChannel.CheckAutoFlush();
}
//
// NOTE: Update the total output byte count with
// the number of bytes we just wrote.
//
outputBytes += outputArray.Length;
}
}
else
{
result = String.Format(
"failed to get binary writer for channel \"{0}\"",
outputChannelId);
code = ReturnCode.Error;
}
}
}
//
// NOTE: If any of the above actions failed, bail out of the
// copy loop now.
//
if (code != ReturnCode.Ok)
{
break;
}
//
// NOTE: Are we done reading input bytes? If this value is
// less than zero, it means we read until end-of-file.
// If we have read the specified number of bytes, bail
// out.
//
if (size == 0)
{
break;
}
//
// NOTE: Check for any pending events in the interpreter and
// service them now.
//
code = Engine.CheckEvents(interpreter, eventFlags, ref result);
if (code != ReturnCode.Ok)
{
break;
}
}while (true);
//
// NOTE: Return the number of bytes written to the output
// channel.
//
if (code == ReturnCode.Ok)
{
result = outputBytes;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"failed to get encoding for output channel \"{0}\"",
outputChannelId);
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"channel \"{0}\" wasn't opened for writing",
outputChannelId);
code = ReturnCode.Error;
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"failed to get encoding for input channel \"{0}\"",
inputChannelId);
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"channel \"{0}\" wasn't opened for reading",
inputChannelId);
code = ReturnCode.Error;
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"fcopy input output ?-size size? ?-command callback?\"";
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"fcopy input output ?-size size? ?-command callback?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IExecuteArgument Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Argument value,
ref Result error
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count == (this.Arguments + 1))
{
int intValue = 0;
code = Value.GetInteger2(
(IGetValue)arguments[1], ValueFlags.AnyInteger,
interpreter.CultureInfo, ref intValue, ref error);
if (code == ReturnCode.Ok)
{
if (intValue > 0)
{
try
{
RandomNumberGenerator rng;
lock (interpreter.SyncRoot)
{
rng = interpreter.RandomNumberGenerator;
}
if (rng != null)
{
byte[] bytes = new byte[intValue];
rng.GetBytes(bytes);
string stringValue = null;
code = StringOps.GetString(
null, bytes, EncodingType.Binary,
ref stringValue, ref error);
if (code == ReturnCode.Ok)
{
value = stringValue;
}
}
else
{
error = "random number generator not available";
code = ReturnCode.Error;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
error = String.Format(
"caught math exception: {0}",
e);
code = ReturnCode.Error;
}
}
else
{
error = "number of bytes must be greater than zero";
code = ReturnCode.Error;
}
}
}
else
{
if (arguments.Count > (this.Arguments + 1))
{
error = String.Format(
"too many arguments for math function \"{0}\"",
base.Name);
}
else
{
error = String.Format(
"too few arguments for math function \"{0}\"",
base.Name);
}
code = ReturnCode.Error;
}
}
else
{
error = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
error = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 2)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nonewline", null)
});
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 1, Index.Invalid, false, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) >= arguments.Count))
{
bool newLine = true;
if (options.IsPresent("-nonewline"))
{
newLine = false;
}
int count = Count.Invalid;
if ((argumentIndex + 1) < arguments.Count)
{
code = Value.GetInteger2(
(IGetValue)arguments[argumentIndex + 1], ValueFlags.AnyInteger,
interpreter.CultureInfo, ref count, ref result);
}
if (code == ReturnCode.Ok)
{
string channelId = arguments[argumentIndex];
Channel channel = interpreter.GetChannel(channelId, ref result);
if (channel != null)
{
CharList endOfLine = channel.GetInputEndOfLine();
Encoding encoding = null;
if (interpreter.GetChannelEncoding(channel, ref encoding) == ReturnCode.Ok)
{
//
// NOTE: If they do not specify a count we simply read
// until end-of-file.
//
try
{
ByteList buffer = null;
code = channel.Read(count, null, false, ref buffer, ref result);
if (code == ReturnCode.Ok)
{
//
// BUGFIX: Remove trailing end-of-line character even
// when reading the entire stream.
//
if (!newLine)
{
channel.RemoveTrailingEndOfLine(buffer, endOfLine);
}
string stringValue = null;
code = StringOps.GetString(
encoding, buffer.ToArray(), EncodingType.Binary,
ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
result = stringValue;
}
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"failed to get encoding for channel \"{0}\"",
channelId);
code = ReturnCode.Error;
}
}
else
{
code = ReturnCode.Error;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"read channelId ?numChars?\" or \"read ?-nonewline? channelId\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"read channelId ?numChars?\" or \"read ?-nonewline? channelId\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 2)
{
string subCommand = arguments[1];
bool tried = false;
code = ScriptOps.TryExecuteSubCommandFromEnsemble(
interpreter, this, clientData, arguments, true,
false, ref subCommand, ref tried, ref result);
if ((code == ReturnCode.Ok) && !tried)
{
switch (subCommand)
{
case "convertfrom":
{
if ((arguments.Count == 3) || (arguments.Count == 4))
{
//
// NOTE: (from Tcl encoding.n): Convert data to Unicode from the
// specified encoding. The characters in data are treated
// as binary data where the lower 8-bits of each character
// is taken as a single byte. The resulting sequence of
// bytes is treated as a string in the specified encoding.
// If encoding is not specified, the current system encoding
// is used.
//
int argumentIndex = 2;
Encoding encoding = null;
if (arguments.Count == 4)
{
code = interpreter.GetEncoding(
arguments[argumentIndex++], LookupFlags.Default,
ref encoding, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
string stringValue = null;
code = StringOps.ConvertString(
null, encoding, EncodingType.Binary, EncodingType.System,
arguments[argumentIndex], ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
result = stringValue;
}
}
}
else
{
result = "wrong # args: should be \"encoding convertfrom ?encoding? data\"";
code = ReturnCode.Error;
}
break;
}
case "convertto":
{
if ((arguments.Count == 3) || (arguments.Count == 4))
{
//
// NOTE: (from Tcl encoding.n): Convert string from Unicode to the
// specified encoding. The result is a sequence of bytes that
// represents the converted string. Each byte is stored in the
// lower 8-bits of a Unicode character. If encoding is not
// specified, the current system encoding is used.
//
int argumentIndex = 2;
Encoding encoding = null;
if (arguments.Count == 4)
{
code = interpreter.GetEncoding(
arguments[argumentIndex++], LookupFlags.Default,
ref encoding, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
string stringValue = null;
code = StringOps.ConvertString(
encoding, null, EncodingType.System, EncodingType.Binary,
arguments[argumentIndex], ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
result = stringValue;
}
}
}
else
{
result = "wrong # args: should be \"encoding convertto ?encoding? data\"";
code = ReturnCode.Error;
}
break;
}
case "getstring":
{
if ((arguments.Count == 3) || (arguments.Count == 4))
{
IObject @object = null;
code = interpreter.GetObject(
arguments[2], LookupFlags.Default,
ref @object, ref result);
if (code == ReturnCode.Ok)
{
Encoding encoding = null;
if (arguments.Count == 4)
{
code = interpreter.GetEncoding(
arguments[3], LookupFlags.Default,
ref encoding, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
if (@object.Value is byte[])
{
string stringValue = null;
code = StringOps.GetString(
encoding, (byte[])@object.Value, EncodingType.System,
ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
result = stringValue;
}
}
else
{
result = String.Format(
"object \"{0}\" is not a byte array",
arguments[2]);
code = ReturnCode.Error;
}
}
}
}
else
{
result = "wrong # args: should be \"encoding getstring object ?encoding?\"";
code = ReturnCode.Error;
}
break;
}
case "names":
{
if ((arguments.Count >= 2) && (arguments.Count <= 4))
{
bool system = true; /* COMPAT: Tcl. */
if (arguments.Count >= 3)
{
code = Value.GetBoolean2(
arguments[2], ValueFlags.AnyBoolean,
interpreter.CultureInfo, ref system,
ref result);
}
if (code == ReturnCode.Ok)
{
EncodingDictionary encodings = null;
if (system)
{
StringOps.GetSystemEncodings(ref encodings);
}
interpreter.GetEncodings(ref encodings);
string pattern = null;
if (arguments.Count == 4)
{
pattern = arguments[3];
}
result = encodings.ToString(pattern, false);
}
}
else
{
result = "wrong # args: should be \"encoding names ?system? ?pattern?\"";
code = ReturnCode.Error;
}
break;
}
case "system":
{
//
// NOTE: The system encoding in Eagle is always Unicode and cannot
// be changed.
//
if ((arguments.Count == 2) || (arguments.Count == 3))
{
if (arguments.Count == 3)
{
result = "not implemented";
code = ReturnCode.Error;
}
else
{
result = StringOps.SystemEncodingWebName;
}
}
else
{
result = "wrong # args: should be \"encoding system ?encoding?\"";
code = ReturnCode.Error;
}
break;
}
default:
{
result = ScriptOps.BadSubCommand(
interpreter, null, null, subCommand, this, null, null);
code = ReturnCode.Error;
break;
}
}
}
}
else
{
result = "wrong # args: should be \"encoding option ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
