bool Weapon::hasRangedAttack() const {
for(uint n = 0; n < count<AttackMode>(); n++) {
AttackMode mode = (AttackMode)n;
if(isRanged(mode) && proto().attack_modes & toFlags(mode))
return true;
}
return false;
}
JSObject* constructRegExp(ExecState* exec, JSGlobalObject* globalObject, const ArgList& args, JSObject* callee, JSValue newTarget)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSValue patternArg = args.at(0);
JSValue flagsArg = args.at(1);
bool isPatternRegExp = patternArg.inherits(vm, RegExpObject::info());
bool constructAsRegexp = isRegExp(vm, exec, patternArg);
RETURN_IF_EXCEPTION(scope, nullptr);
if (newTarget.isUndefined() && constructAsRegexp && flagsArg.isUndefined()) {
JSValue constructor = patternArg.get(exec, vm.propertyNames->constructor);
RETURN_IF_EXCEPTION(scope, nullptr);
if (callee == constructor) {
// We know that patternArg is a object otherwise constructAsRegexp would be false.
return patternArg.getObject();
}
}
if (isPatternRegExp) {
RegExp* regExp = jsCast<RegExpObject*>(patternArg)->regExp();
Structure* structure = getRegExpStructure(exec, globalObject, newTarget);
RETURN_IF_EXCEPTION(scope, nullptr);
if (!flagsArg.isUndefined()) {
RegExpFlags flags = toFlags(exec, flagsArg);
ASSERT(!!scope.exception() == (flags == InvalidFlags));
if (flags == InvalidFlags)
return nullptr;
regExp = RegExp::create(vm, regExp->pattern(), flags);
}
return RegExpObject::create(vm, structure, regExp);
}
if (constructAsRegexp) {
JSValue pattern = patternArg.get(exec, vm.propertyNames->source);
RETURN_IF_EXCEPTION(scope, nullptr);
if (flagsArg.isUndefined()) {
flagsArg = patternArg.get(exec, vm.propertyNames->flags);
RETURN_IF_EXCEPTION(scope, nullptr);
}
patternArg = pattern;
}
scope.release();
return regExpCreate(exec, globalObject, newTarget, patternArg, flagsArg);
}
JSValue JSDirectoryEntry::getDirectory(ExecState* exec)
{
DirectoryEntry* imp = static_cast<DirectoryEntry*>(impl());
const String& path = valueToStringWithUndefinedOrNullCheck(exec, exec->argument(0));
if (exec->hadException())
return jsUndefined();
int argsCount = exec->argumentCount();
if (argsCount <= 1) {
imp->getDirectory(path);
return jsUndefined();
}
RefPtr<Flags> flags;
if (!exec->argument(1).isNull() && !exec->argument(1).isUndefined() && exec->argument(1).isObject() && !exec->argument(1).inherits(&JSFlags::s_info)) {
JSObject* object = exec->argument(1).getObject();
flags = Flags::create();
JSValue jsCreate = object->get(exec, Identifier(exec, "create"));
flags->setCreate(jsCreate.toBoolean(exec));
JSValue jsExclusive = object->get(exec, Identifier(exec, "exclusive"));
flags->setExclusive(jsExclusive.toBoolean(exec));
} else
flags = toFlags(exec->argument(1));
if (exec->hadException())
return jsUndefined();
RefPtr<EntryCallback> successCallback;
if (exec->argumentCount() > 2 && !exec->argument(2).isNull() && !exec->argument(2).isUndefined()) {
if (!exec->argument(2).isObject()) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
successCallback = JSEntryCallback::create(asObject(exec->argument(2)), globalObject());
}
RefPtr<ErrorCallback> errorCallback;
if (exec->argumentCount() > 3 && !exec->argument(3).isNull() && !exec->argument(3).isUndefined()) {
if (!exec->argument(3).isObject()) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
errorCallback = JSErrorCallback::create(asObject(exec->argument(3)), globalObject());
}
imp->getDirectory(path, flags, successCallback, errorCallback);
return jsUndefined();
}
static JSObject* regExpCreate(ExecState* exec, JSGlobalObject* globalObject, JSValue newTarget, JSValue patternArg, JSValue flagsArg)
{
VM& vm = exec->vm();
String pattern = patternArg.isUndefined() ? emptyString() : patternArg.toString(exec)->value(exec);
if (exec->hadException())
return nullptr;
RegExpFlags flags = toFlags(exec, flagsArg);
if (flags == InvalidFlags)
return nullptr;
RegExp* regExp = RegExp::create(vm, pattern, flags);
if (!regExp->isValid())
return vm.throwException(exec, createSyntaxError(exec, regExp->errorMessage()));
Structure* structure = getRegExpStructure(exec, globalObject, newTarget);
if (vm.exception())
return nullptr;
return RegExpObject::create(vm, structure, regExp);
}
static JSObject* regExpCreate(ExecState* exec, JSGlobalObject* globalObject, JSValue newTarget, JSValue patternArg, JSValue flagsArg)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
String pattern = patternArg.isUndefined() ? emptyString() : patternArg.toWTFString(exec);
RETURN_IF_EXCEPTION(scope, nullptr);
RegExpFlags flags = toFlags(exec, flagsArg);
ASSERT(!!scope.exception() == (flags == InvalidFlags));
if (UNLIKELY(flags == InvalidFlags))
return nullptr;
RegExp* regExp = RegExp::create(vm, pattern, flags);
if (!regExp->isValid())
return throwException(exec, scope, createSyntaxError(exec, regExp->errorMessage()));
Structure* structure = getRegExpStructure(exec, globalObject, newTarget);
RETURN_IF_EXCEPTION(scope, nullptr);
return RegExpObject::create(vm, structure, regExp);
}
int issetTTyMode(void *sg,const char *mode){
int flags = 0;
flags = toFlags(flags,mode);
return ((XSgttyb*)sg)->x_sg.SG_flags & flags;
}
