public static NameType TryGetName(ReflectedType dt, FieldInfo fi, out string name)
{
Debug.Assert(dt.IsSubclassOf(DynamicType.GetDeclaringType(fi)));
NameType nt = NameType.PythonField;
name = null;
// hide MinValue & MaxValue on int, Empty on string, Epsilon, Min/Max, etc.. on double
if (fi.DeclaringType == typeof(string) ||
fi.DeclaringType == typeof(int) ||
fi.DeclaringType == typeof(double) ||
fi.IsDefined(typeof(PythonHiddenFieldAttribute), false)) nt = NameType.Field;
string namePrefix = "";
if (fi.IsPrivate || (fi.IsAssembly && !fi.IsFamilyOrAssembly)) {
if (!Options.PrivateBinding) {
return NameType.None;
} else {
// mangle protectes to private
namePrefix = "_" + dt.Name + "__";
nt = NameType.Field;
}
}
name = namePrefix + fi.Name;
return nt;
}
public NameEnvironment(PythonModule globals, object locals)
{
this.globals = globals;
if (locals == null) locals = globals.__dict__;
this.locals = locals;
this.builtin = TypeCache.Builtin;
}
internal ModuleScope(PythonModule mod, IAttributesDictionary globals, object locals)
{
__module__ = mod;
f_globals = globals;
f_locals = locals;
__builtin__ = TypeCache.Builtin;
}
public static NameType TryGetName(ReflectedType dt, EventInfo ei, MethodInfo eventMethod, out string name)
{
Debug.Assert(dt.IsSubclassOf(DynamicType.GetDeclaringType(ei)));
name = ei.Name;
NameType res = dt.IsClsType ? NameType.PythonEvent : NameType.Event;
return GetNameFromMethod(dt, eventMethod, res, ref name);
}
public static NameType TryGetName(ReflectedType dt, MethodInfo mi, out string name)
{
Debug.Assert(dt.IsSubclassOf(DynamicType.GetDeclaringType(mi)));
NameType res = dt.IsClsType ? NameType.PythonMethod : NameType.Method;
name = mi.Name;
return GetNameFromMethod(dt, mi, res, ref name);
}
internal bool TryConvertTo(object value, ReflectedType to, out object result)
{
if (conversions != null && conversions.Count > 0) {
for (int i = 0; i < conversions.Count; i++) {
if (conversions[i].ReturnType == to.type) {
try {
result = conversions[i].Invoke(null, new object[] { value });
return true;
} catch (TargetInvocationException tie) {
throw ExceptionConverter.UpdateForRethrow(tie);
}
}
}
}
result = null;
return false;
}
private string GetName(Type type)
{
if (type == typeof(object)) { return "object"; } //???
PythonTypeAttribute attr = (PythonTypeAttribute)
Attribute.GetCustomAttribute(type, typeof(PythonTypeAttribute));
if (attr != null) {
if (attr.impersonateType != null) {
this.effectivePythonType = (ReflectedType)Ops.GetDynamicTypeFromType(attr.impersonateType);
}
return attr.name;
} else {
string name;
NameConverter.TryGetName(this, type, out name);
return name;
}
}
internal static PythonModule MakePythonModule(SystemState state, string name, ReflectedType type)
{
type.Initialize();
FieldIdDict dict = new FieldIdDict();
foreach (string attrName in type.GetAttrNames(DefaultContext.Default)) {
dict[SymbolTable.StringToId(attrName)] = type.GetAttr(DefaultContext.Default, null, SymbolTable.StringToId(attrName));
}
PythonModule ret = new PythonModule(name, dict, state);
state.modules[name] = ret;
return ret;
}
public static ReflectedType MakeDynamicType(ReflectedType type)
{
if (BoolType == null) {
OpsReflectedType ret = new OpsReflectedType("bool", typeof(bool), typeof(BoolOps), null, new CallTarget1(FastNew));
if (Interlocked.CompareExchange<ReflectedType>(ref BoolType, ret, null) == null)
return ret;
}
return BoolType;
}
public static NameType TryGetName(ReflectedType outerType, Type t, out string name)
{
name = t.Name;
int backtickIndex;
if ((backtickIndex = name.IndexOf(ReflectionUtil.GenericArityDelimiter)) != -1) {
name = name.Substring(0, backtickIndex);
if (!t.ContainsGenericParameters) {
Type[] typeOf = t.GetGenericArguments();
StringBuilder sb = new StringBuilder(name);
sb.Append('[');
bool first = true;
foreach (Type tof in typeOf) {
if (first) first = false; else sb.Append(", ");
sb.Append(Ops.GetDynamicTypeFromType(tof).Name);
}
sb.Append(']');
name = sb.ToString();
}
}
string namePrefix = "";
if ((t.IsNested && !t.IsNestedPublic) || (t.IsNestedAssembly && !t.IsNestedFamORAssem)) {
if (!Options.PrivateBinding) {
return NameType.None;
} else {
namePrefix = "_" + Ops.GetDynamicTypeFromType(t.DeclaringType).Name + "__";
}
}
NameType res = NameType.Type;
if (outerType.IsPythonType) {
object[] attribute = t.GetCustomAttributes(typeof(PythonTypeAttribute), false);
if (attribute.Length > 0) {
PythonTypeAttribute attr = attribute[0] as PythonTypeAttribute;
if (attr.name != null && attr.name.Length > 0) {
res = NameType.PythonType;
name = attr.name;
}
}
} else {
res = NameType.PythonType;
}
name = namePrefix + name;
return res;
}
public static NameType TryGetName(ReflectedType dt, PropertyInfo pi, MethodInfo prop, out string name)
{
Debug.Assert(dt.IsSubclassOf(DynamicType.GetDeclaringType(pi)));
name = pi.Name;
NameType res = dt.IsClsType ? NameType.PythonProperty : NameType.Property;
return GetNameFromMethod(dt, prop, res, ref name);
}
private static NameType GetNameFromMethod(ReflectedType dt, MethodInfo mi, NameType res, ref string name)
{
string namePrefix = null;
if (mi.IsPrivate || (mi.IsAssembly && !mi.IsFamilyOrAssembly)) {
// allow explicitly implemented interface
if (!(mi.IsPrivate && mi.IsFinal && mi.IsHideBySig && mi.IsVirtual)) {
if (!Options.PrivateBinding) {
return NameType.None;
} else {
// mangle protectes to private
namePrefix = "_" + dt.Name + "__";
}
} else {
// explicitly implemented interface
// drop the namespace, leave the interface name, and replace
// the dot with an underscore. Eg System.IConvertible.ToBoolean
// becomes IConvertible_ToBoolean
int lastDot = name.LastIndexOf(Type.Delimiter);
if (lastDot != -1) {
name = name.Substring(lastDot + 1);
}
}
}
object[] attribute = mi.GetCustomAttributes(typeof(PythonNameAttribute), false);
if (namePrefix != null) name = namePrefix + name;
if (attribute.Length > 0) {
PythonNameAttribute attr = attribute[0] as PythonNameAttribute;
if (attr.name != null && attr.name.Length > 0) {
if (attr is PythonClassMethodAttribute) res |= NameType.ClassMember;
res |= NameType.Python;
name = attr.name;
}
}
return res;
}
