/// <summary>
/// Returns the overloads for a normal .NET type
/// </summary>
private OverloadResult[] GetClrOverloads()
{
Type clrType = ClrModule.GetClrType(_type);
// just a normal .NET type...
var ctors = clrType.GetConstructors(BindingFlags.Public | BindingFlags.CreateInstance | BindingFlags.Instance);
var overloads = new OverloadResult[ctors.Length];
for (int i = 0; i < ctors.Length; i++)
{
// TODO: Docs, python type name
var parameters = ctors[i].GetParameters();
bool hasContext = parameters.Length > 0 && parameters[0].ParameterType == typeof(CodeContext);
var paramResult = new ParameterResult[hasContext ? parameters.Length - 1 : parameters.Length];
for (int j = 0; j < paramResult.Length; j++)
{
var curParam = parameters[j + (hasContext ? 1 : 0)];
// TODO: Docs
paramResult[j] = BuiltinFunctionOverloadResult.GetParameterResultFromParameterInfo(curParam);
}
overloads[i] = new SimpleOverloadResult(paramResult, PythonType.Get__name__(_type), "");
}
return(overloads);
}
internal static ParameterResult GetParameterResultFromParameterInfo(ParameterInfo param)
{
// TODO: Get parameter documentation
var pyType = ClrModule.GetPythonType(param.ParameterType);
string name = param.Name;
string typeName = PythonType.Get__name__(pyType);
if (param.IsDefined(typeof(ParamArrayAttribute), false))
{
name = "*" + name;
if (param.ParameterType.IsArray)
{
var elemType = param.ParameterType.GetElementType();
if (elemType == typeof(object))
{
typeName = "sequence";
}
else
{
typeName = PythonType.Get__name__(DynamicHelpers.GetPythonTypeFromType(elemType)) + " sequence";
}
}
}
else if (param.IsDefined(typeof(ParamDictionaryAttribute), false))
{
name = "**" + name;
typeName = "object";
}
bool isOptional = false;
if (param.DefaultValue != DBNull.Value && !(param.DefaultValue is Missing))
{
name = name + " = " + PythonOps.Repr(DefaultContext.Default, param.DefaultValue);
}
else if (param.IsOptional)
{
object missing = CompilerHelpers.GetMissingValue(param.ParameterType);
if (missing != Missing.Value)
{
name = name + " = " + PythonOps.Repr(DefaultContext.Default, missing);
}
else
{
isOptional = true;
}
}
return(new ParameterResult(name, "", typeName, isOptional));
}
public string MakeText <T>(IEnumerable <T> values)
{
var sb = new StringBuilder("{");
foreach (var value in values)
{
if (sb.Length > 1)
{
sb.Append(", ");
}
if (value is PythonType)
{
sb.AppendFormat("Type({0})", PythonType.Get__name__((PythonType)(object)value));
}
else
{
sb.Append(value.ToString());
}
}
sb.Append("}");
return(sb.ToString());
}
/// <summary>
/// Create new scripting engine
/// </summary>
/// <param name="runtime">Instance of the current runtime enviroement</param>
/// <returns>Instance of IP script engine</returns>
public ScriptEngine CreateEngine(ScriptRuntime runtime)
{
scriptEngine = runtime.GetEngineByTypeName(typeof(PythonContext).AssemblyQualifiedName);
// Override import functionality
ScriptScope scope = IronPython.Hosting.Python.GetBuiltinModule(scriptEngine);
scope.SetVariable("__import__", new ImportDelegate(ResolveImport));
var sysScope = scriptEngine.GetSysModule();
List path_hooks = sysScope.GetVariable("path_hooks");
// Disable zipimporter if needed
for (int i = 0; i < path_hooks.Count; i++)
{
if (path_hooks.ElementAt(i) != null)
{
PythonType type = path_hooks.ElementAt(i) as PythonType;
string name = PythonType.Get__name__(type);
if (name == "zipimporter" && EnableZipImporter == false)
{
path_hooks.RemoveAt(i);
}
}
}
PythonType genericimporter = DynamicHelpers.GetPythonType(new GenericImportModule.genericimporter());
path_hooks.Add(genericimporter);
sysScope.SetVariable("path_hooks", path_hooks);
return(scriptEngine);
}
public override string ToString()
{
// return 'Class#' + hex(id(self)) + ' ' + self.clrType.__name__
return("Class " + PythonType.Get__name__(_type));
}