///////////////////////////////////////////////////////////////////////
private /* protected virtual */ void Dispose(
bool disposing
)
{
TraceOps.DebugTrace(String.Format(
"Dispose: disposing = {0}, interpreter = {1}, disposed = {2}",
disposing, FormatOps.InterpreterNoThrow(interpreter), disposed),
typeof(VariableContext).Name, TracePriority.CleanupDebug);
if (!disposed)
{
if (disposing)
{
////////////////////////////////////
// dispose managed resources here...
////////////////////////////////////
Free(true);
}
//////////////////////////////////////
// release unmanaged resources here...
//////////////////////////////////////
disposed = true;
}
}
///////////////////////////////////////////////////////////////////////
private /* protected virtual */ void Dispose(
bool disposing
)
{
TraceOps.DebugTrace(String.Format(
"Dispose: disposing = {0}, interpreter = {1}, disposed = {2}",
disposing, FormatOps.InterpreterNoThrow(interpreter), disposed),
typeof(InteractiveContext).Name, TracePriority.CleanupDebug);
if (!disposed)
{
if (disposing)
{
////////////////////////////////////
// dispose managed resources here...
////////////////////////////////////
interpreter = null; /* NOT OWNED: Do not dispose. */
threadId = 0;
///////////////////////////////////////////////////////////
interactive = false;
interactiveInput = null;
previousInteractiveInput = null;
interactiveMode = null;
activeInteractiveLoops = 0;
totalInteractiveLoops = 0;
interactiveLoopData = null;
interactiveCommandCallback = null;
#if HISTORY
historyLoadData = null;
historySaveData = null;
historyInfoFilter = null;
historyLoadFilter = null;
historySaveFilter = null;
historyFileName = null;
#endif
}
//////////////////////////////////////
// release unmanaged resources here...
//////////////////////////////////////
disposed = true;
}
}
///////////////////////////////////////////////////////////////////////
private static void DumpSetup(
Interpreter interpreter,
string friendlyName,
string baseDirectory,
string packagePath,
bool useBasePath,
AppDomainSetup appDomainSetup
)
{
StringPairList list = new StringPairList();
AddInfo(appDomainSetup, list, DetailFlags.DebugTrace);
TraceOps.DebugTrace(String.Format(
"DumpSetup: interpreter = {0}, friendlyName = {1}, " +
"baseDirectory = {2}, packagePath = {3}, " +
"useBasePath = {4}, appDomainSetup = {5}",
FormatOps.InterpreterNoThrow(interpreter),
FormatOps.WrapOrNull(friendlyName),
FormatOps.WrapOrNull(baseDirectory),
FormatOps.WrapOrNull(packagePath),
useBasePath, list), typeof(AppDomainOps).Name,
TracePriority.SecurityDebug);
}
///////////////////////////////////////////////////////////////////////
private /* protected virtual */ void Dispose(
bool disposing
)
{
TraceOps.DebugTrace(String.Format(
"Dispose: disposing = {0}, interpreter = {1}, disposed = {2}",
disposing, FormatOps.InterpreterNoThrow(interpreter), disposed),
typeof(TestContext).Name, TracePriority.CleanupDebug);
if (!disposed)
{
if (disposing)
{
////////////////////////////////////
// dispose managed resources here...
////////////////////////////////////
interpreter = null; /* NOT OWNED: Do not dispose. */
threadId = 0;
///////////////////////////////////////////////////////////
targetInterpreter = null; /* NOT OWNED: Do not dispose. */
///////////////////////////////////////////////////////////
statistics = null;
///////////////////////////////////////////////////////////
if (constraints != null)
{
constraints.Clear();
constraints = null;
}
///////////////////////////////////////////////////////////
if (failures != null)
{
failures.Clear();
failures = null;
}
///////////////////////////////////////////////////////////
if (counts != null)
{
counts.Clear();
counts = null;
}
///////////////////////////////////////////////////////////
if (match != null)
{
match.Clear();
match = null;
}
///////////////////////////////////////////////////////////
if (skip != null)
{
skip.Clear();
skip = null;
}
///////////////////////////////////////////////////////////
if (returnCodeMessages != null)
{
returnCodeMessages.Clear();
returnCodeMessages = null;
}
///////////////////////////////////////////////////////////
#if DEBUGGER
if (breakpoints != null)
{
breakpoints.Clear();
breakpoints = null;
}
#endif
///////////////////////////////////////////////////////////
path = null;
verbose = TestOutputType.None;
repeatCount = 0;
}
//////////////////////////////////////
// release unmanaged resources here...
//////////////////////////////////////
disposed = true;
}
}
///////////////////////////////////////////////////////////////////////
#if APPDOMAINS || ISOLATED_INTERPRETERS || ISOLATED_PLUGINS
private static string GetBasePath(
Interpreter interpreter, /* OPTIONAL */
string packagePath,
ref Result error
)
{
//
// NOTE: Fetch the raw base directory for the currently executing
// application binary. It is now possible to override the
// value used here via the environment.
//
string path0 = AssemblyOps.GetAnchorPath();
if (path0 == null)
{
path0 = GlobalState.GetRawBinaryBasePath();
}
//
// NOTE: First, try to use the effective path to the core library
// assembly. This is used to verify that this candidate
// application domain base path contains the core library
// assembly somewhere underneath it.
//
string path1 = GetAssemblyPath();
if (PathOps.IsUnderPath(interpreter, path1, path0))
{
if ((packagePath == null) ||
PathOps.IsUnderPath(interpreter, packagePath, path0))
{
return(path0);
}
}
//
// NOTE: Second, try to use the raw base path for the assembly.
// This is used to verify that this candidate application
// domain base path contains the core library assembly
// somewhere underneath it.
//
string path2 = GlobalState.GetRawBasePath();
if (PathOps.IsUnderPath(interpreter, path1, path2))
{
if ((packagePath == null) ||
PathOps.IsUnderPath(interpreter, packagePath, path2))
{
return(path2);
}
}
//
// NOTE: At this point, we have failed to figure out a base path
// for the application domain to be created that actually
// contains the core library assembly.
//
error = String.Format(
"cannot determine usable base path for the new application " +
"domain for interpreter {0}, with the raw binary base path " +
"{1}, assembly path {2}, and raw base path {3}",
FormatOps.InterpreterNoThrow(interpreter),
FormatOps.DisplayPath(path0), FormatOps.DisplayPath(path1),
FormatOps.DisplayPath(path2));
return(null);
}
///////////////////////////////////////////////////////////////////////
public void Free(
bool global
)
{
TraceOps.DebugTrace(String.Format(
"Free: called, global = {0}, interpreter = {1}, disposed = {2}",
global, FormatOps.InterpreterNoThrow(interpreter), disposed),
typeof(VariableContext).Name, TracePriority.CleanupDebug);
///////////////////////////////////////////////////////////////////
interpreter = null; /* NOT OWNED: Do not dispose. */
threadId = 0;
///////////////////////////////////////////////////////////////////
if (traceInfo != null)
{
traceInfo = null;
}
///////////////////////////////////////////////////////////////////
//
// HACK: *SPECIAL CASE* We cannot dispose the current call stack
// unless we are [also] disposing of the interpreter itself;
// therefore, use the special Free method here instead of the
// Dispose method. The Free method is guaranteed to do the
// right thing with regard to the global call frame (assuming
// the "global" paramter is correct).
//
if (callStack != null)
{
callStack.Free(global);
callStack = null;
}
///////////////////////////////////////////////////////////////////
//
// HACK: *SPECIAL CASE* We cannot dispose the uplevel call frame
// unless we are [also] disposing of the interpreter itself.
//
if (uplevelFrame != null)
{
uplevelFrame.Free(global);
uplevelFrame = null;
}
///////////////////////////////////////////////////////////////////
//
// HACK: *SPECIAL CASE* We cannot dispose the procedure call frame
// unless we are [also] disposing of the interpreter itself.
//
if (procedureFrame != null)
{
procedureFrame.Free(global);
procedureFrame = null;
}
///////////////////////////////////////////////////////////////////
//
// HACK: *SPECIAL CASE* We cannot dispose the current call frame
// unless we are [also] disposing of the interpreter itself.
//
if (currentFrame != null)
{
currentFrame.Free(global);
currentFrame = null;
}
///////////////////////////////////////////////////////////////////
//
// HACK: *SPECIAL CASE* We cannot dispose the uplevel call frame
// unless we are [also] disposing of the interpreter itself.
// If this is really a named scope call frame -AND- we are
// being disposed, it should have already been cleaned up by
// this point; therefore, this should be a no-op.
//
if (globalScopeFrame != null)
{
globalScopeFrame.Free(global);
globalScopeFrame = null;
}
///////////////////////////////////////////////////////////////////
//
// HACK: *SPECIAL CASE* We cannot dispose the global call frame
// unless we are [also] disposing of the interpreter itself.
//
if (globalFrame != null)
{
globalFrame.Free(global);
globalFrame = null;
}
}
///////////////////////////////////////////////////////////////////////
private /* protected virtual */ void Dispose(
bool disposing
)
{
TraceOps.DebugTrace(String.Format(
"Dispose: disposing = {0}, interpreter = {1}, disposed = {2}",
disposing, FormatOps.InterpreterNoThrow(interpreter), disposed),
typeof(EngineContext).Name, TracePriority.CleanupDebug);
if (!disposed)
{
if (disposing)
{
////////////////////////////////////
// dispose managed resources here...
////////////////////////////////////
interpreter = null; /* NOT OWNED: Do not dispose. */
threadId = 0;
///////////////////////////////////////////////////////////
#if DEBUGGER
interactiveLoopCallback = null;
#endif
///////////////////////////////////////////////////////////
#if SHELL
argumentCallback = null;
evaluateScriptCallback = null;
evaluateFileCallback = null;
evaluateEncodedFileCallback = null;
#endif
///////////////////////////////////////////////////////////
levels = 0;
maximumLevels = 0;
scriptLevels = 0;
maximumScriptLevels = 0;
parserLevels = 0;
maximumParserLevels = 0;
expressionLevels = 0;
maximumExpressionLevels = 0;
previousLevels = 0;
catchLevels = 0;
unknownLevels = 0;
traceLevels = 0;
subCommandLevels = 0;
#if ARGUMENT_CACHE
cacheArgument = null;
#endif
#if DEBUGGER
watchpointLevels = 0;
#endif
#if NOTIFY || NOTIFY_OBJECT
notifyLevels = 0;
notifyTypes = NotifyType.None;
notifyFlags = NotifyFlags.None;
#endif
policyLevels = 0;
testLevels = 0;
#if DEBUGGER
isDebuggerExiting = false;
#endif
stackOverflow = false;
#if DEBUGGER
if (debugger != null)
{
IDisposable disposable = debugger as IDisposable;
if (disposable != null)
{
disposable.Dispose();
disposable = null;
}
debugger = null;
}
#endif
#if PREVIOUS_RESULT
previousResult = null;
#endif
engineFlags = EngineFlags.None;
parseState = null;
returnCode = ReturnCode.Ok;
errorLine = 0;
errorCode = null;
errorInfo = null;
errorFrames = 0;
exception = null;
scriptLocation = null;
///////////////////////////////////////////////////////////
if (scriptLocations != null)
{
scriptLocations.Clear();
scriptLocations = null;
}
///////////////////////////////////////////////////////////
previousProcessId = 0;
///////////////////////////////////////////////////////////
if (arraySearches != null)
{
arraySearches.Clear();
arraySearches = null;
}
///////////////////////////////////////////////////////////
#if HISTORY
historyEngineFilter = null;
if (history != null)
{
history.Clear();
history = null;
}
#endif
///////////////////////////////////////////////////////////
complaint = null;
}
//////////////////////////////////////
// release unmanaged resources here...
//////////////////////////////////////
disposed = true;
}
}
///////////////////////////////////////////////////////////////////////
public static ReturnCode UploadDataAsync(
Interpreter interpreter,
IClientData clientData,
StringList arguments,
CallbackFlags callbackFlags,
Uri uri,
string method,
byte[] rawData,
ref Result error
)
{
TraceOps.DebugTrace(String.Format(
"UploadDataAsync: interpreter = {0}, clientData = {1}, " +
"arguments = {2}, callbackFlags = {3}, uri = {4}, " +
"method = {5}, rawData = {6}",
FormatOps.InterpreterNoThrow(interpreter),
FormatOps.WrapOrNull(clientData),
FormatOps.WrapOrNull(true, true, arguments),
FormatOps.WrapOrNull(callbackFlags),
FormatOps.WrapOrNull(uri),
FormatOps.WrapOrNull(method),
FormatOps.WrapOrNull(rawData)),
typeof(WebOps).Name, TracePriority.NetworkDebug);
ReturnCode code = ReturnCode.Ok;
WebClient webClient = null;
try
{
ICallback callback = CommandCallback.Create(
MarshalFlags.Default, callbackFlags,
ObjectFlags.Callback, ByRefArgumentFlags.None,
interpreter, null, null, arguments, ref error);
if (callback != null)
{
try
{
Result localError = null;
webClient = CreateClient(
interpreter, "UploadDataAsync", clientData,
ref localError);
if (webClient != null)
{
callback.ClientData = new ClientData(
new AnyTriplet <WebClient, Uri,
IAnyPair <string, byte[]> >(
webClient, uri, new AnyPair <string,
byte[]>(method, rawData)));
webClient.UploadDataCompleted +=
new UploadDataCompletedEventHandler(
UploadDataAsyncCompleted);
/* NO RESULT */
webClient.UploadDataAsync(
uri, method, rawData, callback);
}
else if (localError != null)
{
error = localError;
code = ReturnCode.Error;
}
else
{
error = "could not create web client";
code = ReturnCode.Error;
}
}
catch (Exception e)
{
error = e;
code = ReturnCode.Error;
}
}
else
{
code = ReturnCode.Error;
}
}
finally
{
if ((code != ReturnCode.Ok) && (webClient != null))
{
ReturnCode disposeCode;
Result disposeError = null;
disposeCode = ObjectOps.TryDispose(
webClient, ref disposeError);
if (disposeCode != ReturnCode.Ok)
{
DebugOps.Complain(
interpreter, disposeCode, disposeError);
}
}
}
return(code);
}
///////////////////////////////////////////////////////////////////////
#region Public Web Upload Methods
#region Upload Data Methods
public static ReturnCode UploadData(
Interpreter interpreter,
IClientData clientData,
Uri uri,
string method,
byte[] rawData,
bool trusted,
ref byte[] bytes,
ref Result error
)
{
bool wasTrusted = UpdateOps.IsTrusted();
TraceOps.DebugTrace(String.Format(
"UploadData: interpreter = {0}, clientData = {1}, " +
"uri = {2}, method = {3}, rawData = {4}, trusted = {5}, " +
"wasTrusted = {6}",
FormatOps.InterpreterNoThrow(interpreter),
FormatOps.WrapOrNull(clientData),
FormatOps.WrapOrNull(uri),
FormatOps.WrapOrNull(method),
FormatOps.WrapOrNull(rawData),
trusted, wasTrusted),
typeof(WebOps).Name, TracePriority.NetworkDebug);
ReturnCode code = trusted ? wasTrusted ? ReturnCode.Ok :
UpdateOps.SetTrusted(trusted, ref error) : ReturnCode.Ok;
if (code == ReturnCode.Ok)
{
try
{
try
{
Result localError = null;
using (WebClient webClient = CreateClient(
interpreter, "UploadData", clientData,
ref localError))
{
if (webClient != null)
{
bytes = webClient.UploadData(
uri, method, rawData);
return(ReturnCode.Ok);
}
else if (localError != null)
{
error = localError;
}
else
{
error = "could not create web client";
}
}
}
catch (Exception e)
{
error = e;
}
}
finally
{
if (trusted && !wasTrusted)
{
ReturnCode untrustCode;
Result untrustError = null;
untrustCode = UpdateOps.SetTrusted(
false, ref untrustError);
if (untrustCode != ReturnCode.Ok)
{
DebugOps.Complain(
interpreter, untrustCode, untrustError);
}
}
}
}
return(ReturnCode.Error);
}