private void Exec(string code, BorrowedReference _globals, BorrowedReference _locals)
{
NewReference reference = Runtime.PyRun_String(
code, RunFlagType.File, _globals, _locals
);
PythonException.ThrowIfIsNull(reference);
reference.Dispose();
}
private void Exec(string code, IntPtr _globals, IntPtr _locals)
{
var flag = (IntPtr)Runtime.Py_file_input;
NewReference reference = Runtime.PyRun_String(
code, flag, _globals, _locals
);
PythonException.ThrowIfIsNull(reference);
reference.Dispose();
}
/// <summary>
/// Internal RunString Method.
/// </summary>
/// <remarks>
/// Run a string containing Python code. Returns the result of
/// executing the code string as a PyObject instance, or null if
/// an exception was raised.
/// </remarks>
internal static PyObject RunString(string code, IntPtr?globals, IntPtr?locals, RunFlagType flag)
{
var borrowedGlobals = true;
if (globals == null)
{
globals = Runtime.PyEval_GetGlobals();
if (globals == IntPtr.Zero)
{
globals = Runtime.PyDict_New();
Runtime.PyDict_SetItemString(
globals.Value, "__builtins__",
Runtime.PyEval_GetBuiltins()
);
borrowedGlobals = false;
}
}
if (locals == null)
{
locals = globals;
}
try
{
NewReference result = Runtime.PyRun_String(
code, (IntPtr)flag, globals.Value, locals.Value
);
try
{
Runtime.CheckExceptionOccurred();
return(result.MoveToPyObject());
}
finally
{
result.Dispose();
}
}
finally
{
if (!borrowedGlobals)
{
Runtime.XDecref(globals.Value);
}
}
}
private void Exec(string code, IntPtr _globals, IntPtr _locals)
{
var flag = (IntPtr)Runtime.Py_file_input;
NewReference reference = Runtime.PyRun_String(
code, flag, _globals, _locals
);
try
{
Runtime.CheckExceptionOccurred();
if (!reference.IsNone())
{
throw new PythonException();
}
}
finally
{
reference.Dispose();
}
}
/// <summary>
/// Eval method
/// </summary>
/// <remarks>
/// Evaluate a Python expression and return the result as a PyObject
/// or null if an exception is raised.
/// </remarks>
public PyObject Eval(string code, PyDict locals = null)
{
Check();
IntPtr _locals = locals == null ? variables : locals.obj;
var flag = (IntPtr)Runtime.Py_eval_input;
NewReference reference = Runtime.PyRun_String(
code, flag, variables, _locals
);
try
{
Runtime.CheckExceptionOccurred();
return(reference.MoveToPyObject());
}
finally
{
reference.Dispose();
}
}
private static void InitClassBase(Type type, ClassBase impl)
{
// First, we introspect the managed type and build some class
// information, including generating the member descriptors
// that we'll be putting in the Python class __dict__.
ClassInfo info = GetClassInfo(type);
impl.indexer = info.indexer;
impl.richcompare = new Dictionary <int, MethodObject>();
// Now we allocate the Python type object to reflect the given
// managed type, filling the Python type slots with thunks that
// point to the managed methods providing the implementation.
IntPtr tp = TypeManager.GetTypeHandle(impl, type);
// Finally, initialize the class __dict__ and return the object.
var dict = new BorrowedReference(Marshal.ReadIntPtr(tp, TypeOffset.tp_dict));
if (impl.dotNetMembers == null)
{
impl.dotNetMembers = new List <string>();
}
IDictionaryEnumerator iter = info.members.GetEnumerator();
while (iter.MoveNext())
{
var item = (ManagedType)iter.Value;
var name = (string)iter.Key;
impl.dotNetMembers.Add(name);
Runtime.PyDict_SetItemString(dict, name, item.ObjectReference);
// Decref the item now that it's been used.
item.DecrRefCount();
if (ClassBase.CilToPyOpMap.TryGetValue(name, out var pyOp))
{
impl.richcompare.Add(pyOp, (MethodObject)item);
}
}
// If class has constructors, generate an __doc__ attribute.
NewReference doc = default;
Type marker = typeof(DocStringAttribute);
var attrs = (Attribute[])type.GetCustomAttributes(marker, false);
if (attrs.Length != 0)
{
var attr = (DocStringAttribute)attrs[0];
string docStr = attr.DocString;
doc = NewReference.DangerousFromPointer(Runtime.PyString_FromString(docStr));
Runtime.PyDict_SetItem(dict, PyIdentifier.__doc__, doc);
}
var co = impl as ClassObject;
// If this is a ClassObject AND it has constructors, generate a __doc__ attribute.
// required that the ClassObject.ctors be changed to internal
if (co != null)
{
if (co.NumCtors > 0)
{
// Implement Overloads on the class object
if (!CLRModule._SuppressOverloads)
{
var ctors = new ConstructorBinding(type, tp, co.binder);
// ExtensionType types are untracked, so don't Incref() them.
// TODO: deprecate __overloads__ soon...
Runtime.PyDict_SetItem(dict, PyIdentifier.__overloads__, ctors.ObjectReference);
Runtime.PyDict_SetItem(dict, PyIdentifier.Overloads, ctors.ObjectReference);
ctors.DecrRefCount();
}
// don't generate the docstring if one was already set from a DocStringAttribute.
if (!CLRModule._SuppressDocs && doc.IsNull())
{
doc = co.GetDocString();
Runtime.PyDict_SetItem(dict, PyIdentifier.__doc__, doc);
}
}
}
doc.Dispose();
// The type has been modified after PyType_Ready has been called
// Refresh the type
Runtime.PyType_Modified(tp);
}