/////////////////////////////////////////////////////////////////////////////////////////////// public static string GetWindowText( IntPtr handle, ref Result error ) { try { int length = UnsafeNativeMethods.GetWindowTextLength(handle); if (length > 0) { length++; /* NUL terminator */ StringBuilder buffer = StringOps.NewStringBuilder(length); if (UnsafeNativeMethods.GetWindowText( handle, buffer, length) > 0) { return(buffer.ToString()); } } } catch (Exception e) { error = e; } return(null); }
/////////////////////////////////////////////////////////////////////// private static string TranslateSubSpec( Regex regEx, // original regular expression. string pattern, // original pattern string. string input, // original input string. string replacement, // original replacement string. string text, // string with the subSpecs to process. bool quote, // use list element quoting? bool extra, // \P|I|S|M#|N<n> permitted in subSpec. bool strict, // strict conformance to the Tcl docs. Match match // current Regex match, if any. ) { // // NOTE: Garbage in, garbage out. // if (String.IsNullOrEmpty(text)) { return(text); } StringBuilder builder = StringOps.NewStringBuilder(); for (int index = 0; index < text.Length; index++) { char character = text[index]; HandleSubSpecChar( regEx, pattern, input, replacement, text, quote, extra, strict, match, builder, character, ref index); } return(builder.ToString()); }
/////////////////////////////////////////////////////////////////////// private string Flatten() { if (results == null) { return(null); } long capacity = EstimateCapacity(); Result error = null; if (!IsCapacityOk(capacity, MaximumCapacity, ref error)) { throw new ScriptEngineException(error); } StringBuilder builder = StringOps.NewStringBuilder((int)capacity); foreach (Result result in results) { if (result == null) { continue; } builder.Append(result); } return(builder.ToString()); }
/////////////////////////////////////////////////////////////////////// public string ToRawString( string separator ) { StringBuilder result = StringOps.NewStringBuilder(); foreach (IPair <string> element in this) { if (result.Length > 0) { result.Append(separator); } if (element != null) { result.Append(element.X); result.Append(element.Y); } else { result.Append((string)null); result.Append((string)null); } } return(result.ToString()); }
/////////////////////////////////////////////////////////////////////////////////////////////// #region Public Network Server Methods public static ReturnCode GetServerScript( TcpClient client, string channelId, string oldScript, ref string newScript, ref Result error ) { try { if (client != null) { Socket socket = client.Client; if (socket != null) { IPEndPoint endPoint = socket.RemoteEndPoint as IPEndPoint; if (endPoint != null) { StringBuilder builder = StringOps.NewStringBuilder(oldScript); builder.Append(Characters.Space); builder.Append(channelId); builder.Append(Characters.Space); builder.Append(endPoint.Address); builder.Append(Characters.Space); builder.Append(endPoint.Port); newScript = builder.ToString(); return(ReturnCode.Ok); } else { error = "invalid remote endpoint"; } } else { error = "invalid client socket"; } } else { error = "invalid client"; } } catch (Exception e) { error = e; } return(ReturnCode.Error); }
/////////////////////////////////////////////////////////////////////// public string ToRawString() { StringBuilder result = StringOps.NewStringBuilder(); foreach (string element in this) { result.Append(element); } return(result.ToString()); }
/////////////////////////////////////////////////////////////////////////////////////////// #region Private Methods private bool EnumWindowCallback( IntPtr hWnd, IntPtr lParam ) { try { string text = null; int length = UnsafeNativeMethods.GetWindowTextLength(hWnd); if (length > 0) { length++; /* NUL terminator */ buffer = StringOps.NewStringBuilder(buffer, length); if (UnsafeNativeMethods.GetWindowText( hWnd, buffer, length) > 0) { text = buffer.ToString(); } } string @class = null; length = UnsafeNativeMethods.MAX_CLASS_NAME; buffer = StringOps.NewStringBuilder(buffer, length); if (UnsafeNativeMethods.GetClassName( hWnd, buffer, length) > 0) { @class = buffer.ToString(); } windows[hWnd] = new Pair <string>(@class, text); return(true); } catch (Exception e) { if (traceException) { // // NOTE: Nothing much we can do here except log the // failure. // TraceOps.DebugTrace( e, typeof(EnumWindowCallback).Name, TracePriority.NativeError); } } return(false); }
/////////////////////////////////////////////////////////////////////////////////////////////// public static string Concat(IList list, int startIndex, int stopIndex, string separator) { StringBuilder result = StringOps.NewStringBuilder(); if (list != null) { if (CheckStartAndStopIndex( 0, list.Count - 1, ref startIndex, ref stopIndex)) { // // NOTE: This function joins each of its arguments together // with spaces after trimming leading and trailing // white-space from each of them. If all the arguments // are lists, this has the same effect as concatenating // them into a single list. It permits any number of // arguments; if no args are supplied, the result is an // empty string. // for (int index = startIndex; index <= stopIndex; index++) { object element = list[index]; if (element == null) { continue; } string value = element.ToString(); if (String.IsNullOrEmpty(value)) { continue; } value = value.Trim(); if (String.IsNullOrEmpty(value)) { continue; } if (result.Length > 0) { result.Append(separator); } result.Append(value); } } } return(result.ToString()); }
/////////////////////////////////////////////////////////////////////////////////////////////// public static string Format( /* 0.1 */ IDictionary <long, string> flags, bool legacy, bool compact, bool space, bool sort, ref Result error ) { if (flags != null) { StringBuilder result = StringOps.NewStringBuilder(); LongList keys = new LongList(flags.Keys); if (sort) { keys.Sort(); /* NOTE: O(N^2) is the worst case. */ } for (int index = 0; index < keys.Count; index++) { long key = keys[index]; string keyFlags = compact ? (string)DictionaryToChars( CharsToDictionary(flags[key]), sort) : flags[key]; if (key != NoKey) { result.AppendFormat( legacy ? LegacyFlagFormat : FlagFormat, key, keyFlags); } else { result.Append(keyFlags); } if (space && ((index + 1) < keys.Count)) { result.Append(Characters.Space); } } return(result.ToString()); } error = "invalid flags"; return(null); }
/////////////////////////////////////////////////////////////////////// public string ToRawString( string separator ) { StringBuilder result = StringOps.NewStringBuilder(); foreach (string element in this) { if (result.Length > 0) { result.Append(separator); } result.Append(element); } return(result.ToString()); }
/////////////////////////////////////////////////////////////////////////////////////////////// public string ToString( string pattern, bool noCase ) { StringBuilder result = StringOps.NewStringBuilder(); for (int index = 0; index < this.Count; index++) { result.Append(this[index].ToString()); if ((index + 1) < this.Count) { result.Append(Characters.LineFeed); } } return(result.ToString()); }
/////////////////////////////////////////////////////////////////////// public static string ToHexadecimalString( byte[] array ) { if (array == null) { return(null); } StringBuilder result = StringOps.NewStringBuilder(); int length = array.Length; for (int index = 0; index < length; index++) { result.Append(FormatOps.Hexadecimal(array[index], false)); } return(result.ToString()); }
/////////////////////////////////////////////////////////////////////// public string ToRawString( ToStringFlags toStringFlags, string separator ) { StringBuilder result = StringOps.NewStringBuilder(); foreach (Result element in this) { if (element != null) { if ((separator != null) && (result.Length > 0)) { result.Append(separator); } result.Append(element.ToString(toStringFlags)); } } return(result.ToString()); }
/////////////////////////////////////////////////////////////////////// #region Private Static Methods private static StringBuilder NewStringBuilder( int capacity /* in */ ) { return(StringOps.NewStringBuilder(capacity)); }
/////////////////////////////////////////////////////////////////////// public string GetString( bool nested ) { if (items == null) { return(null); } StringBuilder result = StringOps.NewStringBuilder(); foreach (KeyValuePair <long, object> pair in items) { object value = pair.Value; if (value == null) { continue; } /////////////////////////////////////////////////////////////// // // HACK: Add a command separator to the overall result. This // may have issues if literal strings are mixed in with // the actual commands, especially if they contain any // line-ending characters. Right now, this is not done // if the current value happens to be a string instead // of a string list. // if ((result.Length > 0) && !(value is string)) { result.Append(nested ? Characters.SemiColon : Characters.LineFeed); } /////////////////////////////////////////////////////////////// // // NOTE: Always attempt to normalize the block line-endings to // line-feed only, as required by the script engine. // StringBuilder block = StringOps.NewStringBuilder( (value is IScript) ? ((IScript)value).Text : value.ToString()); StringOps.FixupLineEndings(block); /////////////////////////////////////////////////////////////// result.Append(block); } if (nested && (result.Length > 0)) { result.Insert(0, Characters.OpenBracket); result.Append(Characters.CloseBracket); } return(result.ToString()); }
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 varName = arguments[1]; if (arguments.Count == 2) { // // NOTE: *SPECIAL CASE* For compatibility with Tcl, we must generate // an error if only two arguments are supplied and the variable // does not exist. // code = interpreter.GetVariableValue( VariableFlags.DirectGetValueMask, varName, ref result, ref result); } else { lock (interpreter.SyncRoot) /* TRANSACTIONAL */ { StringBuilder builder; if (interpreter.GetVariableValue( VariableFlags.DirectGetValueMask, varName, ref result) == ReturnCode.Ok) { builder = StringOps.GetStringBuilderFromObject(result); } else { builder = StringOps.NewStringBuilder(); } for (int argumentIndex = 2; argumentIndex < arguments.Count; argumentIndex++) { builder.Append(arguments[argumentIndex]); } code = interpreter.SetVariableValue2( VariableFlags.DirectSetValueMask, varName, builder, (TraceList)null, ref result); if (code == ReturnCode.Ok) { result = builder; } } } } else { result = "wrong # args: should be \"append varName ?value ...?\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
/////////////////////////////////////////////////////////////////////////////////////////////// private static ReturnCode Combine( IList <StringBuilder> list1, /* in */ IList <StringBuilder> list2, /* in */ ref IList <StringBuilder> list3, /* in, out */ ref Result error /* out */ ) { if (list1 == null) { if (list2 == null) { error = "cannot combine, neither list is valid"; return(ReturnCode.Error); } if (list3 != null) { GenericOps <StringBuilder> .AddRange(list3, list2); } else { list3 = new List <StringBuilder>(list2); } } else if (list2 == null) { if (list3 != null) { GenericOps <StringBuilder> .AddRange(list3, list1); } else { list3 = new List <StringBuilder>(list1); } } else { if ((list1.Count > 0) || (list2.Count > 0)) { if (list3 == null) { list3 = new List <StringBuilder>(); } } foreach (StringBuilder element1 in list1) { foreach (StringBuilder element2 in list2) { int capacity = 0; if (element1 != null) { capacity += element1.Length; } if (element2 != null) { capacity += element2.Length; } StringBuilder element3 = StringOps.NewStringBuilder( capacity); element3.Append(element1); element3.Append(element2); list3.Add(element3); } } } return(ReturnCode.Ok); }
/////////////////////////////////////////////////////////////////////////////////////////////// #region Public Methods public static IDictionary <long, string> Parse( /* 0.0 */ string text, bool complex, bool space, bool sort, ref Result error ) { if (text == null) { error = "invalid flags"; return(null); } StringBuilder name = StringOps.NewStringBuilder(); StringBuilder value = StringOps.NewStringBuilder(); IDictionary <long, IDictionary <char, long> > perKeyFlags = new Dictionary <long, IDictionary <char, long> >(); bool haveName = false; bool open = false; long nonComplexKey = DefaultKey; long key = nonComplexKey; for (int index = 0; index < text.Length; index++) { char character = text[index]; switch (character) { case Characters.OpenBrace: { if (!complex) { error = String.Format( "unexpected open brace at index {0}, simple-only mode", index); return(null); } if (open) { error = String.Format( "unexpected open brace at index {0}, already open", index); return(null); } // // NOTE: This code cannot be reached. // // if (name.Length > 0) // { // error = String.Format( // "unexpected name at index {0}", // index); // // return null; // } // if (value.Length > 0) { if (!Union(perKeyFlags, value, nonComplexKey, false)) { // // NOTE: This code cannot be reached. // error = String.Format( "union of flags failed at index {0} for key {1}", index, nonComplexKey); return(null); } value.Length = 0; } open = true; break; } case Characters.CloseBrace: { if (!complex) { error = String.Format( "unexpected close brace at index {0}, simple-only mode", index); return(null); } if (!open) { error = String.Format( "unexpected close brace at index {0}, already closed", index); return(null); } if (!haveName) { error = String.Format( "unexpected close brace at index {0}, name incomplete", index); return(null); } if (name.Length == 0) { error = String.Format( "unexpected close brace at index {0}, name missing", index); return(null); } if (!HexadecimalNameToKey(name.ToString(), ref key)) { // // NOTE: This code cannot be reached. // error = String.Format( "invalid name {0}, must be a hexadecimal long integer", FormatOps.WrapOrNull(name)); return(null); } if (!Union(perKeyFlags, value, key, false)) { // // NOTE: This code cannot be reached. // error = String.Format( "union of flags failed at index {0} for key {1}", index, key); return(null); } name.Length = 0; value.Length = 0; haveName = false; open = false; break; } default: { if (haveName || !open) { if (space && Parser.IsWhiteSpace(character)) { continue; } if (!CharIsValidValue(character)) { error = String.Format( "invalid value character '{0}' at index {1}", character, index); return(null); } value.Append(character); } else { if (space && Parser.IsWhiteSpace(character)) { continue; } if (character == NameSepatator) { haveName = true; continue; } if (!CharIsValidName(character)) { error = String.Format( "invalid name character '{0}' at index {1}", character, index); return(null); } name.Append(character); if (name.Length == NameLength) { haveName = true; } } break; } } } if (complex && open) { error = "close brace expected"; return(null); } // // NOTE: This code cannot be reached. // // if (name.Length > 0) // { // error = String.Format( // "unexpected name at index {0}", // text.Length); // // return null; // } // if (value.Length > 0) { if (!Union(perKeyFlags, value, nonComplexKey, false)) { // // NOTE: This code cannot be reached. // error = String.Format( "union of flags failed at index {0} for key {1}", text.Length, nonComplexKey); return(null); } /* value.Length = 0; */ } // // NOTE: Return the merged flags dictionary to the caller, sorted // if necessary. // return(Merge(perKeyFlags, sort)); }
/////////////////////////////////////////////////////////////////////// #if SHELL && INTERACTIVE_COMMANDS public static ReturnCode GetHelp( XmlDocument document, ref string text, ref Result error ) { if (document == null) { error = "invalid xml document"; return(ReturnCode.Error); } try { XmlNamespaceManager namespaceManager = null; if (GetNamespaceManager( document.NameTable, ref namespaceManager, ref error) != ReturnCode.Ok) { return(ReturnCode.Error); } XmlNodeList nodeList = document.SelectNodes( HelpXPath, namespaceManager); if ((nodeList == null) || (nodeList.Count == 0)) { error = "no help nodes found"; return(ReturnCode.Error); } StringBuilder builder = StringOps.NewStringBuilder(); foreach (XmlNode node in nodeList) { if (node == null) { continue; } string nodeText = node.InnerText.Trim(); if (String.IsNullOrEmpty(nodeText)) { continue; } if (builder.Length > 0) { builder.Append(Characters.Space); } builder.Append(nodeText); } if (builder.Length == 0) { error = "no help text found"; return(ReturnCode.Error); } text = builder.ToString(); return(ReturnCode.Ok); } catch (Exception e) { error = e; } return(ReturnCode.Error); }
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 == 5) || (arguments.Count == 6)) { /////////////////////////////////////////////////////////////////////////////////////////////// // // test name description ?constraints? body result // /////////////////////////////////////////////////////////////////////////////////////////////// string name = arguments[1]; #if DEBUGGER if (DebuggerOps.CanHitBreakpoints(interpreter, EngineFlags.None, BreakpointType.Test)) { code = interpreter.CheckBreakpoints( code, BreakpointType.Test, name, null, null, this, null, clientData, arguments, ref result); } if (code == ReturnCode.Ok) #endif { string description = arguments[2]; string constraints; string body; IScriptLocation bodyLocation; string expectedResult; if (arguments.Count == 6) { constraints = arguments[3]; body = arguments[4]; bodyLocation = arguments[4]; expectedResult = arguments[5]; } else { constraints = null; body = arguments[3]; bodyLocation = arguments[3]; expectedResult = arguments[4]; } ReturnCodeList returnCodes = new ReturnCodeList(new ReturnCode[] { ReturnCode.Ok, ReturnCode.Return }); MatchMode mode = StringOps.DefaultResultMatchMode; bool noCase = false; /////////////////////////////////////////////////////////////////////////////////////////////// int testLevels = interpreter.EnterTestLevel(); try { // // NOTE: Create a place to put all the output of the this command. // StringBuilder testData = StringOps.NewStringBuilder(); // // NOTE: Are we going to skip this test? // bool skip = false; bool fail = true; code = TestOps.CheckConstraints( interpreter, testLevels, name, constraints, false, false, testData, ref skip, ref fail, ref result); // // NOTE: Track the fact that we handled this test. // int[] testStatistics = null; if (code == ReturnCode.Ok) { testStatistics = interpreter.TestStatistics; if ((testStatistics != null) && (testLevels == 1) && skip) { Interlocked.Increment(ref testStatistics[ (int)TestInformationType.Total]); } } if ((code == ReturnCode.Ok) && !skip) { code = TestOps.RecordInformation( interpreter, TestInformationType.Counts, name, null, true, ref result); } // // NOTE: Check test constraints to see if we should run the test. // if ((code == ReturnCode.Ok) && !skip) { ReturnCode bodyCode = ReturnCode.Ok; Result bodyResult = null; // // NOTE: Only run the test body if the setup is successful. // if (body != null) { TestOps.AppendFormat( interpreter, testData, TestOutputType.Start, "---- {0} start", name); TestOps.AppendLine( interpreter, testData, TestOutputType.Start); int savedPreviousLevels = interpreter.BeginNestedExecution(); try { ICallFrame frame = interpreter.NewTrackingCallFrame( StringList.MakeList(this.Name, "body", name), CallFrameFlags.Test); interpreter.PushAutomaticCallFrame(frame); try { bodyCode = interpreter.EvaluateScript( body, bodyLocation, ref bodyResult); if ((bodyResult == null) && ScriptOps.HasFlags( interpreter, InterpreterFlags.TestNullIsEmpty, true)) { bodyResult = String.Empty; } if (bodyCode == ReturnCode.Error) { /* IGNORED */ interpreter.CopyErrorInformation( VariableFlags.None, ref bodyResult); } } finally { // // NOTE: Pop the original call frame that we pushed above // and any intervening scope call frames that may be // leftover (i.e. they were not explicitly closed). // /* IGNORED */ interpreter.PopScopeCallFramesAndOneMore(); } } catch (Exception e) { bodyResult = e; bodyCode = ReturnCode.Error; } finally { interpreter.EndNestedExecution(savedPreviousLevels); } } // // NOTE: Did we fail to match the return code? // bool codeFailure = !returnCodes.Contains(bodyCode); // // NOTE: Does the actual result match the expected result? // bool scriptFailure = false; ReturnCode scriptCode = ReturnCode.Ok; Result scriptResult = null; if (!codeFailure) { if (expectedResult != null) { scriptCode = TestOps.Match( interpreter, mode, bodyResult, expectedResult, noCase, null, TestOps.RegExOptions, false, ref scriptFailure, ref scriptResult); if (scriptCode == ReturnCode.Ok) { scriptFailure = !scriptFailure; } else { scriptFailure = true; } } } // // NOTE: If any of the important things failed, the test fails. // if (!(codeFailure || scriptFailure)) { // // PASS: Test ran with no errors and the results match // what we expected. // if ((testStatistics != null) && (testLevels == 1)) { Interlocked.Increment(ref testStatistics[ (int)TestInformationType.Passed]); Interlocked.Increment(ref testStatistics[ (int)TestInformationType.Total]); } TestOps.AppendFormat( interpreter, testData, TestOutputType.Pass, "++++ {0} PASSED", name); TestOps.AppendLine( interpreter, testData, TestOutputType.Pass); } else { // // FAIL: Test ran with errors or the result does not match // what we expected. // if ((testStatistics != null) && (testLevels == 1)) { if (fail) { Interlocked.Increment(ref testStatistics[ (int)TestInformationType.Failed]); Interlocked.Increment(ref testStatistics[ (int)TestInformationType.Total]); } } // // NOTE: Keep track of each test that fails. // if (testLevels == 1) { TestOps.RecordInformation( interpreter, TestInformationType.FailedNames, name, null, true); } TestOps.AppendLine( interpreter, testData, TestOutputType.Fail); TestOps.AppendFormat( interpreter, testData, TestOutputType.Fail, "==== {0} {1} {2}", name, description.Trim(), fail ? "FAILED" : "IGNORED"); TestOps.AppendLine( interpreter, testData, TestOutputType.Fail); if (body != null) { TestOps.AppendLine( interpreter, testData, TestOutputType.Body, "==== Contents of test case:"); TestOps.AppendLine( interpreter, testData, TestOutputType.Body, body); } if (scriptFailure) { if (scriptCode == ReturnCode.Ok) { TestOps.AppendLine( interpreter, testData, TestOutputType.Reason, "---- Result was:"); TestOps.AppendLine( interpreter, testData, TestOutputType.Reason, bodyResult); TestOps.AppendFormat( interpreter, testData, TestOutputType.Reason, "---- Result should have been ({0} matching):", mode); TestOps.AppendLine( interpreter, testData, TestOutputType.Reason); TestOps.AppendLine( interpreter, testData, TestOutputType.Reason, expectedResult); } else { TestOps.Append( interpreter, testData, TestOutputType.Reason, "---- Error testing result: "); TestOps.AppendLine( interpreter, testData, TestOutputType.Reason, scriptResult); if ((scriptResult != null) && (scriptResult.ErrorInfo != null)) { TestOps.Append( interpreter, testData, TestOutputType.Error, "---- errorInfo(matchResult): "); TestOps.AppendLine( interpreter, testData, TestOutputType.Error, scriptResult.ErrorInfo); TestOps.Append( interpreter, testData, TestOutputType.Error, "---- errorCode(matchResult): "); TestOps.AppendLine( interpreter, testData, TestOutputType.Error, scriptResult.ErrorCode); } } } if (codeFailure) { ReturnCodeDictionary returnCodeMessages = interpreter.TestReturnCodeMessages; string codeMessage; if ((returnCodeMessages == null) || (!returnCodeMessages.TryGetValue( bodyCode, out codeMessage) && !returnCodeMessages.TryGetValue( ReturnCode.Invalid, out codeMessage))) { codeMessage = "Unknown"; } TestOps.AppendFormat( interpreter, testData, TestOutputType.Reason, "---- {0}; Return code was: {1}", codeMessage, bodyCode); TestOps.AppendLine( interpreter, testData, TestOutputType.Reason); TestOps.Append( interpreter, testData, TestOutputType.Reason, "---- Return code should have been one of: "); TestOps.AppendLine( interpreter, testData, TestOutputType.Reason, returnCodes.ToString()); if ((bodyResult != null) && (bodyResult.ErrorInfo != null) && !returnCodes.Contains(ReturnCode.Error)) { TestOps.Append( interpreter, testData, TestOutputType.Error, "---- errorInfo(body): "); TestOps.AppendLine( interpreter, testData, TestOutputType.Error, bodyResult.ErrorInfo); TestOps.Append( interpreter, testData, TestOutputType.Error, "---- errorCode(body): "); TestOps.AppendLine( interpreter, testData, TestOutputType.Error, bodyResult.ErrorCode); } } TestOps.AppendFormat( interpreter, testData, TestOutputType.Fail, "==== {0} {1}", name, fail ? "FAILED" : "IGNORED"); TestOps.AppendLine( interpreter, testData, TestOutputType.Fail); } } // // NOTE: Did the above code succeed? // if (code == ReturnCode.Ok) { // // NOTE: The result is the complete output produced by the // entire test. // if (testData != null) { result = testData; } else { result = String.Empty; } } } catch (Exception e) { Engine.SetExceptionErrorCode(interpreter, e); result = e; code = ReturnCode.Error; } finally { interpreter.ExitTestLevel(); } } } else { result = String.Format( "wrong # args: should be \"{0} name description constraints body result\"", this.Name); code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }