public object ToPythonException()
{
DynamicType exType = ExceptionConverter.GetPythonExceptionByName(PythonExceptionName);
object inst = Ops.Call(exType);
Ops.SetAttr(DefaultContext.Default, inst, SymbolTable.ExceptionMessage, base.Message);
Ops.SetAttr(DefaultContext.Default, inst, SymbolTable.Arguments, Tuple.MakeTuple(
base.Message,
Tuple.MakeTuple(
file,
lineNo,
columnNo == 0 ? null : (object)columnNo,
lineText
)
));
Ops.SetAttr(DefaultContext.Default, inst, SymbolTable.ExceptionFilename, file);
Ops.SetAttr(DefaultContext.Default, inst, SymbolTable.ExceptionLineNumber, lineNo);
if (columnNo != 0)
{
Ops.SetAttr(DefaultContext.Default, inst, SymbolTable.ExceptionOffset, columnNo);
}
else
{
Ops.SetAttr(DefaultContext.Default, inst, SymbolTable.ExceptionOffset, null);
}
Ops.SetAttr(DefaultContext.Default, inst, SymbolTable.Text, lineText);
// print_file_and_line
return(inst);
}
public int GetExitCode(ICallerContext context)
{
object pyObj = ExceptionConverter.ToPython(this);
object args;
if (!Ops.TryGetAttr(pyObj, SymbolTable.Arguments, out args))
{
return(0);
}
Tuple t = args as Tuple;
if (t == null || t.Count == 0)
{
return(0);
}
try {
return(Converter.ConvertToInt32(t[0]));
} catch {
}
try {
Ops.PrintWithDest(context.SystemState, context.SystemState.stderr, t[0]);
} catch {
}
return(1);
}
public object Call(params object[] args)
{
try {
object ret = obj.GetType().InvokeMember(
name,
System.Reflection.BindingFlags.InvokeMethod,
Type.DefaultBinder,
obj,
args
);
return(Ops.ToPython(ret));
} catch (Exception e) {
if (e.InnerException != null)
{
throw ExceptionConverter.UpdateForRethrow(e.InnerException);
}
throw;
}
}
/// <summary>
/// Creates a new throwable exception of type type.
/// </summary>
public static Exception CreateThrowable(object type, object value)
{
object pyEx;
if (Builtin.IsInstance(value, type))
{
pyEx = value;
}
else if (value is Tuple)
{
pyEx = Ops.CallWithArgsTuple(type, new object[0], value);
}
else
{
pyEx = Ops.Call(type, value);
}
return(ExceptionConverter.ToClr(pyEx));
}
public Tuple exc_info()
{
if (RawException == null)
{
return(Tuple.MakeTuple(null, null, null));
}
object pyExcep = ExceptionConverter.ToPython(RawException);
if (Options.TracebackSupport && RawTraceBack != null)
{
RawTraceBack.UpdateFromStackTrace(new System.Diagnostics.StackTrace(RawException, true));
}
exc_traceback = RawTraceBack;
if (pyExcep is StringException)
{
// string exceptions are special... there tuple looks
// like string, argument, traceback instead of
// type, instance, traceback
StringException se = RawException as StringException;
Debug.Assert(se != null);
exc_type = pyExcep;
exc_value = se.Value;
return(Ops.MakeTuple(
pyExcep,
se.Value,
RawTraceBack));
}
else
{
object excType = Ops.GetAttr(DefaultContext.Default, pyExcep, SymbolTable.Class);
exc_type = excType;
exc_value = pyExcep;
return(Ops.MakeTuple(
excType,
pyExcep,
RawTraceBack));
}
}
internal void SetAttr(ICallerContext context, SymbolId name, object value)
{
Initialize(context);
if (HaveInterfaces)
{
foreach (DynamicType type in interfaces)
{
try {
type.SetAttr(context, obj, name, value);
return;
} catch {
}
}
throw Ops.AttributeErrorForMissingAttribute(ComType.MakeDynamicType().__name__.ToString(), name);
}
else
{
try {
Obj.GetType().InvokeMember(
(string)SymbolTable.IdToString(name),
System.Reflection.BindingFlags.SetProperty |
System.Reflection.BindingFlags.SetField,
Type.DefaultBinder,
Obj,
new object[1] {
value
}
);
} catch (Exception e) {
if (e.InnerException != null)
{
throw ExceptionConverter.UpdateForRethrow(e.InnerException);
}
throw;
}
}
}
/// <summary>
/// Performs late-bound invocation - used by ReflectedMethod's and
/// for keyword argument calls.
/// </summary>
protected static object Invoke(MethodBinding binding)
{
object result;
try {
if (binding.method is ConstructorInfo)
{
result = ((ConstructorInfo)binding.method).Invoke(binding.arguments);
}
else
{
result = binding.method.Invoke(binding.instance, binding.arguments);
}
} catch (TargetInvocationException tie) {
throw ExceptionConverter.UpdateForRethrow(tie.InnerException);
}
MethodBase info = binding.method;
ParameterInfo[] parameters = info.GetParameters();
int results = 0;
for (int parm = 0; parm < parameters.Length; parm++)
{
if (parameters[parm].ParameterType.IsByRef)
{
results++;
}
}
if (results == 0)
{
return(Ops.ToPython(CompilerHelpers.GetReturnType(info), result));
}
object[] retValues;
int retValueIndex = 0;
if (info is MethodInfo && ((MethodInfo)info).ReturnType != typeof(void))
{
retValues = new object[results + 1];
retValues[retValueIndex++] = Ops.ToPython(CompilerHelpers.GetReturnType(info), result);
}
else
{
retValues = new object[results];
}
for (int parm = 0; parm < parameters.Length; parm++)
{
Type parmType = parameters[parm].ParameterType;
if (parmType.IsByRef)
{
retValues[retValueIndex++] = Ops.ToPython(parmType, binding.arguments[parm]);
}
}
if (retValues.Length == 1)
{
return(retValues[0]);
}
else
{
return(Tuple.MakeTuple(retValues));
}
}
/// <summary>
/// Creates a CLR exception for the given type
/// </summary>
public static Exception CreateThrowable(object type)
{
object pyEx = Ops.Call(type);
return(ExceptionConverter.ToClr(pyEx));
}
public void exit(object code)
{
// throw as a python exception here to get the args set.
throw ExceptionConverter.CreateThrowable(ExceptionConverter.GetPythonExceptionByName("SystemExit"), code);
}
public void exit()
{
throw ExceptionConverter.CreateThrowable(ExceptionConverter.GetPythonExceptionByName("SystemExit"));
}
