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); }
bool OpNumericUnaryIterator::nextImpl(store::Item_t& result, PlanState& planState) const { store::Item_t item; store::SchemaTypeCode type; const TypeManager* tm = theSctx->get_typemanager(); PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); if (consumeNext(item, theChild.getp(), planState )) { assert(item->isAtomic()); type = item->getTypeCode(); if (type == store::XS_UNTYPED_ATOMIC) { GenericCast::castToBuiltinAtomic(item, item, store::XS_DOUBLE, NULL, loc); type = store::XS_DOUBLE; } // TODO Optimizations (e.g. if item has already the correct type and value, // it does not have to be created newly) if (TypeOps::is_subtype(type, store::XS_DOUBLE)) { GENV_ITEMFACTORY-> createDouble(result, (thePlus ? item->getDoubleValue() : -item->getDoubleValue())); } else if (TypeOps::is_subtype(type, store::XS_FLOAT)) { GENV_ITEMFACTORY-> createFloat(result, (thePlus ? item->getFloatValue() : -item->getFloatValue())); } else if (TypeOps::is_subtype(type, store::XS_INTEGER)) { GENV_ITEMFACTORY-> createInteger(result, (thePlus ? item->getIntegerValue() : -item->getIntegerValue())); } else if (TypeOps::is_subtype(type, store::XS_DECIMAL)) { GENV_ITEMFACTORY-> createDecimal(result, (thePlus ? item->getDecimalValue() : -item->getDecimalValue())); } else { xqtref_t type = tm->create_value_type(item); RAISE_ERROR(err::XPTY0004, loc, ERROR_PARAMS(ZED(BadTypeFor_23), type->toSchemaString(), ZED(UnaryArithOp))); } STACK_PUSH(true, state); } STACK_END(state); }
bool SpecificNumArithIterator<Operation, Type>::nextImpl( store::Item_t& result, PlanState& planState) const { bool res; store::Item_t n0; store::Item_t n1; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); if (this->consumeNext(n0, this->theChild0.getp(), planState)) { if (this->consumeNext(n1, this->theChild1.getp(), planState)) { assert(n0->isAtomic()); assert(n1->isAtomic()); res = Operation::template computeSingleType<Type>(result, NULL, NULL, &this->loc, n0.getp(), n1.getp()); STACK_PUSH(res, state); } } STACK_END(state); }
bool NumArithIterator<Operation>::nextImpl( store::Item_t& result, PlanState& planState) const { bool res; store::Item_t n0; store::Item_t n1; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); if (this->consumeNext(n0, this->theChild0.getp(), planState)) { if (this->consumeNext(n1, this->theChild1.getp(), planState)) { res = compute(result, planState.theLocalDynCtx, this->theSctx->get_typemanager(), this->loc, n0, n1); STACK_PUSH(res, state); } } STACK_END(state); }
/* * Initialize keeper states * * If there is a problem, return an error message (NULL for okay). * * Note: Any problems would be design flaws; the created Lua state is left * unclosed, because it does not really matter. In production code, this * function never fails. */ char const* init_keepers( int const _nbKeepers, lua_CFunction _on_state_create) { int i; assert( _nbKeepers >= 1); GNbKeepers = _nbKeepers; GKeepers = malloc( _nbKeepers * sizeof( struct s_Keeper)); for( i = 0; i < _nbKeepers; ++ i) { // We need to load all base libraries in the keeper states so that the transfer databases are populated properly // // 'io' for debugging messages, 'package' because we need to require modules exporting idfuncs // the others because they export functions that we may store in a keeper for transfer between lanes lua_State* K = luaG_newstate( "*", _on_state_create); if (!K) return "out of memory"; STACK_CHECK( K) // to see VM name in Decoda debugger lua_pushliteral( K, "Keeper #"); lua_pushinteger( K, i + 1); lua_concat( K, 2); lua_setglobal( K, "decoda_name"); #if KEEPER_MODEL == KEEPER_MODEL_C // create the fifos table in the keeper state lua_pushlightuserdata( K, fifos_key); lua_newtable( K); lua_rawset( K, LUA_REGISTRYINDEX); #endif // KEEPER_MODEL == KEEPER_MODEL_C #if KEEPER_MODEL == KEEPER_MODEL_LUA // use package.loaders[2] to find keeper microcode lua_getglobal( K, "package"); // package lua_getfield( K, -1, "loaders"); // package package.loaders lua_rawgeti( K, -1, 2); // package package.loaders package.loaders[2] lua_pushliteral( K, "lanes-keeper"); // package package.loaders package.loaders[2] "lanes-keeper" STACK_MID( K, 4); // first pcall loads lanes-keeper.lua, second one runs the chunk if( lua_pcall( K, 1 /*args*/, 1 /*results*/, 0 /*errfunc*/) || lua_pcall( K, 0 /*args*/, 0 /*results*/, 0 /*errfunc*/)) { // LUA_ERRRUN / LUA_ERRMEM / LUA_ERRERR // char const* err = lua_tostring( K, -1); assert( err); return err; } // package package.loaders STACK_MID( K, 2); lua_pop( K, 2); #endif // KEEPER_MODEL == KEEPER_MODEL_LUA STACK_END( K, 0) MUTEX_INIT( &GKeepers[i].lock_); GKeepers[i].L = K; //GKeepers[i].count = 0; } #if HAVE_KEEPER_ATEXIT_DESINIT atexit( atexit_close_keepers); #endif // HAVE_KEEPER_ATEXIT_DESINIT return NULL; // ok }
/******************************************************************************* declare function is-available-document($uri as xs:string) as xs:boolean ********************************************************************************/ bool IsAvailableDocumentIterator::nextImpl( store::Item_t& result, PlanState& aPlanState) const { zstring lRetrievedUriString; zstring lResolvedUriString; store::Item_t lUri; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, aPlanState); consumeNext(lUri, theChildren[0].getp(), aPlanState); // absolutize retrieved uri try { lUri->getStringValue2(lRetrievedUriString); lResolvedUriString = theSctx->resolve_relative_uri(lRetrievedUriString, true); } catch (ZorbaException const&) { RAISE_ERROR(err::FODC0004, loc, ERROR_PARAMS(lResolvedUriString, ZED(NoResolveRelativeURI))); } // check if document exists in the store GENV_ITEMFACTORY-> createBoolean(result, GENV_STORE.getDocument(lResolvedUriString) != NULL); STACK_PUSH(true, state); STACK_END(state); }
bool IsFollowingSiblingPositionIterator::nextImpl(store::Item_t& result, PlanState& planState) const { store::Item_t lUriA; store::Item_t lUriB; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); consumeNext(lUriA, theChildren[0].getp(), planState); consumeNext(lUriB, theChildren[1].getp(), planState); try { GENV_ITEMFACTORY->createBoolean(result, lUriA->isFollowingSibling(lUriB)); } catch (ZorbaException& e) { set_source(e, loc); throw; } STACK_PUSH(true,state); STACK_END (state); }
/* * Create a deep userdata * * proxy_ud= deep_userdata( idfunc [, ...] ) * * Creates a deep userdata entry of the type defined by 'idfunc'. * Other parameters are passed on to the 'idfunc' "new" invocation. * * 'idfunc' must fulfill the following features: * * lightuserdata = idfunc( eDO_new [, ...] ) -- creates a new deep data instance * void = idfunc( eDO_delete, lightuserdata ) -- releases a deep data instance * tbl = idfunc( eDO_metatable ) -- gives metatable for userdata proxies * * Reference counting and true userdata proxying are taken care of for the * actual data type. * * Types using the deep userdata system (and only those!) can be passed between * separate Lua states via 'luaG_inter_move()'. * * Returns: 'proxy' userdata for accessing the deep data via 'luaG_todeep()' */ int luaG_newdeepuserdata( lua_State* L, luaG_IdFunction idfunc) { char const* errmsg; DEEP_PRELUDE* prelude = DEEP_MALLOC( sizeof(DEEP_PRELUDE)); if( prelude == NULL) { return luaL_error( L, "couldn't not allocate deep prelude: out of memory"); } prelude->refcount = 0; // 'push_deep_proxy' will lift it to 1 prelude->idfunc = idfunc; STACK_GROW( L, 1); STACK_CHECK( L); { int oldtop = lua_gettop( L); prelude->deep = idfunc( L, eDO_new); if( prelude->deep == NULL) { luaL_error( L, "idfunc(eDO_new) failed to create deep userdata (out of memory)"); } if( lua_gettop( L) - oldtop != 0) { luaL_error( L, "Bad idfunc(eDO_new): should not push anything on the stack"); } } errmsg = push_deep_proxy( get_universe( L), L, prelude, eLM_LaneBody); // proxy if( errmsg != NULL) { luaL_error( L, errmsg); } STACK_END( L, 1); return 1; }
/* * Return the registered ID function for 'index' (deep userdata proxy), * or NULL if 'index' is not a deep userdata proxy. */ static inline luaG_IdFunction get_idfunc( lua_State* L, int index, enum eLookupMode mode_) { // when looking inside a keeper, we are 100% sure the object is a deep userdata if( mode_ == eLM_FromKeeper) { DEEP_PRELUDE** proxy = (DEEP_PRELUDE**) lua_touserdata( L, index); // we can (and must) cast and fetch the internally stored idfunc return (*proxy)->idfunc; } else { // essentially we are making sure that the metatable of the object we want to copy is stored in our metatable/idfunc database // it is the only way to ensure that the userdata is indeed a deep userdata! // of course, we could just trust the caller, but we won't luaG_IdFunction ret; STACK_GROW( L, 1); STACK_CHECK( L); if( !lua_getmetatable( L, index)) // deep ... metatable? { return NULL; // no metatable: can't be a deep userdata object! } // replace metatable with the idfunc pointer, if it is actually a deep userdata get_deep_lookup( L); // deep ... idfunc|nil ret = (luaG_IdFunction) lua_touserdata( L, -1); // NULL if not a userdata lua_pop( L, 1); STACK_END( L, 0); return ret; } }
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); }
/* * Push a registry subtable (keyed by unique 'token') onto the stack. * If the subtable does not exist, it is created and chained. */ static void push_registry_subtable( lua_State *L, void *token ) { STACK_GROW(L,3); STACK_CHECK(L) lua_pushlightuserdata( L, token ); lua_rawget( L, LUA_REGISTRYINDEX ); // // [-1]: nil/subtable if (lua_isnil(L,-1)) { lua_pop(L,1); lua_newtable(L); // value lua_pushlightuserdata( L, token ); // key lua_pushvalue(L,-2); // // [-3]: value (2nd ref) // [-2]: key // [-1]: value lua_rawset( L, LUA_REGISTRYINDEX ); } STACK_END(L,1) ASSERT_L( lua_istable(L,-1) ); }
bool SeqValueExceptIterator::nextImpl( store::Item_t &result, PlanState &plan_state ) const { XQPCollator *const coll = theSctx->get_default_collator( loc ); store::Item_t item; TypeManager *const tm = getTypeManager(); long tz; SeqValueExceptIteratorState *state; DEFAULT_STACK_INIT( SeqValueExceptIteratorState, state, plan_state ); tz = plan_state.theLocalDynCtx->get_implicit_timezone(); state->set_ = new_Item_set( tm, tz, coll, loc ); while ( consumeNext( item, theChildren[1], plan_state ) ) if ( state->set_->insert( item.getp() ).second ) item->addReference(); while ( consumeNext( item, theChildren[0], plan_state ) ) if ( state->set_->insert( item.getp() ).second ) { item->addReference(); result = item; STACK_PUSH( true, state ); } delete_Item_set( state->set_ ); STACK_END( state ); }
// cause each keeper state to populate its database of transferable functions with those from the specified module // do do this we simply require the module inside the keeper state, then populate the lookup database void populate_keepers( lua_State* L) { size_t name_len; char const* name = luaL_checklstring( L, -1, &name_len); int i; DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "populate_keepers %s BEGIN\n" INDENT_END, name)); DEBUGSPEW_CODE( ++ debugspew_indent_depth); for( i = 0; i < GNbKeepers; ++ i) { lua_State* K = GKeepers[i].L; int res; MUTEX_LOCK( &GKeepers[i].lock_); STACK_CHECK( K); STACK_GROW( K, 2); lua_getglobal( K, "require"); lua_pushlstring( K, name, name_len); res = lua_pcall( K, 1, 1, 0); if( res != LUA_OK) { char const* err = luaL_checkstring( K, -1); luaL_error( L, "error requiring '%s' in keeper state: %s", name, err); } // after requiring the module, register the functions it exported in our name<->function database populate_func_lookup_table( K, -1, name); lua_pop( K, 1); STACK_END( K, 0); MUTEX_UNLOCK( &GKeepers[i].lock_); } DEBUGSPEW_CODE( -- debugspew_indent_depth); }
bool JSoundValidateIterator::nextImpl( store::Item_t &result, PlanState &plan_state ) const { bool cast = cast_default; store::Item_t jsd_item, type_item, json_item, options_item; PlanIteratorState *state; DEFAULT_STACK_INIT( PlanIteratorState, state, plan_state ); consumeNext( jsd_item, theChildren[0], plan_state ); consumeNext( type_item, theChildren[1], plan_state ); consumeNext( json_item, theChildren[2], plan_state ); consumeNext( options_item, theChildren[3], plan_state ); try { get_bool_opt( options_item, "cast-atomic-values", &cast ); jsound::schema const schema( jsd_item ); GENV_ITEMFACTORY->createBoolean( result, schema.validate( json_item, type_item->getStringValue(), cast ) ); } catch ( ZorbaException &e ) { set_source( e, loc, false ); throw; } STACK_PUSH( true, state ); STACK_END( state ); }
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); }
bool FunctionNameIterator::nextImpl( store::Item_t& r, PlanState& planState) const { store::Item_t lFItem; FunctionItem* lFunctionItem = 0; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); consumeNext(lFItem, theChildren[0], planState); // function signature guarantees that ZORBA_ASSERT(lFItem->isFunction()); lFunctionItem = static_cast<FunctionItem*>(lFItem.getp()); if ((!lFunctionItem->isInline() || lFunctionItem->isCoercion()) && lFunctionItem->getFunctionName() && (lFunctionItem->getArity() == lFunctionItem->getStartArity())) { // non-inline function r = lFunctionItem->getFunctionName(); STACK_PUSH(true, state); } STACK_END(state); }
/* * Does what the original 'push_registry_subtable' function did, but adds an optional mode argument to it */ void push_registry_subtable_mode( lua_State* L, void* key_, const char* mode_) { STACK_GROW( L, 3); STACK_CHECK( L); lua_pushlightuserdata( L, key_); // key lua_rawget( L, LUA_REGISTRYINDEX); // {}|nil if( lua_isnil( L, -1)) { lua_pop( L, 1); // lua_newtable( L); // {} lua_pushlightuserdata( L, key_); // {} key lua_pushvalue( L, -2); // {} key {} // _R[key_] = {} lua_rawset( L, LUA_REGISTRYINDEX); // {} // Set its metatable if requested if( mode_) { lua_newtable( L); // {} mt lua_pushliteral( L, "__mode"); // {} mt "__mode" lua_pushstring( L, mode_); // {} mt "__mode" mode lua_rawset( L, -3); // {} mt lua_setmetatable( L, -2); // {} } } STACK_END( L, 1); ASSERT_L( lua_istable( L, -1)); }
int keeper_push_linda_storage( lua_State* L, void* ptr) { struct s_Keeper* K = keeper_acquire( ptr); lua_State* KL = K->L; STACK_CHECK( KL); lua_pushlightuserdata( KL, fifos_key); // fifos_key lua_rawget( KL, LUA_REGISTRYINDEX); // fifos lua_pushlightuserdata( KL, ptr); // fifos ud lua_rawget( KL, -2); // fifos storage lua_remove( KL, -2); // storage if( !lua_istable( KL, -1)) { lua_pop( KL, 1); // STACK_MID( KL, 0); return 0; } // move data from keeper to destination state KEEPER MAIN lua_pushnil( KL); // storage nil STACK_CHECK( L); lua_newtable( L); // out while( lua_next( KL, -2)) // storage key fifo { keeper_fifo* fifo = prepare_fifo_access( KL, -1); // storage key fifo lua_pushvalue( KL, -2); // storage key fifo key luaG_inter_move( KL, L, 1, eLM_FromKeeper); // storage key fifo // out key STACK_MID( L, 2); lua_newtable( L); // out key keyout luaG_inter_move( KL, L, 1, eLM_FromKeeper); // storage key // out key keyout fifo lua_pushinteger( L, fifo->first); // out key keyout fifo first STACK_MID( L, 5); lua_setfield( L, -3, "first"); // out key keyout fifo lua_pushinteger( L, fifo->count); // out key keyout fifo count STACK_MID( L, 5); lua_setfield( L, -3, "count"); // out key keyout fifo lua_pushinteger( L, fifo->limit); // out key keyout fifo limit STACK_MID( L, 5); lua_setfield( L, -3, "limit"); // out key keyout fifo lua_setfield( L, -2, "fifo"); // out key keyout lua_rawset( L, -3); // out STACK_MID( L, 1); } STACK_END( L, 1); lua_pop( KL, 1); // STACK_END( KL, 0); keeper_release( K); return 1; }
/******************************************************************************* 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); }
bool FlowCtlIterator::nextImpl(store::Item_t& result, PlanState& planState) const { PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); throw FlowCtlException(act); STACK_END(state); }
bool SingletonIterator::nextImpl(store::Item_t& result, PlanState& planState) const { PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); result = theValue; STACK_PUSH ( result != NULL, state ); STACK_END (state); }
bool ExitIterator::nextImpl(store::Item_t& result, PlanState& planState) const { PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); throw ExitException(new PlanIteratorWrapper(theChild, planState)); STACK_END(state); }
/* * Initialize keeper states * * If there is a problem, return an error message (NULL for okay). * * Note: Any problems would be design flaws; the created Lua state is left * unclosed, because it does not really matter. In production code, this * function never fails. * settings table is at position 1 on the stack */ char const* init_keepers( lua_State* L) { int i; PROPAGATE_ALLOCF_PREP( L); STACK_CHECK( L); lua_getfield( L, 1, "nb_keepers"); GNbKeepers = (int) lua_tointeger( L, -1); lua_pop( L, 1); STACK_END( L, 0); assert( GNbKeepers >= 1); GKeepers = malloc( GNbKeepers * sizeof( struct s_Keeper)); for( i = 0; i < GNbKeepers; ++ i) { lua_State* K = PROPAGATE_ALLOCF_ALLOC(); if( K == NULL) { (void) luaL_error( L, "init_keepers() failed while creating keeper state; out of memory"); } STACK_CHECK( K); // to see VM name in Decoda debugger lua_pushliteral( K, "Keeper #"); lua_pushinteger( K, i + 1); lua_concat( K, 2); lua_setglobal( K, "decoda_name"); // create the fifos table in the keeper state lua_pushlightuserdata( K, fifos_key); lua_newtable( K); lua_rawset( K, LUA_REGISTRYINDEX); STACK_END( K, 0); // we can trigger a GC from inside keeper_call(), where a keeper is acquired // from there, GC can collect a linda, which would acquire the keeper again, and deadlock the thread. MUTEX_RECURSIVE_INIT( &GKeepers[i].lock_); GKeepers[i].L = K; } #if HAVE_KEEPER_ATEXIT_DESINIT atexit( atexit_close_keepers); #endif // HAVE_KEEPER_ATEXIT_DESINIT return NULL; // ok }
bool PromoteIterator::nextImpl(store::Item_t& result, PlanState& planState) const { store::Item_t item; store::Item_t temp; const TypeManager* tm = theSctx->get_typemanager(); PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); if (!consumeNext(item, theChild.getp(), planState)) { if (theQuantifier == SequenceType::QUANT_PLUS || theQuantifier == SequenceType::QUANT_ONE) { raiseError("empty-sequence()"); } } else if (theQuantifier == SequenceType::QUANT_QUESTION || theQuantifier == SequenceType::QUANT_ONE) { if (consumeNext(temp, theChild.getp(), planState)) { raiseError("sequence of more than one item"); } // catch exceptions to add/change the error location if (! GenericCast::promote(result, item, thePromoteType, &theNsCtx, tm, loc)) { zstring valueType = tm->create_value_type(item)->toSchemaString(); raiseError(valueType); } STACK_PUSH(true, state); } else { do { if (! GenericCast::promote(result, item, thePromoteType, &theNsCtx, tm, loc)) { zstring valueType = tm->create_value_type(item)->toSchemaString(); raiseError(valueType); } else { STACK_PUSH(true, state); } } while (consumeNext(item, theChild.getp(), planState)); } STACK_END(state); }
void pps(Process* p, Eterm* stop) { fmtfn_t to = ERTS_PRINT_STDOUT; void *to_arg = NULL; Eterm* sp = STACK_START(p) - 1; if (stop <= STACK_END(p)) { stop = STACK_END(p) + 1; } while(sp >= stop) { erts_print(to, to_arg, "%0*lx: ", PTR_SIZE, (UWord) sp); if (is_catch(*sp)) { erts_print(to, to_arg, "catch %ld", (UWord)catch_pc(*sp)); } else { paranoid_display(to, to_arg, p, *sp); } erts_putc(to, to_arg, '\n'); sp--; } }
/* * Sets up [-1]<->[-2] two-way lookups, and ensures the lookup table exists. * Pops the both values off the stack. */ static void set_deep_lookup( lua_State* L) { STACK_GROW( L, 3); STACK_CHECK( L); // a b push_registry_subtable( L, DEEP_LOOKUP_KEY); // a b {} STACK_MID( L, 1); lua_insert( L, -3); // {} a b lua_pushvalue( L, -1); // {} a b b lua_pushvalue( L,-3); // {} a b b a lua_rawset( L, -5); // {} a b lua_rawset( L, -3); // {} lua_pop( L, 1); // STACK_END( L, -2); }
bool NodePositionIterator::nextImpl(store::Item_t& result, PlanState& planState) const { bool valid; store::Item_t inNode; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); valid = consumeNext(inNode, theChildren[0], planState); assert(valid); STACK_PUSH(GENV_STORE.getStructuralInformation(result, inNode), state); STACK_END(state); }
/* * Pops the key (metatable or idfunc) off the stack, and replaces with the * deep lookup value (idfunc/metatable/nil). */ static void get_deep_lookup( lua_State* L) { STACK_GROW( L, 1); STACK_CHECK( L); // a lua_pushlightuserdata( L, DEEP_LOOKUP_KEY); // a DLK lua_rawget( L, LUA_REGISTRYINDEX); // a {} if( !lua_isnil( L, -1)) { lua_insert( L, -2); // {} a lua_rawget( L, -2); // {} b } lua_remove( L, -2); // a|b STACK_END( L, 0); }
/******************************************************************************* declare updating function put($uri as xs:string, $doc as xs:document-node()) as empty-sequence() ********************************************************************************/ bool PutDocumentIterator::nextImpl( store::Item_t& result, PlanState& aPlanState) const { zstring lRetrievedUriString; zstring lResolvedUriString; store::Item_t lUri; store::Item_t lDoc; store::Item_t lResolvedUriItem; std::unique_ptr<store::PUL> lPul; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, aPlanState); consumeNext(lUri, theChildren[0].getp(), aPlanState); // absolutize retrieved uri try { lUri->getStringValue2(lRetrievedUriString); lResolvedUriString = theSctx->resolve_relative_uri(lRetrievedUriString, true); } catch (ZorbaException const&) { RAISE_ERROR(err::FODC0004, loc, ERROR_PARAMS(lResolvedUriString, ZED(NoResolveRelativeURI))); } // check if document already exists in the store if (GENV_STORE.getDocument(lResolvedUriString) != NULL) { RAISE_ERROR(zerr::ZAPI0020_DOCUMENT_ALREADY_EXISTS, loc, ERROR_PARAMS(lResolvedUriString)); } // create the pul and add the primitive GENV_ITEMFACTORY->createAnyURI(lResolvedUriItem, lResolvedUriString); lPul.reset(GENV_ITEMFACTORY->createPendingUpdateList()); consumeNext(lDoc, theChildren[1].getp(), aPlanState); lPul->addCreateDocument(&loc, lResolvedUriItem, lDoc); result = lPul.release(); STACK_PUSH(result != NULL, state); STACK_END(state); }
/* * Access deep userdata through a proxy. * * Reference count is not changed, and access to the deep userdata is not * serialized. It is the module's responsibility to prevent conflicting usage. */ void* luaG_todeep( lua_State* L, luaG_IdFunction idfunc, int index) { DEEP_PRELUDE** proxy; STACK_CHECK( L); // ensure it is actually a deep userdata if( get_idfunc( L, index, eLM_LaneBody) != idfunc) { return NULL; // no metatable, or wrong kind } proxy = (DEEP_PRELUDE**) lua_touserdata( L, index); STACK_END( L, 0); return (*proxy)->deep; }