bool WFormModel::validateField(Field field)
{
if (!isVisible(field))
return true;
FieldMap::iterator i = fields_.find(field);
if (i != fields_.end()) {
FieldData& d = i->second;
if (d.validator)
setValidation(field, d.validator->validate(asString(valueText(field))));
else
setValidation(field, Valid);
return d.validation.state() == WValidator::Valid;
} else
return true;
}
void SetFieldValueAST::typeCheck(TypeChecker& checker) {
mObjectRefExpression->typeCheck(checker);
std::shared_ptr<Type> objRefType;
if (auto varRef = std::dynamic_pointer_cast<VariableReferenceExpressionAST>(mObjectRefExpression)) {
auto varSymbol = std::dynamic_pointer_cast<VariableSymbol>(mSymbolTable->find(varRef->name()));
objRefType = checker.findType(varSymbol->variableType());
} else if (auto arrayRef = std::dynamic_pointer_cast<ArrayAccessAST>(mObjectRefExpression)) {
objRefType = arrayRef->expressionType(checker);
} else {
checker.typeError("Not implemented");
}
auto memberName = getMemberName();
std::string objName = objRefType->name();
if (!checker.objectExists(objName)) {
checker.typeError(objRefType->name() + " is not an object type.");
}
auto& object = checker.getObject(objName);
if (!object.fieldExists(memberName)) {
checker.typeError("There exists no field '" + memberName + "' in the type '" + objRefType->name() + "'.");
}
mRightHandSide->typeCheck(checker);
//Check rhs
std::shared_ptr<Type> fieldType;
if (std::dynamic_pointer_cast<ArrayAccessAST>(mMemberExpression)) {
fieldType = std::dynamic_pointer_cast<ArrayType>(object.getField(memberName).type())->elementType();
} else {
fieldType = object.getField(memberName).type();
}
checker.assertSameType(
*fieldType,
*mRightHandSide->expressionType(checker),
asString());
}
string RinexMetHeader::convertObsType(const RinexMetHeader::RinexMetType& oneObs)
throw(FFStreamError)
{
if (oneObs == PR) return "PR";
else if (oneObs == TD) return "TD";
else if (oneObs == HR) return "HR";
else if (oneObs == ZW) return "ZW";
else if (oneObs == ZD) return "ZD";
else if (oneObs == ZT) return "ZT";
else if (oneObs == WD) return "WD";
else if (oneObs == WS) return "WS";
else if (oneObs == RI) return "RI";
else if (oneObs == HI) return "HI";
else
{
FFStreamError e("Bad obs type:" + asString(oneObs));
GPSTK_THROW(e);
}
}
void TextureItem::draw(const Rect& area, WidgetState state) const
{
Drawer& drawer = m_layer.drawer();
if (state == STATE_SELECTED)
{
const vec3 color = drawer.theme().textColors[STATE_SELECTED];
drawer.fillRectangle(area, vec4(color, 1.f));
}
const float em = drawer.currentEM();
const Rect textureArea(area.position, vec2(em * 3.f));
drawer.blitTexture(textureArea, *m_texture);
const Rect textArea(area.position + vec2(em * 3.5f, 0.f),
area.size - vec2(em, 0.f));
drawer.drawText(textArea, asString().c_str(), LEFT_ALIGNED, state);
}
EncodedJSValue DFG_OPERATION operationGetByValCell(ExecState* exec, JSCell* base, EncodedJSValue encodedProperty)
{
JSValue property = JSValue::decode(encodedProperty);
if (property.isUInt32())
return getByVal(exec, base, property.asUInt32());
if (property.isDouble()) {
double propertyAsDouble = property.asDouble();
uint32_t propertyAsUInt32 = static_cast<uint32_t>(propertyAsDouble);
if (propertyAsUInt32 == propertyAsDouble)
return getByVal(exec, base, propertyAsUInt32);
} else if (property.isString()) {
if (JSValue result = base->fastGetOwnProperty(exec, asString(property)->value(exec)))
return JSValue::encode(result);
}
Identifier ident(exec, property.toString(exec));
return JSValue::encode(JSValue(base).get(exec, ident));
}
void Logger::write(Level level, const std::string& message) {
if(level < level_) return;
char buf[20];
time_t t = time(0);
struct tm tm;
strftime(&buf[0], sizeof(buf), "%F %T", localtime_r(&t, &tm));
std::stringstream s;
s << asString(level) << " " << buf << " " << prefix_
<< "[" << getpid() << ":" << boost::this_thread::get_id() << "]: "
<< message << std::endl;
if(log_.get() != -1) {
while(log_.write(s.str().c_str(), s.str().size()) == -1);
}
if(isatty(2) == 1) {
::write(2, s.str().c_str(), s.str().size());
}
}
SEXP
RGDAL_GetDriver(SEXP sxpDriverName) {
const char *pDriverName = asString(sxpDriverName);
installErrorHandler();
GDALDriver *pDriver = (GDALDriver *) GDALGetDriverByName(pDriverName);
uninstallErrorHandlerAndTriggerError();
if (pDriver == NULL)
error("No driver registered with name: %s\n", pDriverName);
SEXP sxpHandle = R_MakeExternalPtr((void *) pDriver,
mkChar("GDAL Driver"),
R_NilValue);
return(sxpHandle);
}
/**
\fn makeCouples
\brief convert couples into char *first and *couples c, c can be null
*/
bool TinyParams::makeCouples(CONFcouple **c)
{
int nb = nbParamsLeft();
if (!nb)
{
*c = NULL;
return true;
}
const char **s;
s=(const char **)admAlloca(sizeof(char *)*nb);
for (int i = 0; i < nb; i++)
{
s[i] = asString();
}
return stringsToConfCouple(nb, c, s);
}
/// Converts the CommonTime \a dt into a Rinex3 Clock time
/// string for the header
string Rinex3ClockHeader::writeTime(const CommonTime& dt) const
{
if (dt == CommonTime::BEGINNING_OF_TIME)
{
return string(36, ' ');
}
string line;
CivilTime civTime(dt);
line = rightJustify(asString<short>(civTime.year), 4);
line += rightJustify(asString<short>(civTime.month), 3);
line += rightJustify(asString<short>(civTime.day), 3);
line += rightJustify(asString<short>(civTime.hour), 3);
line += rightJustify(asString<short>(civTime.minute), 3);
line += rightJustify(asString(civTime.second, 6), 10);
return line;
} // End of method 'Rinex3ClockHeader::writeTime(const CommonTime& dt)'
MapData::Entry* MapData::find(CallFrame* callFrame, KeyType key)
{
if (key.value.isString()) {
auto iter = m_stringKeyedTable.find(asString(key.value)->value(callFrame).impl());
if (iter == m_stringKeyedTable.end())
return 0;
return &m_entries[iter->value];
}
if (key.value.isCell()) {
auto iter = m_cellKeyedTable.find(key.value.asCell());
if (iter == m_cellKeyedTable.end())
return 0;
return &m_entries[iter->value];
}
auto iter = m_valueKeyedTable.find(JSValue::encode(key.value));
if (iter == m_valueKeyedTable.end())
return 0;
return &m_entries[iter->value];
}
JSC::JSInternalPromise* ScriptModuleLoader::fetch(JSC::JSGlobalObject* jsGlobalObject, JSC::ExecState* exec, JSC::JSModuleLoader*, JSC::JSValue moduleKeyValue, JSC::JSValue initiator)
{
auto& globalObject = *JSC::jsCast<JSDOMGlobalObject*>(jsGlobalObject);
auto& jsPromise = *JSC::JSInternalPromiseDeferred::create(exec, &globalObject);
auto deferred = DeferredPromise::create(globalObject, jsPromise);
if (moduleKeyValue.isSymbol()) {
deferred->reject(TypeError, ASCIILiteral("Symbol module key should be already fulfilled with the inlined resource."));
return jsPromise.promise();
}
if (!moduleKeyValue.isString()) {
deferred->reject(TypeError, ASCIILiteral("Module key is not Symbol or String."));
return jsPromise.promise();
}
// https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
URL completedURL(URL(), asString(moduleKeyValue)->value(exec));
if (!completedURL.isValid()) {
deferred->reject(TypeError, ASCIILiteral("Module key is a valid URL."));
return jsPromise.promise();
}
ASSERT_WITH_MESSAGE(JSC::jsDynamicCast<JSElement*>(initiator), "Initiator should be an JSElement");
auto* scriptElement = toScriptElementIfPossible(&JSC::jsCast<JSElement*>(initiator)->wrapped());
ASSERT_WITH_MESSAGE(scriptElement, "Initiator should be ScriptElement.");
if (auto* frame = m_document.frame()) {
auto loader = CachedModuleScriptLoader::create(*this, deferred.get());
m_loaders.add(loader.copyRef());
if (!loader->load(*scriptElement, completedURL)) {
loader->clearClient();
m_loaders.remove(WTFMove(loader));
deferred->reject(frame->script().moduleLoaderAlreadyReportedErrorSymbol());
return jsPromise.promise();
}
}
return jsPromise.promise();
}
SEXP
RGDAL_GetMetadata(SEXP sxpObj, SEXP sxpDomain) {
void *pGDALObj = getGDALObjPtr(sxpObj);
const char *domain = asString(sxpDomain);
char **metadata = ((GDALMajorObject *)pGDALObj)->GetMetadata(domain);
if (metadata == NULL) return(R_NilValue);
metadata = CSLDuplicate(metadata);
SEXP sxpMetadata, sxpNames;
PROTECT(sxpMetadata = allocVector(VECSXP, CSLCount(metadata)));
PROTECT(sxpNames = allocVector(STRSXP, CSLCount(metadata)));
int i;
for (i = 0; i < CSLCount(metadata); ++i) {
const char *field = CSLGetField(metadata, i);
char *tag = NULL;
const char *value = CPLParseNameValue(field, &tag);
SET_VECTOR_ELT(sxpMetadata, i, value ? mkChar(value) : mkChar(""));
SET_STRING_ELT(sxpNames, i, tag ? mkChar(tag) : mkChar(""));
}
setAttrib(sxpMetadata, R_NamesSymbol, sxpNames);
UNPROTECT(2);
return(sxpMetadata);
}
bool Value::equals(Value& value)
{
if (isNull() && value.isNull())
return true;
switch (_type)
{
case type_int:
return (asInteger() == value.asInteger());
case type_text:
return (asString().compare(value.asString()) == 0);
case type_float:
return (asDouble() == value.asDouble());
case type_bool:
return (asBool() == value.asBool());
case type_time:
return (asTime() == value.asTime());
}
return false;
}
virtual void fire()
{
boost::python::handle<> aHandle(
PyEval_EvalCode(
reinterpret_cast< PyCodeObject* >( theCompiledExpression.get() ),
theGlobalNamespace.ptr(), theLocalNamespace.ptr() ) );
boost::python::object aResultObject( aHandle );
// do not use extract<double> for efficiency
if( ! PyFloat_Check( aResultObject.ptr() ) )
{
THROW_EXCEPTION_INSIDE( SimulationError,
asString() + ": "
"The expression gave a non-float object." );
}
const Real aFlux( PyFloat_AS_DOUBLE( aResultObject.ptr() ) );
setFlux( aFlux );
}
std::string TypeInfo::asDemangledString() const
{
#ifdef __GNUC__
if (stdInfo) {
std::string tmp;
int status;
char *demangled = abi::__cxa_demangle(stdInfo->name(), NULL, NULL, &status);
if (status == 0) {
tmp = demangled;
free(demangled);
return tmp;
} else {
return stdInfo->name();
}
} else {
return customInfo;
}
#else
return asString();
#endif
}
bool JSCryptoAlgorithmDictionary::getAlgorithmIdentifier(ExecState* exec, JSValue value, CryptoAlgorithmIdentifier& algorithmIdentifier)
{
// typedef (Algorithm or DOMString) AlgorithmIdentifier;
String algorithmName;
if (value.isString())
algorithmName = value.toString(exec)->value(exec);
else if (value.isObject()) {
if (value.getObject()->inherits(StringObject::info()))
algorithmName = asString(asStringObject(value)->internalValue())->value(exec);
else {
// FIXME: This doesn't perform some checks mandated by WebIDL for dictionaries:
// - null and undefined input should be treated as if all elements in the dictionary were undefined;
// - undefined elements should be treated as having a default value, or as not present if there isn't such;
// - RegExp and Date objects cannot be converted to dictionaries.
//
// This is partially because we don't implement it elsewhere in WebCore yet, and partially because
// WebCrypto doesn't yet clearly specify what to do with non-present values in most cases anyway.
JSDictionary dictionary(exec, value.getObject());
dictionary.get("name", algorithmName);
}
}
if (exec->hadException())
return false;
if (!algorithmName.containsOnlyASCII()) {
throwSyntaxError(exec);
return false;
}
if (!CryptoAlgorithmRegistry::singleton().getIdentifierForName(algorithmName, algorithmIdentifier)) {
setDOMException(exec, NOT_SUPPORTED_ERR);
return false;
}
return true;
}
void JSValue::dumpForBacktrace(PrintStream& out) const
{
if (!*this)
out.print("<JSValue()>");
else if (isInt32())
out.printf("%d", asInt32());
else if (isDouble())
out.printf("%lf", asDouble());
else if (isCell()) {
if (asCell()->inherits(*asCell()->vm(), JSString::info())) {
JSString* string = asString(asCell());
const StringImpl* impl = string->tryGetValueImpl();
if (impl)
out.print("\"", impl, "\"");
else
out.print("(unresolved string)");
} else if (asCell()->inherits(*asCell()->vm(), Structure::info())) {
out.print("Structure[ ", asCell()->structure()->classInfo()->className);
#if USE(JSVALUE64)
out.print(" ID: ", asCell()->structureID());
#endif
out.print("]: ", RawPointer(asCell()));
} else {
out.print("Cell[", asCell()->structure()->classInfo()->className);
#if USE(JSVALUE64)
out.print(" ID: ", asCell()->structureID());
#endif
out.print("]: ", RawPointer(asCell()));
}
} else if (isTrue())
out.print("True");
else if (isFalse())
out.print("False");
else if (isNull())
out.print("Null");
else if (isUndefined())
out.print("Undefined");
else
out.print("INVALID");
}
bool VirtualValue::operator>=(const VirtualValue& that) const
{
ASSERT(!isArray() && !isObject() && !isBoolean());
ASSERT(mKind == that.mKind);
switch ( mKind )
{
case eNumber:
return asNumber() >= that.asNumber();
case eReal:
return asReal() >= that.asReal();
case eChar:
return asChar() >= that.asChar();
case eString:
return asString() >= that.asString();
}
return false;
}
numeric Item::forceNumeric() const
{
switch( type() ) {
case FLC_ITEM_INT:
return (numeric) asInteger();
case FLC_ITEM_NUM:
return asNumeric();
case FLC_ITEM_RANGE:
return (numeric) asRangeStart();
case FLC_ITEM_STRING:
{
double tgt;
if ( asString()->parseDouble( tgt ) )
return tgt;
return 0.0;
}
}
return 0.0;
}
Variable const* System::findSizeVariable() const
{
try
{
return getVariable( "SIZE" );
}
catch( NotFound const& )
{
System const* const aSuperSystem( getSuperSystem() );
// Prevent infinite looping. But this shouldn't happen.
if( aSuperSystem == this )
{
THROW_EXCEPTION_INSIDE( UnexpectedError,
asString() + ": while trying get a SIZE "
"variable, supersystem == this. "
"Probably a bug." );
}
return aSuperSystem->findSizeVariable();
}
}
int operator()()
{
js::mValue v;
string s = asString(contents("../../tests/rlptest.json"));
js::read_string(s, v);
bool passed = true;
for (auto& i: v.get_obj())
{
js::mObject& o = i.second.get_obj();
cnote << i.first;
RLPStream s;
buildRLP(o["in"], s);
if (!o["out"].is_null() && o["out"].get_str() != toHex(s.out()))
{
cwarn << "Test failed.";
cwarn << "Test says:" << o["out"].get_str();
cwarn << "Impl says:" << toHex(s.out());
passed = false;
}
}
return passed ? 0 : 1;
}
int64 Item::forceInteger() const
{
switch( type() ) {
case FLC_ITEM_INT:
return asInteger();
case FLC_ITEM_NUM:
return (int64) asNumeric();
case FLC_ITEM_RANGE:
return (int64)asRangeStart();
case FLC_ITEM_STRING:
{
int64 tgt;
if ( asString()->parseInt( tgt ) )
return tgt;
return 0;
}
}
return 0;
}
SEXP
RGDAL_SetCategoryNames(SEXP sxpRasterBand, SEXP sxpNames) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
char **nameList = NULL;
int i;
installErrorHandler();
for (i = 0; i < length(sxpNames); ++i)
nameList = CSLAddString(nameList, asString(sxpNames, i));
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
CPLErr err = pRasterBand->SetCategoryNames(nameList);
if (err == CE_Failure) warning("Failed to set category names");
uninstallErrorHandlerAndTriggerError();
return(sxpRasterBand);
}
SEXP
RGDAL_CloseDataset(SEXP sxpDataset) {
SEXP sxpHandle = getObjHandle(sxpDataset);
if (sxpHandle == NULL) return(R_NilValue);
const char *classname = asString(getAttrib(sxpDataset, R_ClassSymbol));
if (strcmp(classname, "GDALTransientDataset") == 0) {
RGDAL_DeleteHandle(sxpHandle);
} else {
RGDAL_CloseHandle(sxpHandle);
}
return(R_NilValue);
}
// - LuaValue::operator== ---------------------------------------------------
bool LuaValue::operator== (const LuaValue& rhs) const
{
std::string lhsTypeName = typeName();
std::string rhsTypeName = rhs.typeName();
if (typeName() != rhs.typeName())
return false;
else switch (type())
{
case LUA_TNIL:
return true;
case LUA_TBOOLEAN:
return asBoolean() == rhs.asBoolean();
case LUA_TNUMBER:
return asNumber() == rhs.asNumber();
case LUA_TSTRING:
return asString() == rhs.asString();
case LUA_TTABLE:
return asTable() == rhs.asTable();
case LUA_TFUNCTION:
return asFunction() == rhs.asFunction();
case LUA_TUSERDATA:
return asUserData() == rhs.asUserData();
default:
{
assert(
false
&& "Invalid type found in a call to 'LuaValue::operator==()'.");
return 0; // make compilers happy
}
}
}
string FileSpec::convertFileSpecType(const FileSpecType fst)
throw(FileSpecException)
{
if (fst == station) return string("n");
else if (fst == receiver) return string("r");
else if (fst == prn) return string("p");
else if (fst == selected) return string("t");
else if (fst == sequence) return string("I");
else if (fst == version) return string("v");
else if (fst == fixed) return string("");
else if (fst == clock) return string("k");
else if (fst == text) return string("x");
else if (fst == year) return string("y");
else if (fst == month) return string("m");
else if (fst == dayofmonth) return string("d");
else if (fst == hour) return string("H");
else if (fst == minute) return string("M");
else if (fst == second) return string("S");
else if (fst == fsecond) return string("f");
else if (fst == gpsweek) return string("G");
else if (fst == fullgpsweek) return string("F");
else if (fst == gpssecond) return string("g");
else if (fst == mjd) return string("Q");
else if (fst == dayofweek) return string("w");
else if (fst == day) return string("j");
else if (fst == doysecond) return string("s");
else if (fst == zcount) return string("Z");
else if (fst == zcountfloor) return string("z");
else if (fst == unixsec) return string("U");
else if (fst == unixusec) return string("u");
else if (fst == fullzcount) return string("C");
else
{
FileSpecException fse("Unknown FileSpecType: " + asString(fst));
GPSTK_THROW(fse);
}
}
Animation AnimationLoader::loadFromResources(const Resources::ResourcePack& resourcePack)
{
auto atlasResource = resourcePack.resource("atlas");
Texture atlas(atlasResource);
auto configResource = resourcePack.resource("config");
ConfigReader reader(configResource.asString());
unsigned frames = reader.getInt("Frames");
if (frames == 1)
return Animation(atlas);
int frameDuration = reader.getInt("FrameDuration");
std::vector<Rectangle> frameRects;
frameRects.reserve(frames);
for (unsigned i = 0; i < frames; ++i)
{
String rectName = String("Rect") + String::fromInt(i + 1);
std::vector<String> rectCoords = reader.getArray(rectName);
int x = rectCoords[0].toInt(), y = rectCoords[1].toInt();
unsigned w = rectCoords[2].toInt(), h = rectCoords[3].toInt();
frameRects.emplace_back(x, y, w, h);
}
return Animation(atlas, frameRects, std::chrono::milliseconds(frameDuration));
}
bool Item::isTrue() const
{
switch( dereference()->type() )
{
case FLC_ITEM_BOOL:
return asBoolean() != 0;
case FLC_ITEM_INT:
return asInteger() != 0;
case FLC_ITEM_NUM:
return asNumeric() != 0.0;
case FLC_ITEM_RANGE:
return asRangeStart() != asRangeEnd() || asRangeIsOpen();
case FLC_ITEM_STRING:
return asString()->size() != 0;
case FLC_ITEM_ARRAY:
return asArray()->length() != 0;
case FLC_ITEM_DICT:
return asDict()->length() != 0;
case FLC_ITEM_FUNC:
case FLC_ITEM_OBJECT:
case FLC_ITEM_CLASS:
case FLC_ITEM_METHOD:
case FLC_ITEM_MEMBUF:
case FLC_ITEM_LBIND:
// methods are always filled, so they are always true.
return true;
}
return false;
}
EncodedJSValue JIT_OPERATION operationGetByVal(ExecState* exec, EncodedJSValue encodedBase, EncodedJSValue encodedProperty)
{
VM& vm = exec->vm();
NativeCallFrameTracer tracer(&vm, exec);
JSValue baseValue = JSValue::decode(encodedBase);
JSValue property = JSValue::decode(encodedProperty);
if (LIKELY(baseValue.isCell())) {
JSCell* base = baseValue.asCell();
if (property.isUInt32()) {
return getByVal(exec, base, property.asUInt32());
} else if (property.isDouble()) {
double propertyAsDouble = property.asDouble();
uint32_t propertyAsUInt32 = static_cast<uint32_t>(propertyAsDouble);
if (propertyAsUInt32 == propertyAsDouble && isIndex(propertyAsUInt32))
return getByVal(exec, base, propertyAsUInt32);
} else if (property.isString()) {
Structure& structure = *base->structure(vm);
if (JSCell::canUseFastGetOwnProperty(structure)) {
if (AtomicStringImpl* existingAtomicString = asString(property)->toExistingAtomicString(exec)) {
if (JSValue result = base->fastGetOwnProperty(vm, structure, existingAtomicString))
return JSValue::encode(result);
}
}
}
}
baseValue.requireObjectCoercible(exec);
if (exec->hadException())
return JSValue::encode(jsUndefined());
auto propertyName = property.toPropertyKey(exec);
if (exec->hadException())
return JSValue::encode(jsUndefined());
return JSValue::encode(baseValue.get(exec, propertyName));
}
zmqpp::message reader::Json::read() {
zmqpp::message msg;
msg << target;
::Json::Value value;
::Json::Reader reader;
if (!reader.parse(Plain::read_input_str(), value)) {
throw std::runtime_error(reader.getFormatedErrorMessages());
}
if (!value.isArray()) {
throw std::runtime_error("Must be array");
}
for (size_t i = 0; i < value.size(); ++i) {
auto val = value.get(i, "");
std::string param = (val.isString() ? val.asString() : val.toStyledString());
if (!val.isString()) {
if (verbose) {
std::cerr << "Item #" << i << " is not string!" << std::endl;
}
param = trim_newline(param);
}
msg << param;
}
return msg;
}
