internal PythonFunction(CodeContext/*!*/ context, FunctionCode funcInfo, object modName, object[] defaults, MutableTuple closure) {
Assert.NotNull(context, funcInfo);
_context = context;
_defaults = defaults ?? ArrayUtils.EmptyObjects;
_code = funcInfo;
_doc = funcInfo._initialDoc;
_name = funcInfo.co_name;
Debug.Assert(_defaults.Length <= _code.co_argcount);
if (modName != Uninitialized.Instance) {
_module = modName;
}
Closure = closure;
_compat = CalculatedCachedCompat();
}
private static int _CurrentId = 1; // The current ID for functions which are called in complex ways.
public TotemFunction(CodeContext context, FunctionCode funcInfo, object moduleName, object[] defaults, MutableTuple closure)
{
Assert.NotNull(context, funcInfo);
_context = context;
_defaults = defaults ?? ArrayUtils.EmptyObjects;
_code = funcInfo;
_name = funcInfo.Name;
Debug.Assert(_defaults.Length <= _code.ArgCount);
if (moduleName != Uninitialized.Instance)
{
_module = moduleName;
}
Closure = closure;
_compat = CalculatedCachedCompat();
}
internal RubyBlockScope(MutableTuple locals, SymbolId[]/*!*/ variableNames,
BlockParam/*!*/ blockFlowControl, object selfObject, InterpretedFrame interpretedFrame) {
var parent = blockFlowControl.Proc.LocalScope;
// RuntimeFlowControl:
_activeFlowControlScope = parent.FlowControlScope;
// RubyScope:
_parent = parent;
_top = parent.Top;
_selfObject = selfObject;
_methodAttributes = RubyMethodAttributes.PublicInstance;
_locals = locals;
_variableNames = variableNames;
InterpretedFrame = interpretedFrame;
// RubyBlockScope:
_blockFlowControl = blockFlowControl;
}
internal RubyMethodScope(MutableTuple locals, SymbolId[]/*!*/ variableNames,
RubyScope/*!*/ parent, RubyModule/*!*/ declaringModule, string/*!*/ definitionName,
object selfObject, Proc blockParameter, InterpretedFrame interpretedFrame) {
Assert.NotNull(parent, declaringModule, definitionName);
// RuntimeFlowControl:
_activeFlowControlScope = this;
// RubyScope:
_parent = parent;
_top = parent.Top;
_selfObject = selfObject;
_methodAttributes = RubyMethodAttributes.PublicInstance;
_locals = locals;
_variableNames = variableNames;
InterpretedFrame = interpretedFrame;
// RubyMethodScope:
_declaringModule = declaringModule;
_definitionName = definitionName;
_blockParameter = blockParameter;
InitializeRfc(blockParameter);
SetDebugName("method " + definitionName + ((blockParameter != null) ? "&" : null));
}
internal void SetEmptyLocals() {
Debug.Assert(_variableNames == null);
_variableNames = SymbolId.EmptySymbols;
_locals = null;
}
internal void SetLocals(MutableTuple locals, SymbolId[]/*!*/ variableNames) {
Debug.Assert(_variableNames == null);
_locals = locals;
_variableNames = variableNames;
}
internal RubyFileInitializerScope(MutableTuple locals, string[]/*!*/ variableNames, RubyScope/*!*/ parent) {
// RuntimeFlowControl:
_activeFlowControlScope = parent.FlowControlScope;
// RubyScope:
_parent = parent;
_top = parent.Top;
_selfObject = parent.SelfObject;
_methodAttributes = RubyMethodAttributes.PublicInstance;
_locals = locals;
_variableNames = variableNames;
InLoop = parent.InLoop;
InRescue = parent.InRescue;
}
internal void SetEmptyLocals() {
Debug.Assert(_variableNames == null);
_variableNames = ArrayUtils.EmptyStrings;
_locals = null;
}
public static CodeContext CreateLocalContext(CodeContext/*!*/ outerContext, MutableTuple boxes, string[] args)
{
return new CodeContext(
new TotemDictionary(
new RuntimeVariablesDictionaryStorage(boxes, args)
),
outerContext.GlobalContext,
outerContext.LanguageContext);
}
public static object MakeFunctionDebug(CodeContext context, FunctionCode funcInfo, object modName, MutableTuple closure, object[] defaults, Delegate target)
{
funcInfo.SetDebugTarget(context.LanguageContext, target);
return new TotemFunction(context, funcInfo, modName, defaults, closure);
}
public static object MakeFunction(CodeContext context, FunctionCode funcInfo, object modName, MutableTuple closure, object[] defaults)
{
return new TotemFunction(context, funcInfo, modName, defaults, closure);
}
public RuntimeVariablesDictionaryStorage(MutableTuple boxes, string[] args)
{
_boxes = boxes;
_args = args;
}
internal static TotemGenerator MakeGenerator(TotemFunction function, MutableTuple data, object generatorCode)
{
Func<MutableTuple, object> next = generatorCode as Func<MutableTuple, object>;
if (next == null)
next = ((LazyCode<Func<MutableTuple, object>>)generatorCode).EnsureDelegate();
return new TotemGenerator(function, next, data);
}
internal static Task<object> MakeAsync(TotemFunction function, MutableTuple data, object generatorCode)
{
Func<MutableTuple, object> next = generatorCode as Func<MutableTuple, object>;
if (next == null)
next = ((LazyCode<Func<MutableTuple, object>>)generatorCode).EnsureDelegate();
var gen = new TotemAsyncStateMachine(function, next, data);
return gen.Run();
}
/// <summary>
/// Gets the values from a tuple including unpacking nested values.
/// </summary>
public static object[] GetTupleValues(MutableTuple tuple) {
ContractUtils.RequiresNotNull(tuple, "tuple");
List<object> res = new List<object>();
GetTupleValues(tuple, res);
return res.ToArray();
}
/// <summary>
/// Python ctor - maps to function.__new__
///
/// y = func(x.__code__, globals(), 'foo', None, (a, ))
/// </summary>
public PythonFunction(CodeContext context, FunctionCode code, PythonDictionary globals, string name, PythonTuple defaults, PythonTuple closure) {
if (closure != null && closure.__len__() != 0) {
throw new NotImplementedException("non empty closure argument is not supported");
}
if (globals == context.GlobalDict) {
_module = context.Module.GetName();
_context = context;
} else {
_module = null;
_context = new CodeContext(new PythonDictionary(), new ModuleContext(globals, DefaultContext.DefaultPythonContext));
}
_defaults = defaults == null ? ArrayUtils.EmptyObjects : defaults.ToArray();
_code = code;
_name = name;
_doc = code._initialDoc;
Closure = null;
var scopeStatement = _code.PythonCode;
if (scopeStatement.IsClosure) {
throw new NotImplementedException("code containing closures is not supported");
}
scopeStatement.RewriteBody(FunctionDefinition.ArbitraryGlobalsVisitorInstance);
_compat = CalculatedCachedCompat();
}
private static void GetTupleValues(MutableTuple tuple, List<object> args) {
Type[] types = tuple.GetType().GetGenericArguments();
for (int i = 0; i < types.Length; i++) {
if (typeof(MutableTuple).IsAssignableFrom(types[i])) {
GetTupleValues((MutableTuple)tuple.GetValue(i), args);
} else if (types[i] != typeof(DynamicNull)) {
args.Add(tuple.GetValue(i));
}
}
}
public void VerifyTuple(int size)
{
//Construct a tuple of the right type
MethodInfo mi = typeof(MutableTuple).GetMethod("MakeTupleType", BindingFlags.Public | BindingFlags.Static);
Assert(mi != null, "Could not find Tuple.MakeTupleType");
Type[] args = new Type[size];
object[] values = new object[size];
for (int i = 0; i < size; i++)
{
args[i] = typeof(int);
values[i] = 0;
}
Type tupleType = (Type)mi.Invoke(null, new object[] { args });
MutableTuple t = MutableTuple.MakeTuple(tupleType, values);
/////////////////////
//Properties
//Write
for (int i = 0; i < size; i++)
{
object o = t;
foreach (PropertyInfo pi in MutableTuple.GetAccessPath(tupleType, i))
{
if (typeof(MutableTuple).IsAssignableFrom(pi.PropertyType))
{
o = pi.GetValue(o, null);
}
else
{
pi.SetValue(o, i * 5, null);
}
}
}
//Read
for (int i = 0; i < size; i++)
{
object o = t;
foreach (PropertyInfo pi in MutableTuple.GetAccessPath(tupleType, i))
{
o = pi.GetValue(o, null);
}
AreEqual(typeof(int), o.GetType());
AreEqual((int)o, i * 5);
}
//Negative cases for properties
AssertError <ArgumentException>(delegate() {
foreach (PropertyInfo pi in MutableTuple.GetAccessPath(tupleType, -1))
{
Console.WriteLine(pi.Name); //This won't run, but we need it so that this call isn't inlined
}
});
/////////////////////
//GetTupleValues
values = MutableTuple.GetTupleValues(t);
AreEqual(values.Length, size);
for (int i = 0; i < size; i++)
{
AreEqual(typeof(int), values[i].GetType());
AreEqual((int)(values[i]), i * 5);
}
/////////////////////
//Access methods
if (size <= MutableTuple.MaxSize)
{
//SetValue
for (int i = 0; i < size; i++)
{
t.SetValue(i, i * 3);
}
//GetValue
for (int i = 0; i < size; i++)
{
AreEqual(t.GetValue(i), i * 3);
}
//Ensure there are no extras
if (tupleType.GetGenericArguments().Length <= size)
{
//We're requesting an index beyond the end of this tuple.
AssertError <ArgumentException>(delegate() { t.SetValue(size, 3); });
AssertError <ArgumentException>(delegate() { t.GetValue(size); });
}
else
{
/*We're requesting an index in the scope of this tuple but beyond the scope of our
* requested capacity (in which case the field's type will be Microsoft.Scripting.None
* and we won't be able to convert "3" to that). Imagine asking for a tuple of 3 ints,
* we'd actually get a Tuple<int,int,int,Microsoft.Scripting.None> since there is no
* Tuple that takes only 3 generic arguments.*/
AssertError <InvalidCastException>(delegate() { t.SetValue(size, 3); });
//Verify the type of the field
AreEqual(typeof(Microsoft.Scripting.Runtime.DynamicNull), tupleType.GetGenericArguments()[size]);
//Verify the value of the field is null
AreEqual(null, t.GetValue(size));
}
}
}