internal static RubyClass /*!*/ DefineClass(Scope /*!*/ autoloadScope, RubyModule /*!*/ owner, string /*!*/ name, object superClassObject) { Assert.NotNull(owner); RubyClass superClass = ToSuperClass(owner.Context, superClassObject); object existing; if (ReferenceEquals(owner, owner.Context.ObjectClass) ? owner.TryResolveConstant(autoloadScope, name, out existing) : owner.TryGetConstant(autoloadScope, name, out existing)) { RubyClass cls = existing as RubyClass; if (cls == null || !cls.IsClass) { throw RubyExceptions.CreateTypeError(String.Format("{0} is not a class", name)); } if (superClassObject != null && !ReferenceEquals(cls.SuperClass, superClass)) { throw RubyExceptions.CreateTypeError(String.Format("superclass mismatch for class {0}", name)); } return(cls); } else { return(owner.Context.DefineClass(owner, name, superClass)); } }
// 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); }
public static Object Scan(ConversionStorage <MutableString> /*!*/ toMutableStringStorage, RespondToStorage /*!*/ respondsTo, BinaryOpStorage /*!*/ readIOStorage, BlockParam block, RubyModule /*!*/ self, Object /*!*/ source, Hash /*!*/ options) { Object elementContent; if (!self.TryGetConstant(null, "ElementContent", out elementContent) && !(elementContent is Hash)) { throw new Exception("Hpricot::ElementContent is missing or it is not an Hash"); } var scanner = new HpricotScanner(toMutableStringStorage, readIOStorage, block); return(scanner.Scan(source, options, elementContent as Hash)); }
internal static RubyModule /*!*/ DefineModule(Scope /*!*/ autoloadScope, RubyModule /*!*/ owner, string /*!*/ name) { Assert.NotNull(autoloadScope, owner); object existing; if (owner.TryGetConstant(autoloadScope, name, out existing)) { RubyModule module = existing as RubyModule; if (module == null || module.IsClass) { throw RubyExceptions.CreateTypeError(String.Format("{0} is not a module", name)); } return(module); } else { // create class/module object: return(owner.Context.DefineModule(owner, name)); } }
public bool TryResolveConstant(bool autoload, string /*!*/ name, out object result) { Scope autoloadScope = autoload ? GlobalScope : null; RubyScope scope = this; // lexical lookup first: RubyModule innerMostModule = null; do { RubyModule module = scope.Module; if (module != null) { if (module.TryGetConstant(autoloadScope, name, out result)) { return(true); } // remember the module: if (innerMostModule == null) { innerMostModule = module; } } scope = (RubyScope)scope.Parent; } while (scope != null); // check the inner most module and it's base classes/mixins: if (innerMostModule != null && innerMostModule.TryResolveConstant(autoloadScope, name, out result)) { return(true); } return(RubyContext.ObjectClass.TryResolveConstant(autoloadScope, name, out result)); }