/// <summary>
/// Compares the memory context to each context in the given array in the manner indicated by compare flags, returning an index of the first context that matches.
/// </summary>
/// <param name="Compare">A value from the CONTEXT_COMPARE enumeration that determines the type of comparison.</param>
/// <param name="rgpMemoryContextSet">An array of references to the IDebugMemoryContext2 objects to compare against.</param>
/// <param name="dwMemoryContextSetLen">The number of contexts in the rgpMemoryContextSet array.</param>
/// <param name="pdwMemoryContext">Returns the index of the first memory context that satisfies the comparison.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code. Returns E_COMPARE_CANNOT_COMPARE if the two contexts cannot be compared.</returns>
/// <remarks>A debug engine (DE) does not have to support all types of comparisons, but it must support at least CONTEXT_EQUAL, CONTEXT_LESS_THAN, CONTEXT_GREATER_THAN and CONTEXT_SAME_SCOPE.</remarks>
public virtual int Compare( enum_CONTEXT_COMPARE Compare,
IDebugMemoryContext2[] rgpMemoryContextSet,
uint dwMemoryContextSetLen,
out uint pdwMemoryContext)
{
Logger.Debug( string.Empty );
pdwMemoryContext = 0;
return VSConstants.E_NOTIMPL;
}
/// <summary>
/// Compares the memory context to each context in the given array in the manner indicated by compare flags, returning an index of the first context that matches.
/// </summary>
/// <param name="Compare">A value from the CONTEXT_COMPARE enumeration that determines the type of comparison.</param>
/// <param name="rgpMemoryContextSet">An array of references to the IDebugMemoryContext2 objects to compare against.</param>
/// <param name="dwMemoryContextSetLen">The number of contexts in the rgpMemoryContextSet array.</param>
/// <param name="pdwMemoryContext">Returns the index of the first memory context that satisfies the comparison.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code. Returns E_COMPARE_CANNOT_COMPARE if the two contexts cannot be compared.</returns>
/// <remarks>A debug engine (DE) does not have to support all types of comparisons, but it must support at least CONTEXT_EQUAL, CONTEXT_LESS_THAN, CONTEXT_GREATER_THAN and CONTEXT_SAME_SCOPE.</remarks>
public virtual int Compare(enum_CONTEXT_COMPARE Compare,
IDebugMemoryContext2[] rgpMemoryContextSet,
uint dwMemoryContextSetLen,
out uint pdwMemoryContext)
{
Logger.Debug(string.Empty);
pdwMemoryContext = 0;
return(VSConstants.E_NOTIMPL);
}
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
for(int i = 0; i < dwMemoryContextSetLen; ++i)
{
pdwMemoryContext = (uint)i;
var other = rgpMemoryContextSet[i] as DebugCodeContext;
if (other == null)
return HResults.E_COMPARE_CANNOT_COMPARE;
var isSameMethod = Equals(Location.Class, other.Location.Class) && Equals(Location.Method, other.Location.Method);
switch (Compare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
if (location.Equals(other.Location))
return VSConstants.S_OK;
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
if (!isSameMethod) return HResults.E_COMPARE_CANNOT_COMPARE;
if(Location.CompareTo(other.Location) > 0)
return VSConstants.S_OK;
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
if (!isSameMethod) return HResults.E_COMPARE_CANNOT_COMPARE;
if (Location.CompareTo(other.Location) >= 0)
return VSConstants.S_OK;
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
if (!isSameMethod) return HResults.E_COMPARE_CANNOT_COMPARE;
if (Location.CompareTo(other.Location) < 0)
return VSConstants.S_OK;
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
if (!isSameMethod) return HResults.E_COMPARE_CANNOT_COMPARE;
if (Location.CompareTo(other.Location) <= 0)
return VSConstants.S_OK;
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
return VSConstants.S_OK;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
if(isSameMethod)
return VSConstants.S_OK;
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
// TODO: analyze scopes.
if(isSameMethod)
return VSConstants.S_OK;
break;
}
}
pdwMemoryContext = (uint)0;
return VSConstants.S_FALSE;
}
int IDebugMemoryContext2.Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext) {
pdwMemoryContext = 0;
for (int i = 0; i < rgpMemoryContextSet.Length; ++i) {
var other = rgpMemoryContextSet[i] as AD7MemoryAddress;
if (other == null || other.Engine != Engine) {
continue;
}
bool match = false;
switch (Compare) {
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
match = (LineNumber == other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
match = (LineNumber < other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
match = (LineNumber <= other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
match = (LineNumber > other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
match = (LineNumber >= other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
match = true;
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
match = (FileName == other.FileName);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
match = (LineNumber == other.LineNumber && FileName == other.FileName);
break;
default:
return VSConstants.E_NOTIMPL;
}
if (match) {
pdwMemoryContext = (uint)i;
return VSConstants.S_OK;
}
}
return VSConstants.S_FALSE;
}
public int /*IDebugCodeContext2*/ Compare(
enum_CONTEXT_COMPARE Compare,
IDebugMemoryContext2[] rgpMemoryContextSet,
uint dwMemoryContextSetLen,
out uint pdwMemoryContext)
{
pdwMemoryContext = uint.MaxValue;
if (Compare != enum_CONTEXT_COMPARE.CONTEXT_EQUAL)
{
return(VSConstants.E_NOTIMPL);
}
for (uint i = 0; i < dwMemoryContextSetLen; ++i)
{
var that = rgpMemoryContextSet[i] as CodeContext;
if (that == null)
{
continue;
}
if (this.Engine != that.Engine)
{
continue;
}
if (this.Program != that.Program)
{
continue;
}
if (!string.Equals(
Path.GetFullPath(this.FilePath), Path.GetFullPath(that.FilePath),
StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (this.FileLine != that.FileLine)
{
continue;
}
pdwMemoryContext = i;
return(VSConstants.S_OK);
}
return(VSConstants.S_FALSE);
}
/// <summary>
/// Compares the memory context to each context in the given array in the manner indicated by compare flags, returning an index of the first context that matches.
/// </summary>
/// <param name="Compare">[in] A value from the CONTEXT_COMPARE enumeration that determines the type of comparison.</param>
/// <param name="rgpMemoryContextSet">[in] An array of references to the IDebugMemoryContext2 objects to compare against.</param>
/// <param name="dwMemoryContextSetLen">[in] The number of contexts in the rgpMemoryContextSet array.</param>
/// <param name="pdwMemoryContext">[out] Returns the index of the first memory context that satisfies the comparison.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code. Returns E_COMPARE_CANNOT_COMPARE if the two contexts cannot be compared.</returns>
/// <remarks>
/// A debug engine (DE) does not have to support all types of comparisons, but it must support at least CONTEXT_EQUAL, CONTEXT_LESS_THAN, CONTEXT_GREATER_THAN and CONTEXT_SAME_SCOPE.
/// </remarks>
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
if (rgpMemoryContextSet == null)
throw new ArgumentNullException("rgpMemoryContextSet");
if (rgpMemoryContextSet.Length < dwMemoryContextSetLen)
throw new ArgumentException();
pdwMemoryContext = 0;
bool relational = false;
switch (Compare)
{
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
relational = true;
break;
}
JavaDebugCodeContext[] contexts = new JavaDebugCodeContext[dwMemoryContextSetLen];
for (int i = 0; i < contexts.Length; i++)
{
if (rgpMemoryContextSet[i] == null)
return VSConstants.E_INVALIDARG;
contexts[i] = rgpMemoryContextSet[i] as JavaDebugCodeContext;
if (contexts[i] == null)
return AD7Constants.E_COMPARE_CANNOT_COMPARE;
// relational tests only work if the contexts are in the same scope
if (relational && !this.Location.GetMethod().Equals(contexts[i].Location.GetMethod()))
return AD7Constants.E_COMPARE_CANNOT_COMPARE;
}
int index;
switch (Compare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
index = Array.FindIndex(contexts, i => this.Location.Equals(i.Location));
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() > this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() >= this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() < this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() <= this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
index = Array.FindIndex(contexts, i => this.Location.GetMethod().Equals(i.Location.GetMethod()));
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
throw new NotImplementedException();
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
index = Array.FindIndex(contexts, i => this.Program.Process == i.Program.Process);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
index = Array.FindIndex(contexts, i => this.Location.GetMethod().Equals(i.Location.GetMethod()));
break;
default:
throw new ArgumentException();
}
if (index < 0)
{
return VSConstants.E_FAIL;
}
pdwMemoryContext = (uint)index;
return VSConstants.S_OK;
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE uContextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
enum_CONTEXT_COMPARE contextCompare = uContextCompare;
for (uint c = 0; c < compareToLength; c++)
{
var compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null)
{
continue;
}
if (!ReferenceEquals(_engine, compareTo._engine))
{
continue;
}
bool result;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = _line == compareTo._line;
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = _line < compareTo._line;
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = _line > compareTo._line;
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = _line <= compareTo._line;
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = _line >= compareTo._line;
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
if (_frame != null)
{
result = compareTo.FileName == FileName && compareTo._line >= _frame.StartLine && compareTo._line <= _frame.EndLine;
}
else if (compareTo._frame != null)
{
result = compareTo.FileName == FileName && _line >= compareTo._frame.StartLine && compareTo._line <= compareTo._frame.EndLine;
}
else
{
result = _line == compareTo._line && FileName == compareTo.FileName;
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = FileName == compareTo.FileName;
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return(VSConstants.E_NOTIMPL);
}
if (result)
{
foundIndex = c;
return(VSConstants.S_OK);
}
}
return(VSConstants.S_FALSE);
}
int IDebugCodeContext2.Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext) {
return IDebugMemoryContext2.Compare(Compare, rgpMemoryContextSet, dwMemoryContextSetLen, out pdwMemoryContext);
}
/// <summary>
/// Compares the memory context to each context in the given array in the manner indicated by compare flags, returning an index of the first context that matches.
/// </summary>
/// <param name="Compare">[in] A value from the CONTEXT_COMPARE enumeration that determines the type of comparison.</param>
/// <param name="rgpMemoryContextSet">[in] An array of references to the IDebugMemoryContext2 objects to compare against.</param>
/// <param name="dwMemoryContextSetLen">[in] The number of contexts in the rgpMemoryContextSet array.</param>
/// <param name="pdwMemoryContext">[out] Returns the index of the first memory context that satisfies the comparison.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code. Returns E_COMPARE_CANNOT_COMPARE if the two contexts cannot be compared.</returns>
/// <remarks>
/// A debug engine (DE) does not have to support all types of comparisons, but it must support at least CONTEXT_EQUAL, CONTEXT_LESS_THAN, CONTEXT_GREATER_THAN and CONTEXT_SAME_SCOPE.
/// </remarks>
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
if (rgpMemoryContextSet == null)
{
throw new ArgumentNullException("rgpMemoryContextSet");
}
if (rgpMemoryContextSet.Length < dwMemoryContextSetLen)
{
throw new ArgumentException();
}
pdwMemoryContext = 0;
bool relational = false;
switch (Compare)
{
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
relational = true;
break;
}
JavaDebugCodeContext[] contexts = new JavaDebugCodeContext[dwMemoryContextSetLen];
for (int i = 0; i < contexts.Length; i++)
{
if (rgpMemoryContextSet[i] == null)
{
return(VSConstants.E_INVALIDARG);
}
contexts[i] = rgpMemoryContextSet[i] as JavaDebugCodeContext;
if (contexts[i] == null)
{
return(AD7Constants.E_COMPARE_CANNOT_COMPARE);
}
// relational tests only work if the contexts are in the same scope
if (relational && !this.Location.GetMethod().Equals(contexts[i].Location.GetMethod()))
{
return(AD7Constants.E_COMPARE_CANNOT_COMPARE);
}
}
int index;
switch (Compare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
index = Array.FindIndex(contexts, i => this.Location.Equals(i.Location));
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() > this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() >= this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() < this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
index = Array.FindIndex(contexts, i => i.Location.GetCodeIndex() <= this.Location.GetCodeIndex());
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
index = Array.FindIndex(contexts, i => this.Location.GetMethod().Equals(i.Location.GetMethod()));
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
throw new NotImplementedException();
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
index = Array.FindIndex(contexts, i => this.Program.Process == i.Program.Process);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
index = Array.FindIndex(contexts, i => this.Location.GetMethod().Equals(i.Location.GetMethod()));
break;
default:
throw new ArgumentException();
}
if (index < 0)
{
return(VSConstants.E_FAIL);
}
pdwMemoryContext = (uint)index;
return(VSConstants.S_OK);
}
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet,
uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
throw new NotImplementedException();
}
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
Log.Debug("ScriptDocumentContext: IDebugCodeContext2.Compare");
pdwMemoryContext = 0;
return VSConstants.E_NOTIMPL;
}
int IDebugMemoryContext2.Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
Debug.WriteLine("AD7DocumentContext: Compare");
throw new NotImplementedException();
}
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
pdwMemoryContext = 0;
return(VSConstants.E_NOTIMPL);
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE uContextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex) {
foundIndex = uint.MaxValue;
enum_CONTEXT_COMPARE contextCompare = (enum_CONTEXT_COMPARE)uContextCompare;
for (uint c = 0; c < compareToLength; c++) {
AD7MemoryAddress compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null) {
continue;
}
if (!AD7Engine.ReferenceEquals(this._engine, compareTo._engine)) {
continue;
}
bool result;
switch (contextCompare) {
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (this._lineNo == compareTo._lineNo);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (this._lineNo < compareTo._lineNo);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (this._lineNo > compareTo._lineNo);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (this._lineNo <= compareTo._lineNo);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (this._lineNo >= compareTo._lineNo);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
if (_frame != null) {
result = compareTo._filename == _filename && (compareTo._lineNo + 1) >= _frame.StartLine && (compareTo._lineNo + 1) <= _frame.EndLine;
} else if (compareTo._frame != null) {
result = compareTo._filename == _filename && (_lineNo + 1) >= compareTo._frame.StartLine && (compareTo._lineNo + 1) <= compareTo._frame.EndLine;
} else {
result = this._lineNo == compareTo._lineNo && this._filename == compareTo._filename;
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = _filename == compareTo._filename;
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return VSConstants.E_NOTIMPL;
}
if (result) {
foundIndex = c;
return VSConstants.S_OK;
}
}
return VSConstants.S_FALSE;
}
int IDebugMemoryContext2.Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
Debug.WriteLine("AD7DocumentContext: Compare");
throw new NotImplementedException();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int Compare(enum_CONTEXT_COMPARE contextCompare, IDebugMemoryContext2 [] compareToItems, uint compareToLength, out uint foundIndex)
{
//
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
//
LoggingUtils.PrintFunction();
try
{
if (compareToItems.Length != compareToLength)
{
throw new ArgumentException("Comparing contexts of different sizes.");
}
//
// Get the context info for the current object.
//
CONTEXT_INFO [] currentContextInfo = new CONTEXT_INFO [1];
LoggingUtils.RequireOk(GetInfo(enum_CONTEXT_INFO_FIELDS.CIF_ALLFIELDS, currentContextInfo));
for (uint i = 0; i < compareToLength; ++i)
{
DebuggeeCodeContext compareTo = compareToItems [i] as DebuggeeCodeContext;
if (compareTo == null)
{
continue;
}
CONTEXT_INFO [] compareToInfo = new CONTEXT_INFO [1];
LoggingUtils.RequireOk(compareTo.GetInfo(enum_CONTEXT_INFO_FIELDS.CIF_ALLFIELDS, compareToInfo));
if (!DebugEngine.ReferenceEquals(m_engine, compareTo.m_engine))
{
continue;
}
bool comparisonResult = false;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
{
comparisonResult = (currentContextInfo [0].bstrAddressAbsolute.CompareTo(compareToInfo [0].bstrAddressAbsolute) == 0);
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
{
comparisonResult = (currentContextInfo [0].bstrAddressAbsolute.CompareTo(compareToInfo [0].bstrAddressAbsolute) < 0);
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
{
comparisonResult = (currentContextInfo [0].bstrAddressAbsolute.CompareTo(compareToInfo [0].bstrAddressAbsolute) > 0);
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
{
comparisonResult = (currentContextInfo [0].bstrAddressAbsolute.CompareTo(compareToInfo [0].bstrAddressAbsolute) <= 0);
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
{
comparisonResult = (currentContextInfo [0].bstrAddressAbsolute.CompareTo(compareToInfo [0].bstrAddressAbsolute) >= 0);
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
{
comparisonResult = true;
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
{
comparisonResult = (currentContextInfo [0].bstrFunction.CompareTo(compareToInfo [0].bstrFunction) == 0);
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
{
comparisonResult = (currentContextInfo [0].bstrModuleUrl.CompareTo(compareToInfo [0].bstrModuleUrl) == 0);
break;
}
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
// Fallthrough.
default:
{
throw new NotImplementedException();
}
}
if (comparisonResult)
{
foundIndex = i;
return(Constants.S_OK);
}
}
}
catch (NotImplementedException e)
{
LoggingUtils.HandleException(e);
foundIndex = uint.MaxValue;
return(Constants.E_NOTIMPL);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
foundIndex = uint.MaxValue;
return(Constants.E_COMPARE_CANNOT_COMPARE);
}
foundIndex = uint.MaxValue;
return(Constants.S_FALSE);
}
int IDebugMemoryContext2.Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
pdwMemoryContext = 0;
for (int i = 0; i < rgpMemoryContextSet.Length; ++i)
{
var other = rgpMemoryContextSet[i] as AD7MemoryAddress;
if (other == null || other.Engine != Engine)
{
continue;
}
bool match = false;
switch (Compare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
match = (LineNumber == other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
match = (LineNumber < other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
match = (LineNumber <= other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
match = (LineNumber > other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
match = (LineNumber >= other.LineNumber);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
match = true;
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
match = (FileName == other.FileName);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
match = (LineNumber == other.LineNumber && FileName == other.FileName);
break;
default:
return(VSConstants.E_NOTIMPL);
}
if (match)
{
pdwMemoryContext = (uint)i;
return(VSConstants.S_OK);
}
}
return(VSConstants.S_FALSE);
}
int IDebugCodeContext2.Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
return(IDebugMemoryContext2.Compare(Compare, rgpMemoryContextSet, dwMemoryContextSetLen, out pdwMemoryContext));
}
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
pdwMemoryContext = 0;
return VSConstants.E_FAIL;
}
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
Log.Debug("ScriptDocumentContext: IDebugCodeContext2.Compare");
pdwMemoryContext = 0;
return(VSConstants.E_NOTIMPL);
}
// Token: 0x060000B1 RID: 177 RVA: 0x00003B2C File Offset: 0x00001D2C
public int Compare(enum_CONTEXT_COMPARE contextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
int result;
try
{
for (uint num = 0U; num < compareToLength; num += 1U)
{
AD7MemoryAddress ad7MemoryAddress = compareToItems[(int)num] as AD7MemoryAddress;
if (ad7MemoryAddress != null && this.m_engine == ad7MemoryAddress.m_engine)
{
bool flag;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
flag = (this.m_address == ad7MemoryAddress.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
flag = (this.m_address < ad7MemoryAddress.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
flag = (this.m_address > ad7MemoryAddress.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
flag = (this.m_address <= ad7MemoryAddress.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
flag = (this.m_address >= ad7MemoryAddress.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
flag = (this.m_address == ad7MemoryAddress.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
goto IL_C9;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
flag = true;
break;
default:
goto IL_C9;
}
if (flag)
{
foundIndex = num;
return(0);
}
goto IL_DC;
IL_C9:
return(-2147467263);
}
IL_DC :;
}
result = 1;
}
catch (Exception e)
{
result = Utils.UnexpectedException(e);
}
return(result);
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE uContextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
try
{
enum_CONTEXT_COMPARE contextCompare = (enum_CONTEXT_COMPARE)uContextCompare;
for (uint c = 0; c < compareToLength; c++)
{
AD7MemoryAddress compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null)
{
continue;
}
if (!AD7Engine.ReferenceEquals(this.m_engine, compareTo.m_engine))
{
continue;
}
bool result;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (this.m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (this.m_address < compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (this.m_address > compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (this.m_address <= compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (this.m_address >= compareTo.m_address);
break;
// The sample debug engine doesn't understand scopes or functions
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
result = (this.m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = (this.m_address == compareTo.m_address);
if (result == false)
{
DebuggedModule module = m_engine.DebuggedProcess.ResolveAddress(m_address);
if (module != null)
{
result = (compareTo.m_address >= module.BaseAddress) &&
(compareTo.m_address < module.BaseAddress + module.Size);
}
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return(Constants.E_NOTIMPL);
}
if (result)
{
foundIndex = c;
return(Constants.S_OK);
}
}
return(Constants.S_FALSE);
}
catch (ComponentException e)
{
return(e.HResult);
}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
}
public int Compare(enum_CONTEXT_COMPARE comparisonType,
IDebugMemoryContext2[] memoryContexts, uint numMemoryContexts,
out uint matchIndex)
{
matchIndex = uint.MaxValue;
for (uint i = 0; i < numMemoryContexts; i++)
{
ulong otherAddress = memoryContexts[i].GetAddress();
switch (comparisonType)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
if (_address == otherAddress)
{
matchIndex = i;
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
if (_address > otherAddress)
{
matchIndex = i;
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
if (_address >= otherAddress)
{
matchIndex = i;
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
if (_address < otherAddress)
{
matchIndex = i;
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
if (_address <= otherAddress)
{
matchIndex = i;
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
memoryContexts[i].GetName(out string otherName);
GetName(out string thisName);
if (_address == otherAddress || thisName == otherName)
{
matchIndex = i;
}
break;
// TODO: if needed, implement other comparison types
default:
return(VSConstants.E_NOTIMPL);
}
if (matchIndex != uint.MaxValue)
{
return(VSConstants.S_OK);
}
}
return(VSConstants.S_FALSE);
}
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet,
uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
throw new NotImplementedException();
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE contextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
try
{
for (uint c = 0; c < compareToLength; c++)
{
AD7MemoryAddress compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null)
{
continue;
}
if (!AD7Engine.ReferenceEquals(_engine, compareTo._engine))
{
continue;
}
bool result;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (_address == compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (_address < compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (_address > compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (_address <= compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (_address >= compareTo._address);
break;
// The debug engine doesn't understand scopes
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
result = (_address == compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return(VSConstants.E_NOTIMPL);
}
if (result)
{
foundIndex = c;
return(VSConstants.S_OK);
}
}
return(VSConstants.S_FALSE);
}
catch (MIException e)
{
return(e.HResult);
}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE contextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
try
{
for (uint c = 0; c < compareToLength; c++)
{
AD7MemoryAddress compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null)
{
continue;
}
if (!AD7Engine.ReferenceEquals(_engine, compareTo._engine))
{
continue;
}
bool result;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (_address == compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (_address < compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (_address > compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (_address <= compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (_address >= compareTo._address);
break;
// The debug engine doesn't understand scopes
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
result = (_address == compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
if (_address == compareTo._address)
{
result = true;
break;
}
string funcThis = Engine.GetAddressDescription(_address);
if (string.IsNullOrEmpty(funcThis))
{
result = false;
break;
}
string funcCompareTo = Engine.GetAddressDescription(compareTo._address);
result = (funcThis == funcCompareTo);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = (_address == compareTo._address);
if (result == false)
{
DebuggedModule module = _engine.DebuggedProcess.ResolveAddress(_address);
if (module != null)
{
result = module.AddressInModule(compareTo._address);
}
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return Constants.E_NOTIMPL;
}
if (result)
{
foundIndex = c;
return Constants.S_OK;
}
}
return Constants.S_FALSE;
}
catch (MIException e)
{
return e.HResult;
}
catch (Exception e)
{
return EngineUtils.UnexpectedException(e);
}
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE Compare, IDebugMemoryContext2[] rgpMemoryContextSet, uint dwMemoryContextSetLen, out uint pdwMemoryContext)
{
pdwMemoryContext = UInt32.MaxValue;
try
{
for (uint c = 0; c < dwMemoryContextSetLen; c++)
{
if (!(rgpMemoryContextSet[c] is AD7MemoryAddress compareTo))
{
continue;
}
if (!ReferenceEquals(m_engine, compareTo.m_engine))
{
continue;
}
bool result;
switch (Compare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (m_address < compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (m_address > compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (m_address <= compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (m_address >= compareTo.m_address);
break;
// The sample debug engine doesn't understand scopes or functions
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
result = (m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = (m_address == compareTo.m_address);
if (result == false)
{
//DebuggedModule module = m_engine.DebuggedProcess.ResolveAddress(m_address);
//if (module != null)
//{
// result = (compareTo.m_address >= module.BaseAddress) &&
// (compareTo.m_address < module.BaseAddress + module.Size);
//}
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return(VSConstants.E_NOTIMPL);
}
if (result)
{
pdwMemoryContext = c;
return(VSConstants.S_OK);
}
}
return(VSConstants.S_FALSE);
}
//catch (ComponentException e)
//{
// return e.HResult;
//}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE contextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
try
{
for (uint c = 0; c < compareToLength; c++)
{
AD7MemoryAddress compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null)
{
continue;
}
if (!AD7Engine.ReferenceEquals(_engine, compareTo._engine))
{
continue;
}
bool result;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (_address == compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (_address < compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (_address > compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (_address <= compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (_address >= compareTo._address);
break;
// The debug engine doesn't understand scopes
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
result = (_address == compareTo._address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
if (_address == compareTo._address)
{
result = true;
break;
}
string funcThis = Engine.GetAddressDescription(_address);
if (string.IsNullOrEmpty(funcThis))
{
result = false;
break;
}
string funcCompareTo = Engine.GetAddressDescription(compareTo._address);
result = (funcThis == funcCompareTo);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = (_address == compareTo._address);
if (result == false)
{
DebuggedModule module = _engine.DebuggedProcess.ResolveAddress(_address);
if (module != null)
{
result = module.AddressInModule(compareTo._address);
}
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return(Constants.E_NOTIMPL);
}
if (result)
{
foundIndex = c;
return(Constants.S_OK);
}
}
return(Constants.S_FALSE);
}
catch (MIException e)
{
return(e.HResult);
}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE uContextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
try
{
enum_CONTEXT_COMPARE contextCompare = (enum_CONTEXT_COMPARE)uContextCompare;
for (uint c = 0; c < compareToLength; c++)
{
AD7MemoryAddress compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null)
{
continue;
}
if (!AD7Engine.ReferenceEquals(this.m_engine, compareTo.m_engine))
{
continue;
}
bool result;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (this.m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (this.m_address < compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (this.m_address > compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (this.m_address <= compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (this.m_address >= compareTo.m_address);
break;
// The sample debug engine doesn't understand scopes or functions
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
result = (this.m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = (this.m_address == compareTo.m_address);
if (result == false)
{
//DebuggedModule module = m_engine.DebuggedProcess.ResolveAddress(m_address);
//if (module != null)
//{
// result = (compareTo.m_address >= module.BaseAddress) &&
// (compareTo.m_address < module.BaseAddress + module.Size);
//}
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return VSConstants.E_NOTIMPL;
}
if (result)
{
foundIndex = c;
return VSConstants.S_OK;
}
}
return VSConstants.S_FALSE;
}
//catch (ComponentException e)
//{
// return e.HResult;
//}
catch (Exception e)
{
return EngineUtils.UnexpectedException(e);
}
}
