void areNodeModifiersViolated(
const static_context* aSctx,
const store::Item* aTarget,
const QueryLoc& aLoc)
{
const store::Collection* lColl = aTarget->getCollection();
if (lColl != 0 && !lColl->isDynamic())
{
const StaticallyKnownCollection* lDeclColl =
aSctx->lookup_collection(lColl->getName());
if (lDeclColl == NULL)
{
throw XQUERY_EXCEPTION(zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
ERROR_PARAMS(lColl->getName()->getStringValue()),
ERROR_LOC(aLoc));
}
switch(lDeclColl->getNodeModifier())
{
case StaticContextConsts::read_only:
throw XQUERY_EXCEPTION(zerr::ZDDY0010_COLLECTION_CONST_NODE_UPDATE,
ERROR_PARAMS( lColl->getName()->getStringValue() ),
ERROR_LOC(aLoc));
case StaticContextConsts::mutable_node:
// good to go
break;
}
}
}
bool DivideOperation::compute<store::XS_DT_DURATION,store::XS_DOUBLE>
( store::Item_t& result,
dynamic_context* dctx,
const TypeManager* tm,
const QueryLoc* loc,
const store::Item* i0,
const store::Item* i1 )
{
std::unique_ptr<Duration> d;
if( i1->getDoubleValue().isPosInf() || i1->getDoubleValue().isNegInf() )
{
d.reset(new Duration());
}
else if ( i1->getDoubleValue().isZero() )
throw XQUERY_EXCEPTION( err::FODT0002, ERROR_LOC( loc ) );
else if ( i1->getDoubleValue().isNaN() )
throw XQUERY_EXCEPTION( err::FOCA0005, ERROR_LOC( loc ) );
else try {
d.reset(i0->getDayTimeDurationValue() / i1->getDoubleValue());
} catch (XQueryException& e) {
set_source(e, *loc);
throw;
}
return GENV_ITEMFACTORY->createDayTimeDuration(result, d.get());
}
bool
IndexKeysIterator::nextImpl(
store::Item_t& result,
PlanState& aPlanState) const
{
store::Item_t lQName;
IndexDecl_t indexDecl;
store::IndexKey lKey;
store::Item_t lKeyNodeName;
GENV_ITEMFACTORY->createQName(lKeyNodeName,
static_context::ZORBA_STORE_UNORDERED_MAPS_FN_NS,
"", "key");
IndexKeysIteratorState* state;
DEFAULT_STACK_INIT(IndexKeysIteratorState, state, aPlanState);
consumeNext(lQName, theChildren[0].getp(), aPlanState);
if ((indexDecl = theSctx->lookup_index(lQName)) == NULL)
{
throw XQUERY_EXCEPTION(
zerr::ZDDY0021_INDEX_NOT_DECLARED,
ERROR_PARAMS( lQName->getStringValue() ),
ERROR_LOC( loc )
);
}
state->theIndex = GENV_STORE.getIndex(lQName);
if (!state->theIndex)
{
throw XQUERY_EXCEPTION(
zerr::ZDDY0023_INDEX_DOES_NOT_EXIST,
ERROR_PARAMS( lQName->getStringValue() ),
ERROR_LOC( loc )
);
}
state->theIter = state->theIndex->keys();
state->theIter->open();
// generate result elements of the form
// <key>
// <attribute value="key1_value"/>
// <attribute value="key2_value"/>
// <attribute value="key3_value"/>
// </key>
while (state->theIter->next(lKey))
{
IndexUtil::createIndexKeyElement(
state->theIndex->getSpecification().theIsGeneral,
result, lKey, static_context::ZORBA_STORE_STATIC_INDEXES_DML_FN_NS
);
STACK_PUSH(true, state);
}
STACK_END(state);
}
void PPFtScan::do_next(xqp_tuple &t)
{
if (first_time)
{
tuple_cell tc;
index_type.op->next(t);
if (t.is_eos())
throw XQUERY_EXCEPTION(SE1071);
tc = t.cells[0];
if (!tc.is_atomic() || !is_string_type(tc.get_atomic_type()))
throw XQUERY_EXCEPTION(SE1071);
tc = tuple_cell::make_sure_light_atomic(tc);
ft_index_type itype = str2ft_index_type(tc.get_str_mem());
if (cust_rules.op)
{
ptr = ft_custom_tree_t::init();
ft_index_template_t * templ = make_cust_rules_vector(&cust_rules, cxt);
ft_index_template_t::iterator tmp=templ->begin();
while (tmp!=templ->end())
{
ptr->put(new ft_custom_cell(tmp->first, tmp->second));
tmp++;
}
delete_cust_rules_vector(templ);
}
sj=se_new SednaSearchJob(&seq, itype, ptr);
query.op->next(t);
if (t.is_eos())
throw XQUERY_EXCEPTION(SE1071);
tc = t.cells[0];
if (!tc.is_atomic() || !is_string_type(tc.get_atomic_type()))
throw XQUERY_EXCEPTION(SE1071);
sj->set_request(tc);
query.op->next(t);
if (!t.is_eos())
throw XQUERY_EXCEPTION(SE1071);
first_time = false;
}
sj->get_next_result(t);
if (t.is_eos())
{
delete sj;
sj = NULL;
first_time = true;
}
}
bool
ZorbaValidateInPlaceIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
store::Item_t node;
PlanIteratorState* state;
store::PUL_t pul;
DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
if (consumeNext(node, theChild.getp(), planState))
{
// verify that if the element being revalidated is an element it is the root
if (node->getNodeKind()==store::StoreConsts::elementNode &&
node->getParent() &&
node->getParent()->getNodeKind()!=store::StoreConsts::documentNode)
throw XQUERY_EXCEPTION( zerr::ZAPI0090_CANNOT_VALIDATE_NON_ROOT, ERROR_LOC( loc ) );
pul = GENV_ITEMFACTORY->createPendingUpdateList();
pul->addRevalidate(&loc,node);
result.transfer(pul);
STACK_PUSH(true, state);
}
STACK_END(state);
}
Resource*
FileURLResolver::resolveURL
(zstring const& aUrl, EntityData const* aEntityData)
{
switch ( aEntityData->getKind() ) {
case EntityData::COLLECTION:
#ifndef ZORBA_NO_FULL_TEXT
case EntityData::THESAURUS:
#endif /* ZORBA_NO_FULL_TEXT */
return nullptr;
default:
break;
}
uri::scheme lScheme = uri::get_scheme(aUrl);
if (lScheme != uri::file) {
return NULL;
}
try {
std::string lPath( fs::normalize_path(aUrl) );
if (fs::get_type(lPath) == fs::file) {
std::ifstream* lStream = new std::ifstream(lPath.c_str());
return new StreamResource(
lStream, &fileStreamReleaser, "", true /* seekable */);
}
return NULL;
}
catch ( std::invalid_argument const &e ) {
throw XQUERY_EXCEPTION( err::XPTY0004, ERROR_PARAMS( e.what() ) );
}
}
void dynamic_context::set_implicit_timezone(long tzone_seconds)
{
if (tzone_seconds > 14*3600 || tzone_seconds < -14*3600)
throw XQUERY_EXCEPTION(err::FODT0003, ERROR_PARAMS(tzone_seconds));
theTimezone = tzone_seconds;
}
static void x2j_children( store::Item_t const &parent,
vector<store::Item_t> *children ) {
ZORBA_ASSERT( children );
store::Iterator_t i( parent->getChildren() );
i->open();
store::Item_t child_item, temp_item;
while ( i->next( child_item ) ) {
if ( !x2j_map_atomic( child_item, &temp_item ) ) {
if ( !child_item->isNode() )
throw XQUERY_EXCEPTION(
zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON,
ERROR_PARAMS( ZED( ZJ2X0001_BadElement ), child_item->getKind() )
);
switch ( child_item->getNodeKind() ) {
case store::StoreConsts::elementNode:
x2j_element( child_item, &temp_item );
break;
case store::StoreConsts::textNode: {
zstring s( child_item->getStringValue() );
GENV_ITEMFACTORY->createString( temp_item, s );
break;
}
default:
continue;
} // switch
} // if
children->push_back( temp_item );
} // while
i->close();
}
void relpath_expr::compute_scripting_kind()
{
theScriptingKind = UNKNOWN_SCRIPTING_KIND;
for (unsigned i = 0; i < size(); ++i)
{
expr* step = theSteps[i];
if (step->is_updating())
{
throw XQUERY_EXCEPTION(err::XUST0001,
ERROR_PARAMS(ZED(XUST0001_Generic)),
ERROR_LOC(get_loc()));
}
theScriptingKind |= step->get_scripting_detail();
}
theScriptingKind &= ~VACUOUS_EXPR;
if (is_sequential(theScriptingKind))
theScriptingKind &= ~SIMPLE_EXPR;
checkScriptingKind();
}
bool
DeleteIterator::nextImpl(store::Item_t& result, PlanState& aPlanState) const
{
store::Item_t target;
std::unique_ptr<store::PUL> pul;
PlanIteratorState* state;
DEFAULT_STACK_INIT(PlanIteratorState, state, aPlanState);
pul.reset(GENV_ITEMFACTORY->createPendingUpdateList());
while (consumeNext(target, theChild, aPlanState))
{
if (!target->isNode())
throw XQUERY_EXCEPTION( err::XUTY0007, ERROR_LOC( loc ) );
areNodeModifiersViolated(theSctx, target, loc);
pul->addDelete(&loc, target);
}
result = pul.release();
STACK_PUSH(true, state);
STACK_END(state);
}
/*******************************************************************************
14.9.2 fn:parse-xml-fragment
********************************************************************************/
bool FnParseXmlFragmentIterator::nextImpl(
store::Item_t& result,
PlanState& planState) const
{
zstring docString;
FnParseXmlFragmentIteratorState* state;
DEFAULT_STACK_INIT(FnParseXmlFragmentIteratorState, state, planState);
if (consumeNext(result, theChildren[0].getp(), planState))
{
if (result->isStreamable())
{
state->theFragmentStream.theStream = &result->getStream();
}
else
{
result->getStringValue2(docString);
state->theFragmentStream.theIss = new std::istringstream(docString.c_str());
state->theFragmentStream.theStream = state->theFragmentStream.theIss;
}
state->theProperties.setBaseUri(theSctx->get_base_uri());
state->theProperties.setParseExternalParsedEntity(true);
state->theProperties.setStoreDocument(false);
state->baseUri = state->theProperties.getBaseUri();
// create only one document node holding all fragment nodes
state->theFragmentStream.only_one_doc_node = 1;
try
{
result = GENV.getStore().loadDocument(state->baseUri,
state->docUri,
state->theFragmentStream,
state->theProperties);
}
catch ( ZorbaException const &e )
{
if ( !state->theProperties.getNoError() )
{
XQueryException xe(
XQUERY_EXCEPTION(err::FODC0006,
ERROR_PARAMS( "fn:parse-xml-fragment()", e.what() ),
ERROR_LOC( loc )));
set_data( xe, e );
throw xe;
}
result = nullptr;
}
if (result != NULL)
STACK_PUSH(true, state);
} // if
STACK_END(state);
}
void xml_to_json( store::Item_t const &xml_item, store::Item_t *json_item ) {
ZORBA_ASSERT( json_item );
switch ( xml_item->getNodeKind() ) {
case store::StoreConsts::elementNode:
x2j_element( xml_item, json_item );
break;
default:
throw XQUERY_EXCEPTION( zerr::ZJSE0001_NOT_ELEMENT_NODE );
}
}
bool DivideOperation::compute<store::XS_DT_DURATION, store::XS_DT_DURATION>(
store::Item_t& result,
dynamic_context* dctx,
const TypeManager* tm,
const QueryLoc* loc,
const store::Item* i0,
const store::Item* i1 )
{
xs_dayTimeDuration otherDTDuration = i1->getDayTimeDurationValue();
if (otherDTDuration.isZero())
throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC(loc));
xs_decimal d = i0->getDayTimeDurationValue() / otherDTDuration;
return GENV_ITEMFACTORY->createDecimal(result, d);
}
bool IntegerDivideOperation::compute<store::XS_DOUBLE,store::XS_DOUBLE>(
store::Item_t& result,
dynamic_context* /* dctx */,
const TypeManager* /* tm */,
const QueryLoc* loc,
const store::Item* i0,
const store::Item* i1 )
{
xs_double d0 = i0->getDoubleValue();
xs_double d1 = i1->getDoubleValue();
if ( d1 == numeric_consts<xs_double>::zero() )
{
throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
}
if (i0->isNaN() || i1->isNaN())
{
throw XQUERY_EXCEPTION(
err::FOAR0002, ERROR_PARAMS( ZED( DivisionNoNaN ) ), ERROR_LOC( loc )
);
}
if (i0->isPosOrNegInf())
{
throw XQUERY_EXCEPTION(
err::FOAR0002, ERROR_PARAMS( ZED( DivisionNoINF ) ), ERROR_LOC( loc )
);
}
if (i0->isPosOrNegInf()) {
// idiv with +-INF divisor has 0 as result
return GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
}
xs_integer const lInteger( d0 / d1 );
return GENV_ITEMFACTORY->createInteger (result, lInteger );
}
bool
ValidateIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
store::Item_t item;
store::Item_t tmp;
PlanIteratorState* aState;
DEFAULT_STACK_INIT(PlanIteratorState, aState, planState);
if (consumeNext(item, theChild, planState))
{
if (consumeNext(tmp, theChild, planState))
{
throw XQUERY_EXCEPTION( err::XQTY0030, ERROR_LOC( loc ) );
// STACK_PUSH(false, aState); -- THIS IS NEVER REACHED
}
else
{
STACK_PUSH(Validator::effectiveValidationValue(result,
item,
typeName,
typemgr.getp(),
validationMode,
theSctx,
this->loc),
aState);
}
}
else
{
throw XQUERY_EXCEPTION( err::XQTY0030, ERROR_LOC( loc ) );
// STACK_PUSH(false, aState); -- THIS IS NEVER REACHED
}
STACK_END (aState);
}
void json_to_xml( store::Item_t const &json_item, store::Item_t *xml_item ) {
ZORBA_ASSERT( xml_item );
switch ( json_item->getKind() ) {
case store::Item::ARRAY:
*xml_item = j2x_array( json_item, nullptr );
break;
case store::Item::OBJECT:
throw XQUERY_EXCEPTION(
zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON,
ERROR_PARAMS( ZED( ZJ2X0001_ArrayRequired ) )
);
default:
ZORBA_ASSERT( false );
}
}
bool DivideOperation::compute<store::XS_DECIMAL,store::XS_DECIMAL>(
store::Item_t& result,
dynamic_context* /*dctx*/,
const TypeManager* /* tm */,
const QueryLoc* loc,
const store::Item* i0,
const store::Item* i1)
{
xs_decimal ld0 = i0->getDecimalValue();
xs_decimal ld1 = i1->getDecimalValue();
if ( ld1.sign() == 0 )
{
throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
}
return GENV_ITEMFACTORY->createDecimal (result, ld0 / ld1 );
}
bool DivideOperation::compute<store::XS_INTEGER,store::XS_INTEGER>(
store::Item_t& result,
dynamic_context* /* dctx */,
const TypeManager* /* tm */,
const QueryLoc* loc,
const store::Item* i0,
const store::Item* i1 )
{
xs_decimal const ll0(i0->getIntegerValue());
xs_decimal const ll1(i1->getIntegerValue());
if ( ll1.sign() == 0 )
{
throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
}
return GENV_ITEMFACTORY->createDecimal (result, ll0 / ll1 );
}
static bool get_bool_opt( store::Item_t const &object,
char const *opt_name, bool *result ) {
store::Item_t opt_item;
if ( get_json_option( object, opt_name, &opt_item ) ) {
if ( !IS_ATOMIC_TYPE( opt_item, XS_BOOLEAN ) )
throw XQUERY_EXCEPTION(
jse::INVALID_OPTION,
ERROR_PARAMS(
opt_item->getStringValue(),
opt_name,
ZED( INVALID_OPTION_jse_MustBeBoolean )
)
);
*result = opt_item->getBooleanValue();
return true;
}
return false;
}
void PPFtHighlight::do_next(xqp_tuple &t)
{
if (first_time)
{
tuple_cell tc;
U_ASSERT(fthl == NULL);
if (options.op)
{
options.op->next(t);
if (t.is_eos())
throw XQUERY_EXCEPTION(SE1071);
tc = t.cells[0];
if (!tc.is_atomic() || !is_string_type(tc.get_atomic_type()))
throw XQUERY_EXCEPTION(SE1071);
op_str_buf buf(tc);
fthl = new FtHighlighter(hl_fragment, &seq);
fthl->set_options(buf.c_str());
options.op->next(t);
if (!t.is_eos())
throw XQUERY_EXCEPTION(SE1071);
}
else
fthl = new FtHighlighter(hl_fragment, &seq);
query.op->next(t);
if (t.is_eos())
throw XQUERY_EXCEPTION(SE1071);
tc = t.cells[0];
if (!tc.is_atomic() || !is_string_type(tc.get_atomic_type()))
throw XQUERY_EXCEPTION(SE1071);
fthl->set_request(tc);
query.op->next(t);
if (!t.is_eos())
throw XQUERY_EXCEPTION(SE1071);
first_time = false;
}
fthl->get_next_result(t);
if (t.is_eos())
{
delete fthl;
fthl = NULL;
first_time = true;
}
}
bool XMLtoJSONInternal::nextImpl( store::Item_t& result,
PlanState &planState ) const {
store::Item_t xml_item;
options_type options;
PlanIteratorState *state;
DEFAULT_STACK_INIT( PlanIteratorState, state, planState );
ZORBA_ASSERT( theChildren.size() == 2 );
consumeNext( xml_item, theChildren[1], planState );
get_options( xml_item, &options );
consumeNext( xml_item, theChildren[0], planState );
try {
options_type::mapped_type const &format_opt = options[ "json-format" ];
ZORBA_ASSERT( !format_opt.empty() );
switch ( xml_item->getNodeKind() ) {
case store::StoreConsts::elementNode:
if ( format_opt == "Snelson" )
snelson::xml_to_json( xml_item, &result );
else if ( format_opt == "JsonML" || format_opt == "JsonML-array" )
jsonml_array::xml_to_json( xml_item, &result );
else if ( format_opt == "JsonML-object" )
jsonml_object::xml_to_json( xml_item, &result );
else
ZORBA_ASSERT( false );
break;
default:
throw XQUERY_EXCEPTION(
zerr::ZJSE0001_NOT_ELEMENT_NODE,
ERROR_LOC( loc )
);
} // switch
}
catch ( ZorbaException &e ) {
set_source( e, loc );
throw;
}
STACK_PUSH( !!result, state );
STACK_END( state );
}
bool SubtractOperation::compute<store::XS_TIME,store::XS_TIME>(
store::Item_t& result,
dynamic_context* dctx,
const TypeManager* tm,
const QueryLoc* loc,
const store::Item* i0,
const store::Item* i1)
{
std::unique_ptr<Duration> d;
try
{
d.reset(i0->getTimeValue().subtractDateTime(&i1->getTimeValue(),
dctx->get_implicit_timezone()));
}
catch (InvalidTimezoneException const &e)
{
throw XQUERY_EXCEPTION(err::FODT0003, ERROR_PARAMS(e.get_tz_seconds()));
}
return GENV_ITEMFACTORY->createDayTimeDuration(result, d.get());
}
void relpath_expr::add_back(expr* step)
{
if (step->is_updating())
{
throw XQUERY_EXCEPTION(err::XUST0001,
ERROR_PARAMS(ZED(XUST0001_Generic)),
ERROR_LOC(get_loc()));
}
theScriptingKind |= step->get_scripting_detail();
if (theScriptingKind & VACUOUS_EXPR)
theScriptingKind &= ~VACUOUS_EXPR;
if (is_sequential(theScriptingKind))
theScriptingKind &= ~SIMPLE_EXPR;
checkScriptingKind();
theSteps.push_back(step);
}
// ---------------------------------------------------------------------------
// LoadSchemaErrorHandler: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------
void LoadSchemaErrorHandler::error(const XERCES_CPP_NAMESPACE::SAXParseException& e)
{
zstring system_id, public_id;
if ( e.getSystemId() )
system_id = StrX( e.getSystemId() ).localFormOrDefault( "" );
if ( e.getPublicId() )
public_id = StrX( e.getPublicId() ).localFormOrDefault( "" );
theSawErrors = true;
throw XQUERY_EXCEPTION(
err::XQST0059,
ERROR_PARAMS(
ZED( XQST0059_XercesMessage ),
e.getLineNumber(),
e.getColumnNumber(),
system_id,
public_id,
StrX( e.getMessage() ).localFormOrDefault( "" )
),
ERROR_LOC( theQueryLoc )
);
}
/******************************************************************************
Create a dummy main module to wrap a library module.
******************************************************************************/
parsenode_t XQueryCompiler::createMainModule(
parsenode_t aLibraryModule,
std::istream& aXQuery,
const zstring& aFileName)
{
//get the namespace from the LibraryModule
LibraryModule* mod_ast = dynamic_cast<LibraryModule *>(&*aLibraryModule);
if (!mod_ast)
throw ZORBA_EXCEPTION(zerr::ZAPI0002_XQUERY_COMPILATION_FAILED,
ERROR_PARAMS(ZED(BadLibraryModule)));
const zstring& lib_namespace = mod_ast->get_decl()->get_target_namespace();
URI lURI(lib_namespace);
if(!lURI.is_absolute())
{
throw XQUERY_EXCEPTION(err::XQST0046,
ERROR_PARAMS(lURI.toString(), ZED(MustBeAbsoluteURI)),
ERROR_LOC(mod_ast->get_decl()->get_location()));
}
// Set up the original query stream as the result of resolving the
// library module's URI
aXQuery.clear();
aXQuery.seekg(0);
FakeLibraryModuleURLResolver* aFakeResolver =
new FakeLibraryModuleURLResolver(aFileName, aXQuery);
theCompilerCB->theRootSctx->add_url_resolver(aFakeResolver);
// create a dummy main module and parse it
std::stringstream lDocStream;
zstring tmp;
zorba::xml::escape(lib_namespace, &tmp);
lDocStream << "import module namespace m = '" << tmp << "'; 1";
return parse(lDocStream, aFileName);
}
bool EitherNodesOrAtomicsIterator::nextImpl(
store::Item_t& result,
PlanState& planState) const
{
EitherNodesOrAtomicsIteratorState* state;
DEFAULT_STACK_INIT(EitherNodesOrAtomicsIteratorState, state, planState);
if (CONSUME(result, 0))
{
state->atomics = !result->isNode();
STACK_PUSH(true, state);
while (CONSUME(result, 0))
{
if (state->atomics == result->isNode())
throw XQUERY_EXCEPTION(err::XPTY0018, ERROR_LOC(loc));
STACK_PUSH(true, state);
}
}
STACK_END(state);
}
void normalizeInputUri(
zstring const& aUri,
static_context* aSctx,
QueryLoc const& aLoc,
zstring* aResult)
{
zstring const lBaseUri = aSctx->get_base_uri();
try
{
// To support the very common (if technically incorrect) use
// case of users passing local filesystem paths to fn:doc(),
// we use the following heuristic: IF the base URI has a file:
// scheme AND the incoming URI has no scheme, we will assume
// the incoming URI is actually a filesystem path. QQQ For
// the moment, we assume any "unknown" schemes are probably
// Windows drive letters.
if ((uri::get_scheme(aUri) == uri::none ||
uri::get_scheme(aUri) == uri::unknown) &&
uri::get_scheme(lBaseUri) == uri::file)
{
try
{
// Ok, we assume it's a filesystem path. First normalize it.
zstring lNormalizedPath = fs::normalize_path( aUri );
// QQQ For now, normalize_path() doesn't do what we
// want when base URI represents a file. So, when the
// normalized path is relative, we pretend it's a relative
// URI and resolve it as such.
if (fs::is_absolute(lNormalizedPath))
{
URI::encode_file_URI(lNormalizedPath, *aResult);
}
else
{
#ifdef WIN32
ascii::replace_all(lNormalizedPath, '\\', '/');
#endif
*aResult = aSctx->resolve_relative_uri(lNormalizedPath, true);
}
}
catch ( std::invalid_argument const &e )
{
throw XQUERY_EXCEPTION( err::XPTY0004, ERROR_PARAMS( e.what() ) );
}
}
else
{
// We do NOT assume it's a filesystem path; just resolve it.
*aResult = aSctx->resolve_relative_uri(aUri, true);
}
}
catch (ZorbaException& e)
{
if (e.diagnostic() == err::XQST0046)
// the value of a URILiteral is of nonzero length and is not in the
// lexical space of xs:anyURI.
e.set_diagnostic(err::FODC0005);
else
e.set_diagnostic(err::FODC0002);
set_source(e, aLoc);
throw;
}
}
bool
DecodeURIIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
store::Item_t lString, lDecodePlus, lEncoding;
zstring lDecodedString, lCharset;
PlanIteratorState* state;
DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
consumeNext(lString, theChildren[0].getp(), planState);
consumeNext(lDecodePlus, theChildren[1].getp(), planState);
consumeNext(lEncoding, theChildren[2].getp(), planState);
lString->getStringValue2(lDecodedString);
lEncoding->getStringValue2(lCharset);
if (lDecodePlus->getBooleanValue())
{
std::replace( lDecodedString.begin(), lDecodedString.end(), '+', ' ' );
}
uri::decode(lDecodedString);
if (transcode::is_necessary(lCharset.c_str()))
{
if (!transcode::is_supported(lCharset.c_str()))
{
throw XQUERY_EXCEPTION(
zuri::CHARSET_UNKNOWN,
ERROR_PARAMS( lCharset ),
ERROR_LOC( loc )
);
}
try
{
transcode::stream<istringstream> lTranscoder(
lCharset.c_str(),
lDecodedString.c_str()
);
lDecodedString.clear();
char buf[1024];
while (lTranscoder.good())
{
lTranscoder.read(buf, 1024);
lDecodedString.append(buf, static_cast<zstring::size_type>(lTranscoder.gcount()));
}
}
catch (ZorbaException& e)
{
throw XQUERY_EXCEPTION(
zerr::ZOSE0006_TRANSCODING_ERROR,
ERROR_PARAMS( e.what() ),
ERROR_LOC( loc )
);
}
}
STACK_PUSH(GENV_ITEMFACTORY->createString(result, lDecodedString), state );
STACK_END (state);
}
bool
SerializeURIIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
store::Item_t lItemURI, lItemKey;
zorba::zstring lStrValue, lStrKey, lStrRes;
store::Iterator_t lKeys;
URI uri = URI();
int lIntPort = 0;
bool lHasSchemeField, lHasOpaqueField, lHasNotOpaqueField;
PlanIteratorState* state;
DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
consumeNext(lItemURI, theChildren[0].getp(), planState);
lHasSchemeField = lHasOpaqueField = lHasNotOpaqueField = false;
if(lItemURI->isObject()) {
lKeys = lItemURI->getObjectKeys();
if(!lKeys.isNull()){
lKeys->open();
while(lKeys->next(lItemKey)){
lStrKey = lItemKey->getStringValue();
lStrValue = lItemURI->getObjectValue(lItemKey)->getStringValue();
if(lStrKey == SCHEME_NAME && !lStrValue.empty()){
uri.set_scheme(lStrValue);
lHasSchemeField = true;
} else if(lStrKey == OPAQUE_PART_NAME && !lStrValue.empty()){
uri.set_opaque_part(lStrValue);
lHasOpaqueField = true;
} else if(lStrKey == AUTHORITY_NAME && !lStrValue.empty()){
uri.set_reg_based_authority(lStrValue);
lHasNotOpaqueField = true;
} else if(lStrKey == USER_INFO_NAME && !lStrValue.empty()){
uri.set_user_info(lStrValue);
lHasNotOpaqueField = true;
} else if(lStrKey == HOST_NAME && !lStrValue.empty()){
uri.set_host(lStrValue);
lHasNotOpaqueField = true;
} else if(lStrKey == PORT_NAME){
sscanf(lStrValue.str().c_str(), "%d", &lIntPort);
if(lIntPort != 0){
uri.set_port(lIntPort);
lHasNotOpaqueField = true;
}
} else if(lStrKey == PATH_NAME && !lStrValue.empty()){
uri.set_path(lStrValue);
lHasNotOpaqueField = true;
} else if(lStrKey == QUERY_NAME){
uri.set_query(lStrValue);
lHasNotOpaqueField = true;
} else if(lStrKey == FRAGMENT_NAME){
uri.set_fragment(lStrValue);
}
}
lKeys->close();
}
}
// check for errors
if(lHasOpaqueField && lHasNotOpaqueField)
{
throw XQUERY_EXCEPTION(
zuri::OPAQUE_COMB_NOT_VALID,
ERROR_LOC( loc )
);
}
if(lHasOpaqueField && !lHasSchemeField)
{
throw XQUERY_EXCEPTION(
zuri::OPAQUE_WITHOUT_SCHEME,
ERROR_LOC( loc )
);
}
if(lHasSchemeField && !uri.get_encoded_path().empty() && (uri.get_encoded_path().substr(0,1) != "/"))
{
throw XQUERY_EXCEPTION(
zuri::INVALID_ABSOLUTE_PATH,
ERROR_LOC( loc )
);
}
lStrRes = zorba::zstring(uri.toString());
STACK_PUSH(GENV_ITEMFACTORY->createString(result, lStrRes), state );
STACK_END (state);
}
static store::Item_t j2x_array( store::Item_t const &array_item,
store::Item *parent_xml_item ) {
zstring base_uri;
store::NsBindings ns_bindings;
store::Item_t array_elt_item, element_name, junk_item, type_name, xml_item;
store::Iterator_t i( array_item->getArrayValues() );
i->open();
if ( !i->next( array_elt_item ) )
throw XQUERY_EXCEPTION(
zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON,
ERROR_PARAMS( ZED( ZJ2X0001_EmptyArray ) )
);
if ( !array_elt_item->isAtomic() ||
!TypeOps::is_subtype( array_elt_item->getTypeCode(), store::XS_STRING ) )
throw XQUERY_EXCEPTION(
zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON,
ERROR_PARAMS( ZED( ZJ2X0001_Bad1stElement ) )
);
GENV_ITEMFACTORY->createQName(
element_name, "", "", array_elt_item->getStringValue()
);
type_name = GENV_TYPESYSTEM.XS_UNTYPED_QNAME;
GENV_ITEMFACTORY->createElementNode(
xml_item, parent_xml_item,
element_name, type_name, false, false, ns_bindings, base_uri
);
bool did_attributes = false;
while ( i->next( array_elt_item ) ) {
switch ( array_elt_item->getKind() ) {
case store::Item::ARRAY:
j2x_array( array_elt_item, xml_item.getp() );
break;
case store::Item::ATOMIC: {
zstring value_str( array_elt_item->getStringValue() );
GENV_ITEMFACTORY->createTextNode( junk_item, xml_item, value_str );
break;
}
case store::Item::OBJECT:
if ( did_attributes )
throw XQUERY_EXCEPTION(
zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON,
ERROR_PARAMS( ZED( ZJ2X0001_UnexpectedObject ) )
);
j2x_object( array_elt_item, &xml_item );
did_attributes = true;
break;
default:
throw XQUERY_EXCEPTION(
zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON,
ERROR_PARAMS( ZED( ZJ2X0001_BadElement ), array_elt_item->getKind() )
);
} // switch
} // while
i->close();
return xml_item;
}
