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