// thread-safe: // Returns null on success, the lexically inner-most module on failure. internal RubyModule TryResolveConstantNoLock(RubyGlobalScope autoloadScope, string /*!*/ name, out ConstantStorage result) { var context = RubyContext; context.RequiresClassHierarchyLock(); RubyScope scope = this; // lexical lookup first: RubyModule innerMostModule = null; do { RubyModule module = scope.Module; if (module != null) { Debug.Assert(module.Context == context); if (module.TryGetConstantNoLock(autoloadScope, name, out result)) { return(null); } // remember the module: if (innerMostModule == null) { innerMostModule = module; } } scope = scope.Parent; } while (scope != null); // check the inner most module and it's base classes/mixins: if (innerMostModule != null) { if (innerMostModule.TryResolveConstantNoLock(autoloadScope, name, out result)) { return(null); } } else { innerMostModule = context.ObjectClass; } if (context.ObjectClass.TryResolveConstantNoLock(autoloadScope, name, out result)) { return(null); } return(innerMostModule); }
public RubyConstructor(RubyGlobalScope/*!*/ scope, NodeProvider/*!*/ nodeProvider) : base(nodeProvider, scope) { _newSite = CallSite<Func<CallSite, RubyModule, object, object, object, object>>.Create( RubyCallAction.Make(scope.Context, "new", RubyCallSignature.WithImplicitSelf(3)) ); _yamlInitializeSite = CallSite<Func<CallSite, object, object, Hash, object>>.Create( RubyCallAction.Make(scope.Context, "yaml_initialize", RubyCallSignature.WithImplicitSelf(3)) ); }
public void OverloadResolution_Block() { var t = GetType(); var gse = new RubyGlobalScope(Context, new Scope(), new object(), true); var scope = new RubyTopLevelScope(gse, null, new SymbolDictionary()); var proc = new Proc(ProcKind.Proc, null, scope, new BlockDispatcher0((x, y) => null, BlockSignatureAttributes.None)); var scopeArg = new DynamicMetaObject(Ast.Constant(proc.LocalScope), BindingRestrictions.Empty, proc.LocalScope); var contextArg = new DynamicMetaObject(Ast.Constant(Context), BindingRestrictions.Empty, Context); var instanceInt = new DynamicMetaObject(Ast.Constant(1), BindingRestrictions.Empty, 1); var str = "foo"; var instanceStr = new DynamicMetaObject(Ast.Constant(str), BindingRestrictions.Empty, str); var procArg = new DynamicMetaObject(Ast.Constant(proc), BindingRestrictions.Empty, proc); var nullArg = new DynamicMetaObject(Ast.Constant(Ast.Constant(null)), BindingRestrictions.Empty, null); var arguments = new[] { // 1.times new CallArguments(scopeArg, instanceInt, new DynamicMetaObject[0], RubyCallSignature.WithScope(0)), // 1.times &nil new CallArguments(scopeArg, instanceInt, new[] { nullArg }, RubyCallSignature.WithScopeAndBlock(0)), // 1.times &p new CallArguments(contextArg, instanceInt, new[] { procArg }, RubyCallSignature.WithBlock(0)), // obj.times &p new CallArguments(contextArg, instanceStr, new[] { procArg }, RubyCallSignature.WithBlock(0)), }; var results = new[] { "Times2", "Times1", "Times3", "Times4", }; for (int i = 0; i < arguments.Length; i++) { var bindingTarget = RubyMethodGroupInfo.ResolveOverload("times", new[] { t.GetMethod("Times1"), t.GetMethod("Times2"), t.GetMethod("Times3"), t.GetMethod("Times4"), }, arguments[i], true, false); Assert(bindingTarget.Success); Assert(bindingTarget.Method.Name == results[i]); } }
internal bool TryResolveConstant(RubyContext/*!*/ callerContext, RubyGlobalScope autoloadScope, string/*!*/ name, out ConstantStorage value) { return callerContext != Context ? TryResolveConstant(autoloadScope, name, out value) : TryResolveConstantNoLock(autoloadScope, name, out value); }
public bool Load(RubyGlobalScope/*!*/ autoloadScope) { if (_loaded) { return false; } using (autoloadScope.Context.ClassHierarchyUnlocker()) { _loaded = true; return autoloadScope.Context.Loader.LoadFile(autoloadScope.Scope, null, _path, LoadFlags.LoadOnce | LoadFlags.AppendExtensions); } }
internal MarshalReader(ReaderSites/*!*/ sites, BinaryReader/*!*/ reader, RubyGlobalScope/*!*/ globalScope, Proc proc) { _sites = sites; _reader = reader; _globalScope = globalScope; _proc = proc; _symbols = new Dictionary<int, Symbol>(); _objects = new Dictionary<int, object>(); }
/// <summary> /// Get constant defined in this module or any of its ancestors. /// </summary> public bool TryResolveConstant(RubyGlobalScope autoloadScope, string/*!*/ name, out object value) { return TryLookupConstant(true, true, autoloadScope, name, out value) != ConstantLookupResult.NotFound; }
// thread-safe: // Returns null on success, the lexically inner-most module on failure. internal RubyModule TryResolveConstantNoLock(RubyGlobalScope autoloadScope, string/*!*/ name, out ConstantStorage result) { var context = RubyContext; context.RequiresClassHierarchyLock(); RubyScope scope = this; // lexical lookup first: RubyModule innerMostModule = null; do { RubyModule module = scope.Module; if (module != null) { if (module.TryGetConstant(context, autoloadScope, name, out result)) { return null; } // remember the module: if (innerMostModule == null) { innerMostModule = module; } } scope = scope.Parent; } while (scope != null); // check the inner most module and it's base classes/mixins: if (innerMostModule != null) { if (innerMostModule.TryResolveConstant(context, autoloadScope, name, out result)) { return null; } } else { innerMostModule = context.ObjectClass; } if (context.ObjectClass.TryResolveConstant(context, autoloadScope, name, out result)) { return null; } return innerMostModule; }
/// <summary> /// Get constant defined in this module or any of its ancestors. /// </summary> internal bool TryResolveConstantNoLock(RubyGlobalScope autoloadScope, string/*!*/ name, out ConstantStorage value) { Context.RequiresClassHierarchyLock(); return TryLookupConstantNoLock(true, true, autoloadScope, name, out value) != ConstantLookupResult.NotFound; }
public RubyConstructor(RubyGlobalScope/*!*/ scope, NodeProvider/*!*/ nodeProvider) : base(nodeProvider, scope) { AddConstructor("tag:yaml.org,2002:str", ConstructRubyScalar); AddConstructor("tag:ruby.yaml.org,2002:range", ConstructRubyRange); AddConstructor("tag:ruby.yaml.org,2002:regexp", ConstructRubyRegexp); AddMultiConstructor("tag:ruby.yaml.org,2002:object:", ConstructPrivateObject); AddMultiConstructor("tag:ruby.yaml.org,2002:struct:", ConstructRubyStruct); AddConstructor("tag:yaml.org,2002:binary", ConstructRubyBinary); AddConstructor("tag:yaml.org,2002:timestamp#ymd", ConstructRubyTimestampYMD); //AddConstructor("tag:yaml.org,2002:omap", ConstructRubyOmap); //AddMultiConstructor("tag:yaml.org,2002:seq:", ConstructSpecializedRubySequence); //AddMultiConstructor("tag:yaml.org,2002:map:", ConstructSpecializedRubyMap); }
/// <summary> /// Get constant defined in this module. /// </summary> public bool TryGetConstantNoLock(RubyGlobalScope autoloadScope, string/*!*/ name, out object value) { Context.RequiresClassHierarchyLock(); return TryLookupConstantNoLock(false, false, autoloadScope, name, out value) != ConstantLookupResult.NotFound; }
/// <summary> /// Get constant defined in this module. /// </summary> public bool TryGetConstant(RubyGlobalScope autoloadScope, string/*!*/ name, out object value) { using (Context.ClassHierarchyLocker()) { return TryGetConstantNoLock(autoloadScope, name, out value); } }
public RubyConstructor(RubyGlobalScope/*!*/ scope, NodeProvider/*!*/ nodeProvider) : base(nodeProvider, scope) { }
private ConstantLookupResult TryLookupConstant(bool included, bool inherited, RubyGlobalScope autoloadScope, string/*!*/ name, out object value) { Debug.Assert(included || !inherited); value = null; while (true) { object result; bool found = included ? TryResolveConstantNoAutoloadCheck(inherited, name, out result) : TryGetConstantNoAutoloadCheck(name, out result); if (!found) { return ConstantLookupResult.NotFound; } var autoloaded = result as AutoloadedConstant; if (autoloaded == null) { value = result; return ConstantLookupResult.Found; } if (autoloadScope == null) { return ConstantLookupResult.FoundAutoload; } // autoloaded constants are removed before the associated file is loaded: RemoveConstant(name); // load file and try lookup again: if (!autoloaded.Load(autoloadScope)) { return ConstantLookupResult.NotFound; } } }
public bool TryGetConstant(RubyGlobalScope autoloadScope, string/*!*/ name, out object value) { ConstantStorage storage; var result = TryGetConstant(autoloadScope, name, out storage); value = storage.Value; return result; }
/// <summary> /// Get constant defined in this module or any of its ancestors. /// Autoloads if autoloadScope is not null. /// </summary> /// <remarks> /// Thread safe. /// </remarks> internal bool TryResolveConstant(RubyGlobalScope autoloadScope, string/*!*/ name, out ConstantStorage value) { using (Context.ClassHierarchyLocker()) { return TryResolveConstantNoLock(autoloadScope, name, out value); } }
public SafeConstructor(/*!*/NodeProvider nodeProvider, RubyGlobalScope/*!*/ scope) : base(nodeProvider, scope) { }
private ConstantLookupResult TryLookupConstantNoLock(bool included, bool inherited, RubyGlobalScope autoloadScope, string/*!*/ name, out ConstantStorage value) { Context.RequiresClassHierarchyLock(); Debug.Assert(included || !inherited); value = default(ConstantStorage); while (true) { ConstantStorage result; RubyModule owner = included ? TryResolveConstantNoAutoloadCheck(inherited, name, out result) : (TryGetConstantNoAutoloadCheck(name, out result) ? this : null); if (owner == null) { return ConstantLookupResult.NotFound; } var autoloaded = result.Value as AutoloadedConstant; if (autoloaded == null) { value = result; return ConstantLookupResult.Found; } if (autoloadScope == null) { return ConstantLookupResult.FoundAutoload; } if (autoloadScope.Context != Context) { throw RubyExceptions.CreateTypeError(String.Format("Cannot autoload constants to a foreign runtime #{0}", autoloadScope.Context.RuntimeId)); } // autoloaded constants are removed before the associated file is loaded: object _; owner.TryRemoveConstantNoLock(name, out _); // load file and try lookup again (releases the class hierarchy lock when loading the file): if (!autoloaded.Load(autoloadScope)) { return ConstantLookupResult.NotFound; } } }
private static RubyConstructor/*!*/ MakeConstructor(RubyGlobalScope/*!*/ scope, TextReader/*!*/ reader) { return new RubyConstructor(scope, MakeComposer(reader)); }
public Constructor(NodeProvider/*!*/ nodeProvider, RubyGlobalScope/*!*/ scope) : base(nodeProvider, scope) { }
private static RubyConstructor/*!*/ MakeConstructor(RubyGlobalScope/*!*/ scope, Stream/*!*/ stream) { return new RubyConstructor(scope, MakeComposer(scope.Context, stream)); }
internal void SetGlobalScope(RubyGlobalScope/*!*/ value) { Assert.NotNull(value); _globalScope = value; }
public bool Load(RubyGlobalScope/*!*/ autoloadScope) { if (_loaded) { return false; } _loaded = true; return autoloadScope.Context.Loader.LoadFile(autoloadScope.Scope, null, _path, LoadFlags.LoadOnce | LoadFlags.AppendExtensions); }