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