public static object Call(CodeContext/*!*/ context, TypeGroup/*!*/ self, params object[] args) {
return PythonCalls.Call(
context,
DynamicHelpers.GetPythonTypeFromType(self.NonGenericType),
args ?? ArrayUtils.EmptyObjects
);
}
/// <summary>
/// Convenience function for users to call directly
/// </summary>
public object GetValue(CodeContext context, object instance) {
object value;
if (TryGetValue(context, instance, DynamicHelpers.GetPythonType(instance), out value)) {
return value;
}
throw new InvalidOperationException("cannot get field");
}
public static CodeContext CreateCodeContext(Type[] extensionTypes)
{
DefaultLanguageContext dlc = new DefaultLanguageContext();
CodeContext cc = new CodeContext(new Scope(), dlc, new ModuleContext(null));
dlc._binder = new DefaultActionBinder(cc, extensionTypes);
return cc;
}
internal TraceBackFrame(CodeContext context, TotemDictionary globals, object locals, FunctionCode code)
{
_globals = globals;
_locals = locals;
_code = code;
_context = context;
}
public PythonTypeChangedEventArgs(CodeContext context, SymbolId changed, ChangeType type, object previous, object newValue) {
_context = context;
_changed = changed;
_type = type;
_previous = previous;
_newValue = newValue;
}
static InvariantContext()
{
Instance = new InvariantContext();
ModuleContext moduleContext = new ModuleContext(null);
moduleContext.ShowCls = true;
CodeContext = new CodeContext(new Scope(null), Instance, moduleContext);
}
public DynamicStackFrame(CodeContext context, MethodBase method, string funcName, string filename, int line) {
_context = context;
_funcName = funcName;
_filename = filename;
_lineNo = line;
_method = method;
}
protected static object CheckCodeContext(CodeContext cc)
{
if (cc != null && cc.Scope.Parent.Parent == null)
{
return null;
}
return cc;
}
public static object Call(CodeContext/*!*/ context, TypeGroup/*!*/ self, [ParamDictionary]PythonDictionary kwArgs, params object[] args) {
return PythonCalls.CallWithKeywordArgs(
context,
DynamicHelpers.GetPythonTypeFromType(self.NonGenericType),
args ?? ArrayUtils.EmptyObjects,
kwArgs ?? new PythonDictionary()
);
}
internal override bool TryGetValue(CodeContext context, object instance, PythonType owner, out object value) {
if (instance != null || owner == TypeCache.Null) {
CheckSelf(context, instance);
value = UncheckedGetAttribute(instance);
return true;
}
value = this;
return true;
}
public override object Build(CodeContext context, object[] args, object[] parameters, object ret)
{
if (_returnArgs.Count == 1) {
return GetValue(args, ret, _returnArgs[0]);
} else {
object[] retValues = new object[_returnArgs.Count];
int rIndex = 0;
foreach (int index in _returnArgs) {
retValues[rIndex++] = GetValue(args, ret, index);
}
return _binder.GetByRefArray(retValues);
}
}
internal static void Initialize(IronSchemeLanguageProvider ironSchemeLanguageProvider)
{
lp = ironSchemeLanguageProvider;
se = lp.GetEngine() as IronSchemeScriptEngine;
scriptmodule = ScriptDomainManager.CurrentManager.Host.DefaultModule as ScriptModule;
ModuleContext mc = new ModuleContext(scriptmodule);
mc.CompilerContext = new CompilerContext(SourceUnit.CreateSnippet(se, ""));
cc = new CodeContext(scriptmodule.Scope, se.GetLanguageContext(), mc);
binder = new IronScheme.Actions.IronSchemeActionBinder(cc);
Generator.initme = true;
}
public static void AddGenerators(CodeContext cc, Assembly assembly)
{
foreach (Type t in assembly.GetExportedTypes())
{
if (Attribute.IsDefined(t, typeof(GeneratorAttribute)))
{
IGenerator g = Activator.CreateInstance(t) as IGenerator;
foreach (GeneratorAttribute ga in t.GetCustomAttributes(typeof(GeneratorAttribute), false))
{
string name = ga.Name;
object s = SymbolTable.StringToObject(name);
cc.Scope.SetName((SymbolId)s, g);
}
}
}
}
internal override bool TrySetValue(CodeContext context, object instance, PythonType owner, object value) {
if (Setter.Length == 0) {
return false;
}
if (instance == null) {
foreach (MethodInfo mi in Setter) {
if(mi.IsStatic && DeclaringType != owner.UnderlyingSystemType) {
return false;
} else if (mi.IsProtected()) {
throw PythonOps.TypeErrorForProtectedMember(owner.UnderlyingSystemType, _info.Name);
}
}
} else if (instance != null) {
foreach (MethodInfo mi in Setter) {
if (mi.IsStatic) {
return false;
}
}
}
return CallSetter(context, PythonContext.GetContext(context).GetGenericCallSiteStorage(), instance, ArrayUtils.EmptyObjects, value);
}
internal override bool TryGetValue(CodeContext context, object instance, PythonType owner, out object value) {
PerfTrack.NoteEvent(PerfTrack.Categories.Properties, this);
value = CallGetter(context, owner, PythonContext.GetContext(context).GetGenericCallSiteStorage0(), instance);
return true;
}
public string/*!*/ __repr__(CodeContext/*!*/ context) {
return string.Format("<property# {0} on {1}>",
__name__,
DynamicHelpers.GetPythonTypeFromType(DeclaringType).Name);
}
public void __set__(CodeContext context, object instance, object value) {
// TODO: Throw? currently we have a test that verifies we never throw when this is called directly.
TrySetValue(context, instance, DynamicHelpers.GetPythonType(instance), value);
}
public void SetValue(CodeContext context, object instance, object value) {
if (!TrySetValue(context, instance, DynamicHelpers.GetPythonType(instance), value)) {
throw new InvalidOperationException("cannot set property");
}
}
public DefaultActionBinder(CodeContext context, Type[] extensionTypes)
: base(context)
{
this._extensionTypes = extensionTypes;
}
public IList<object> GetCustomMemberNames(CodeContext context) {
List<object> ret;
if (!context.ModuleContext.ShowCls) {
ret = new List<object>();
foreach (KeyValuePair<object, object> kvp in Scope.GetAllItems(context.LanguageContext)) {
if(kvp.Value != Uninitialized.Instance) {
if (kvp.Key is SymbolId) {
ret.Add(SymbolTable.IdToString((SymbolId)kvp.Key));
} else {
ret.Add(kvp.Key);
}
}
}
} else {
ret = new List<object>(Scope.GetAllKeys(context.LanguageContext));
}
return ret;
}
private object CallGetter(CodeContext context, PythonType owner, SiteLocalStorage<CallSite<Func<CallSite, CodeContext, object, object>>> storage, object instance) {
if (NeedToReturnProperty(instance, Getter)) {
return this;
}
if (Getter.Length == 0) {
throw new MissingMemberException("unreadable property");
}
if (owner == null) {
owner = DynamicHelpers.GetPythonType(instance);
}
// this matches the logic in the default binder when it does a property get. We
// need to duplicate it here to be consistent for all gets.
MethodInfo[] members = Getter;
Type type = owner.UnderlyingSystemType;
if (Getter.Length > 1) {
// if we were given multiple members pick the member closest to the type...
Type bestMemberDeclaringType = Getter[0].DeclaringType;
MethodInfo bestMember = Getter[0];
for (int i = 1; i < Getter.Length; i++) {
MethodInfo mt = Getter[i];
if (!IsApplicableForType(type, mt)) {
continue;
}
if (Getter[i].DeclaringType.IsSubclassOf(bestMemberDeclaringType) ||
!IsApplicableForType(type, bestMember)) {
bestMember = Getter[i];
bestMemberDeclaringType = Getter[i].DeclaringType;
}
}
members = new MethodInfo[] { bestMember };
}
BuiltinFunction target = PythonTypeOps.GetBuiltinFunction(type, __name__, members);
return target.Call0(context, storage, instance);
}
public void SetVariable(CodeContext context, SymbolId name, object value)
{
_manager.SetVariable(context, name, value);
}
public object GetVariable(CodeContext context, SymbolId name)
{
return _manager.GetVariable(context, name);
}
/// <summary>
/// Create a context for keeping track of allocated temporary variables inside of TemporaryStorage.
/// When this function is called, the variables given by paramVars will be set to the values given by paramValues;
/// when the returned object is disposed of, the supplied paramVars and tempVars variables will be removed from temporary storage.
/// </summary>
internal CodeContext GetTemporaryVariableContext(CodeContext context, Variable[] paramVars, object[] paramValues) {
Debug.Assert(paramVars.Length == paramValues.Length);
Scope scope = CloneForTemporaries();
context = new CodeContext(scope, context.LanguageContext, context.ModuleContext);
for (int i = 0; i < paramValues.Length; i++) {
scope.TemporaryStorage[paramVars[i]] = paramValues[i];
}
return context;
}
public object GetCustomMember(CodeContext context, string name) {
object value;
if (Scope.TryGetName(context.LanguageContext, SymbolTable.StringToId(name), out value)) {
if (value != Uninitialized.Instance) {
return value;
}
}
return null;
}
internal override bool TryDeleteValue(CodeContext context, object instance, PythonType owner) {
__delete__(instance);
return true;
}
public bool DeleteMember(CodeContext context, string name) {
if (Scope.TryRemoveName(context.LanguageContext, SymbolTable.StringToId(name))) {
OnModuleChange(new ModuleChangeEventArgs(SymbolTable.StringToId(name), ModuleChangeType.Delete));
return true;
}
return false;
}
internal override bool IsSetDescriptor(CodeContext context, PythonType owner) {
return Setter.Length != 0;
}
protected override IList<object> Ops_GetAttrNames(CodeContext context, object obj)
{
Callable c = context.Scope.LookupName(SymbolTable.StringToId("int-env-syms")) as Callable;
Cons ids = c.Call() as Cons;
List<object> names = new List<object>(ids);
names.Sort(delegate(object o, object p) { return o.ToString().CompareTo(p.ToString()); });
return names;
}
private List<Scope> GenerateScriptScopes()
{
List<Scope> scopes = new List<Scope>(_scriptCodes.Length);
ScriptModule sm = ScriptDomainManager.CurrentManager.Host.DefaultModule as ScriptModule;
for (int i = 0; i < _scriptCodes.Length; i++) {
ScriptCode scriptCode = _scriptCodes[i];
// Force creation of names used in other script codes into all optimized dictionaries
ScopeAllocator allocator = _allocators[scriptCode.LanguageContext];
IAttributesCollection iac = CreateLanguageDictionary(scriptCode.LanguageContext, allocator);
Scope scope = new Scope(sm.Scope, iac);
// module context is filled later:
CodeContext codeContext = new CodeContext(scope, scriptCode.LanguageContext);
IModuleDictionaryInitialization ici = iac as IModuleDictionaryInitialization;
if (ici != null) {
ici.InitializeModuleDictionary(codeContext);
}
scopes.Add(scope);
_codeContexts.Add(codeContext);
}
return scopes;
}
