C# Scripting.CodeContext类代码示例

 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;
 }

 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);
 }