void eval() {
cont = continuation(cont_end, NIL);
C(cont)->expand = YES;
eval:
if (C(cont)->expand)
cont = continuation(cont_macroexpand, continuation(cont_eval, cont));
else if (iscons(expr))
cont = continuation(cont_list, cont);
else if (issymbol(expr))
cont = continuation(cont_symbol, cont);
apply_cont:
assert(iscontinuation(cont));
switch(C(cont)->fn()) {
case ACTION_EVAL:
goto eval;
case ACTION_APPLY_CONT:
goto apply_cont;
case ACTION_DONE:
break;
default:
abort();
}
/* By the time we get here, we should have finished the entire
computation, so should no longer have a continuation.*/
assert(isnil(cont));
}
IntRect RenderInline::clippedOverflowRectForRepaint(RenderBox* repaintContainer)
{
// Only run-ins are allowed in here during layout.
ASSERT(!view() || !view()->layoutStateEnabled() || isRunIn());
if (!firstLineBox() && !continuation())
return IntRect();
// Find our leftmost position.
IntRect boundingBox(linesBoundingBox());
int left = boundingBox.x();
int top = boundingBox.y();
// Now invalidate a rectangle.
int ow = style() ? style()->outlineSize() : 0;
// We need to add in the relative position offsets of any inlines (including us) up to our
// containing block.
RenderBlock* cb = containingBlock();
for (RenderObject* inlineFlow = this; inlineFlow && inlineFlow->isRenderInline() && inlineFlow != cb;
inlineFlow = inlineFlow->parent()) {
if (inlineFlow->style()->position() == RelativePosition && inlineFlow->hasLayer())
toRenderBox(inlineFlow)->layer()->relativePositionOffset(left, top);
}
IntRect r(-ow + left, -ow + top, boundingBox.width() + ow * 2, boundingBox.height() + ow * 2);
if (cb->hasColumns())
cb->adjustRectForColumns(r);
if (cb->hasOverflowClip()) {
// cb->height() is inaccurate if we're in the middle of a layout of |cb|, so use the
// layer's size instead. Even if the layer's size is wrong, the layer itself will repaint
// anyway if its size does change.
int x = r.x();
int y = r.y();
IntRect boxRect(0, 0, cb->layer()->width(), cb->layer()->height());
cb->layer()->subtractScrolledContentOffset(x, y); // For overflow:auto/scroll/hidden.
IntRect repaintRect(x, y, r.width(), r.height());
r = intersection(repaintRect, boxRect);
}
ASSERT(repaintContainer != this);
cb->computeRectForRepaint(r, repaintContainer);
if (ow) {
for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
if (!curr->isText()) {
IntRect childRect = curr->rectWithOutlineForRepaint(repaintContainer, ow);
r.unite(childRect);
}
}
if (continuation() && !continuation()->isInline()) {
IntRect contRect = continuation()->rectWithOutlineForRepaint(repaintContainer, ow);
r.unite(contRect);
}
}
return r;
}
void RenderBoxModelObject::computeLayerHitTestRects(LayerHitTestRects& rects) const
{
RenderLayerModelObject::computeLayerHitTestRects(rects);
// If there is a continuation then we need to consult it here, since this is
// the root of the tree walk and it wouldn't otherwise get picked up.
// Continuations should always be siblings in the tree, so any others should
// get picked up already by the tree walk.
if (continuation())
continuation()->computeLayerHitTestRects(rects);
}
void RenderInline::absoluteQuads(Vector<FloatQuad>& quads, bool topLevel)
{
for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
FloatRect localRect(curr->xPos(), curr->yPos(), curr->width(), curr->height());
quads.append(localToAbsoluteQuad(localRect));
}
for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
if (!curr->isText())
curr->absoluteQuads(quads, false);
}
if (continuation() && topLevel)
continuation()->absoluteQuads(quads, topLevel);
}
void RenderInline::styleDidChange(RenderStyle::Diff diff, const RenderStyle* oldStyle)
{
RenderFlow::styleDidChange(diff, oldStyle);
setInline(true);
//Nicki Vankoughnett: this change is indicated in webkit changest 37637,
//but not obviously relevant to changes to the RenderStyle class.
// setHasReflection(false);
// Ensure that all of the split inlines pick up the new style. We
// only do this if we're an inline, since we don't want to propagate
// a block's style to the other inlines.
// e.g., <font>foo <h4>goo</h4> moo</font>. The <font> inlines before
// and after the block share the same style, but the block doesn't
// need to pass its style on to anyone else.
RenderFlow* currCont = continuation();
while (currCont) {
if (currCont->isInline()) {
RenderFlow* nextCont = currCont->continuation();
currCont->setContinuation(0);
currCont->setStyle(style());
currCont->setContinuation(nextCont);
}
currCont = currCont->continuation();
}
m_lineHeight = -1;
// Update pseudos for :before and :after now.
if (!isAnonymous()) {
updateBeforeAfterContent(RenderStyle::BEFORE);
updateBeforeAfterContent(RenderStyle::AFTER);
}
}
/*
* Block current thread and continue execution in a new thread
*/
int
ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
int rslt;
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
if (stack_size > 0) {
pthread_attr_setstacksize(&attr, stack_size);
}
if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) {
void * tmp;
pthread_join(tid, &tmp);
rslt = (int)tmp;
} else {
/*
* Continue execution in current thread if for some reason (e.g. out of
* memory/LWP) a new thread can't be created. This will likely fail
* later in continuation as JNI_CreateJavaVM needs to create quite a
* few new threads, anyway, just give it a try..
*/
rslt = continuation(args);
}
pthread_attr_destroy(&attr);
return rslt;
}
void RenderInline::absoluteRects(Vector<IntRect>& rects, int tx, int ty, bool topLevel)
{
for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
rects.append(IntRect(tx + curr->xPos(), ty + curr->yPos(), curr->width(), curr->height()));
for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
if (!curr->isText())
curr->absoluteRects(rects, tx + curr->xPos(), ty + curr->yPos(), false);
}
if (continuation() && topLevel)
continuation()->absoluteRects(rects,
tx - containingBlock()->xPos() + continuation()->xPos(),
ty - containingBlock()->yPos() + continuation()->yPos(),
topLevel);
}
void RenderInline::setStyle(RenderStyle* newStyle)
{
RenderFlow::setStyle(newStyle);
setInline(true);
// Ensure that all of the split inlines pick up the new style. We
// only do this if we're an inline, since we don't want to propagate
// a block's style to the other inlines.
// e.g., <font>foo <h4>goo</h4> moo</font>. The <font> inlines before
// and after the block share the same style, but the block doesn't
// need to pass its style on to anyone else.
RenderFlow* currCont = continuation();
while (currCont) {
if (currCont->isInline()) {
RenderFlow* nextCont = currCont->continuation();
currCont->setContinuation(0);
currCont->setStyle(style());
currCont->setContinuation(nextCont);
}
currCont = currCont->continuation();
}
m_lineHeight = -1;
// Update pseudos for :before and :after now.
if (!isAnonymous()) {
updateBeforeAfterContent(RenderStyle::BEFORE);
updateBeforeAfterContent(RenderStyle::AFTER);
}
}
static void native_thread_run(struct c_state *c_state)
{
void (*continuation)(void);
DIAGNOSTIC(2,"starting new native thread, waiting for event",0,0);
wait_for_event(c_state->native.event);
continuation = (void (*)(void))c_state->eip;
DIAGNOSTIC(3,"in new thread, calling continuation 0x%x",continuation,0);
continuation();
}
static action_t cont_macroexpand() {
C(cont)->expand = (expr != C(cont)->val[0]);
if(!C(cont)->expand) {
pop_cont();
return ACTION_APPLY_CONT;
}
C(cont)->val[0] = expr;
cont = continuation(cont_macroexpand1, cont);
return ACTION_APPLY_CONT;
}
/*
* Block current thread and continue execution in a new thread
*/
int
ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
int rslt;
#ifndef __solaris__
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
if (stack_size > 0) {
pthread_attr_setstacksize(&attr, stack_size);
}
if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) {
void * tmp;
pthread_join(tid, &tmp);
rslt = (int)(intptr_t)tmp;
} else {
/*
* Continue execution in current thread if for some reason (e.g. out of
* memory/LWP) a new thread can't be created. This will likely fail
* later in continuation as JNI_CreateJavaVM needs to create quite a
* few new threads, anyway, just give it a try..
*/
rslt = continuation(args);
}
pthread_attr_destroy(&attr);
#else /* __solaris__ */
thread_t tid;
long flags = 0;
if (thr_create(NULL, stack_size, (void *(*)(void *))continuation, args, flags, &tid) == 0) {
void * tmp;
thr_join(tid, NULL, &tmp);
rslt = (int)(intptr_t)tmp;
} else {
/* See above. Continue in current thread if thr_create() failed */
rslt = continuation(args);
}
#endif /* !__solaris__ */
return rslt;
}
void executive::ReconvergenceBarrier::eval_Bar(executive::CTAContext &context,
const ir::PTXInstruction &instr) {
CTAContext continuation(context);
runtimeStack.pop_back();
if (runtimeStack.size() == 0) {
continuation.active.set();
continuation.PC = context.PC + 1;
runtimeStack.push_back(continuation);
}
}
void RenderBoxModelObject::willBeDestroyed()
{
ImageQualityController::remove(this);
// A continuation of this RenderObject should be destroyed at subclasses.
ASSERT(!continuation());
// If this is a first-letter object with a remaining text fragment then the
// entry needs to be cleared from the map.
if (firstLetterRemainingText())
setFirstLetterRemainingText(0);
RenderLayerModelObject::willBeDestroyed();
}
static BOOST_FORCEINLINE i_t select(A0& x)
{
// find significand in antilog table A[]
i_t i = One<i_t>();
i = if_else((x <= twomio16(Nine<i_t>())) , Nine<i_t>(), i);
i = seladd ((x <= twomio16(i+Four<i_t>())), i, Four<i_t>());
i = seladd ((x <= twomio16(i+Two<i_t>())) , i, Two<i_t>() );
i = if_else((x >= twomio16(One<i_t>())) , Mone<i_t>(), i);
i = inc(i);
A0 tmp = twomio16(i);
x -= tmp;
x -= continuation(shr(i, 1));
x /= tmp;
return i;
}
void CFA::verify() {
bool error = false;
for (const auto& p : nodes()) {
auto in = p.second;
if (in != entry() && in->preds_.size() == 0) {
VLOG("missing predecessors: {}", in->continuation());
error = true;
}
}
if (error) {
// TODO
//ycomp();
assert(false && "CFG not sound");
}
}
VisiblePosition RenderInline::positionForCoordinates(int x, int y)
{
// Translate the coords from the pre-anonymous block to the post-anonymous block.
RenderBlock* cb = containingBlock();
int parentBlockX = cb->xPos() + x;
int parentBlockY = cb->yPos() + y;
for (RenderObject* c = continuation(); c; c = c->continuation()) {
RenderObject* contBlock = c;
if (c->isInline())
contBlock = c->containingBlock();
if (c->isInline() || c->firstChild())
return c->positionForCoordinates(parentBlockX - contBlock->xPos(), parentBlockY - contBlock->yPos());
}
return RenderFlow::positionForCoordinates(x, y);
}
// Expected value using row rearrangement
//[[Rcpp::export]]
arma::mat Expected(const arma::mat& grid,
const arma::mat& value,
const arma::cube& disturb,
const arma::vec& weight) {
// Passing R objects to C++
const std::size_t n_grid = grid.n_rows;
const std::size_t n_dim = grid.n_cols;
const std::size_t n_disturb = disturb.n_slices;
// Computing the continuation value function
arma::mat continuation(n_grid, n_dim, arma::fill::zeros);
arma::mat d_value(n_grid, n_dim);
for (std::size_t dd = 0; dd < n_disturb; dd++) {
d_value = value * disturb.slice(dd);
continuation += weight(dd) * Optimal(grid, d_value);
}
return continuation;
}
/*
* Block current thread and continue execution in a new thread
*/
int
ContinueInNewThread(int (JNICALL *continuation)(void *), jlong stack_size, void * args, int ret) {
int rslt = 0;
unsigned thread_id;
#ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
#define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000)
#endif
/*
* STACK_SIZE_PARAM_IS_A_RESERVATION is what we want, but it's not
* supported on older version of Windows. Try first with the flag; and
* if that fails try again without the flag. See MSDN document or HotSpot
* source (os_win32.cpp) for details.
*/
HANDLE thread_handle =
(HANDLE)_beginthreadex(NULL,
(unsigned)stack_size,
continuation,
args,
STACK_SIZE_PARAM_IS_A_RESERVATION,
&thread_id);
if (thread_handle == NULL) {
thread_handle =
(HANDLE)_beginthreadex(NULL,
(unsigned)stack_size,
continuation,
args,
0,
&thread_id);
}
if (thread_handle) {
WaitForSingleObject(thread_handle, INFINITE);
GetExitCodeThread(thread_handle, &rslt);
CloseHandle(thread_handle);
} else {
rslt = continuation(args);
}
/* If the caller has deemed there is an error we
* simply return that, otherwise we return the value of
* the callee
*/
return (ret != 0) ? ret : rslt;
}
void RenderInline::addChildToFlow(RenderObject* newChild, RenderObject* beforeChild)
{
// Make sure we don't append things after :after-generated content if we have it.
if (!beforeChild && isAfterContent(lastChild()))
beforeChild = lastChild();
if (!newChild->isInline() && !newChild->isFloatingOrPositioned()) {
// We are placing a block inside an inline. We have to perform a split of this
// inline into continuations. This involves creating an anonymous block box to hold
// |newChild|. We then make that block box a continuation of this inline. We take all of
// the children after |beforeChild| and put them in a clone of this object.
RefPtr<RenderStyle> newStyle = RenderStyle::create();
newStyle->inheritFrom(style());
newStyle->setDisplay(BLOCK);
RenderBlock* newBox = new (renderArena()) RenderBlock(document() /* anonymous box */);
newBox->setStyle(newStyle.release());
RenderFlow* oldContinuation = continuation();
setContinuation(newBox);
// Someone may have put a <p> inside a <q>, causing a split. When this happens, the :after content
// has to move into the inline continuation. Call updateBeforeAfterContent to ensure that our :after
// content gets properly destroyed.
bool isLastChild = (beforeChild == lastChild());
if (document()->usesBeforeAfterRules())
updateBeforeAfterContent(RenderStyle::AFTER);
if (isLastChild && beforeChild != lastChild())
beforeChild = 0; // We destroyed the last child, so now we need to update our insertion
// point to be 0. It's just a straight append now.
splitFlow(beforeChild, newBox, newChild, oldContinuation);
return;
}
RenderContainer::addChild(newChild, beforeChild);
newChild->setNeedsLayoutAndPrefWidthsRecalc();
}
UTF8Input& UTF8Input::get_cps(F validate, C continuation) {
char32_t c = strip_nonanwp();
if (c == std::char_traits<char32_t>::eof()) {
throw EndOfFileE("Encountered an unexpected end-of-file marker");
}
size_t size = 0;
std::vector<std::string> buffer = { std::string(1, c) };
buffer[0].reserve(24); // 2**64 has 20 digits.
while (true) {
const size_t capacity = buffer.back().capacity();
for (size_t ii = buffer.back().size(); ii < capacity; ++ii) {
if (validate(c = get_char())) {
buffer.back() += c;
} else {
size += buffer.back().size();
return continuation(std::move(buffer), size);
}
}
size += buffer.back().size();
buffer.push_back(std::string());
buffer.back().reserve(size); // Double the current size.
}
}
static void fn_macroexpand1() {
init_vals(cont);
C(cont)->fn = cont_macroexpand1;
cont = continuation(NULL, cont);
expr = lookup(sym_args);
}
void RenderContainer::updateBeforeAfterContentForContainer(RenderStyle::PseudoId type, RenderContainer* styledObject)
{
// In CSS2, before/after pseudo-content cannot nest. Check this first.
if (style()->styleType() == RenderStyle::BEFORE || style()->styleType() == RenderStyle::AFTER)
return;
RenderStyle* pseudoElementStyle = styledObject->getCachedPseudoStyle(type);
RenderObject* child = beforeAfterContainer(type);
// Whether or not we currently have generated content attached.
bool oldContentPresent = child;
// Whether or not we now want generated content.
bool newContentWanted = pseudoElementStyle && pseudoElementStyle->display() != NONE;
// For <q><p/></q>, if this object is the inline continuation of the <q>, we only want to generate
// :after content and not :before content.
if (newContentWanted && type == RenderStyle::BEFORE && isInlineContinuation())
newContentWanted = false;
// Similarly, if we're the beginning of a <q>, and there's an inline continuation for our object,
// then we don't generate the :after content.
if (newContentWanted && type == RenderStyle::AFTER && isRenderInline() && continuation())
newContentWanted = false;
// If we don't want generated content any longer, or if we have generated content, but it's no longer
// identical to the new content data we want to build render objects for, then we nuke all
// of the old generated content.
if (!newContentWanted || (oldContentPresent && !child->style()->contentDataEquivalent(pseudoElementStyle))) {
// Nuke the child.
if (child && child->style()->styleType() == type) {
oldContentPresent = false;
child->destroy();
child = (type == RenderStyle::BEFORE) ? m_firstChild : m_lastChild;
}
}
// If we have no pseudo-element style or if the pseudo-element style's display type is NONE, then we
// have no generated content and can now return.
if (!newContentWanted)
return;
if (isInlineFlow() && !pseudoElementStyle->isDisplayInlineType() && pseudoElementStyle->floating() == FNONE &&
!(pseudoElementStyle->position() == AbsolutePosition || pseudoElementStyle->position() == FixedPosition))
// According to the CSS2 spec (the end of section 12.1), the only allowed
// display values for the pseudo style are NONE and INLINE for inline flows.
// FIXME: CSS2.1 lifted this restriction, but block display types will crash.
// For now we at least relax the restriction to allow all inline types like inline-block
// and inline-table.
pseudoElementStyle->setDisplay(INLINE);
if (oldContentPresent) {
if (child && child->style()->styleType() == type) {
// We have generated content present still. We want to walk this content and update our
// style information with the new pseudo-element style.
child->setStyle(pseudoElementStyle);
// Note that if we ever support additional types of generated content (which should be way off
// in the future), this code will need to be patched.
for (RenderObject* genChild = child->firstChild(); genChild; genChild = genChild->nextSibling()) {
if (genChild->isText())
// Generated text content is a child whose style also needs to be set to the pseudo-element style.
genChild->setStyle(pseudoElementStyle);
else if (genChild->isImage()) {
// Images get an empty style that inherits from the pseudo.
RefPtr<RenderStyle> style = RenderStyle::create();
style->inheritFrom(pseudoElementStyle);
genChild->setStyle(style.release());
} else
// Must be a first-letter container. updateFirstLetter() will take care of it.
ASSERT(genChild->style()->styleType() == RenderStyle::FIRST_LETTER);
}
}
return; // We've updated the generated content. That's all we needed to do.
}
RenderObject* insertBefore = (type == RenderStyle::BEFORE) ? firstChild() : 0;
// Generated content consists of a single container that houses multiple children (specified
// by the content property). This generated content container gets the pseudo-element style set on it.
RenderObject* generatedContentContainer = 0;
// Walk our list of generated content and create render objects for each.
for (const ContentData* content = pseudoElementStyle->contentData(); content; content = content->m_next) {
RenderObject* renderer = 0;
switch (content->m_type) {
case CONTENT_NONE:
break;
case CONTENT_TEXT:
renderer = new (renderArena()) RenderTextFragment(document() /* anonymous object */, content->m_content.m_text);
renderer->setStyle(pseudoElementStyle);
break;
case CONTENT_OBJECT: {
RenderImageGeneratedContent* image = new (renderArena()) RenderImageGeneratedContent(document()); // anonymous object
RefPtr<RenderStyle> style = RenderStyle::create();
style->inheritFrom(pseudoElementStyle);
image->setStyle(style.release());
if (StyleImage* styleImage = content->m_content.m_image)
image->setStyleImage(styleImage);
renderer = image;
break;
}
case CONTENT_COUNTER:
renderer = new (renderArena()) RenderCounter(document(), *content->m_content.m_counter);
renderer->setStyle(pseudoElementStyle);
break;
}
if (renderer) {
if (!generatedContentContainer) {
// Make a generated box that might be any display type now that we are able to drill down into children
// to find the original content properly.
generatedContentContainer = RenderObject::createObject(document(), pseudoElementStyle);
generatedContentContainer->setStyle(pseudoElementStyle);
}
generatedContentContainer->addChild(renderer);
}
}
// Add the pseudo after we've installed all our content so that addChild will be able to find the text
// inside the inline for e.g., first-letter styling.
if (generatedContentContainer)
addChild(generatedContentContainer, insertBefore);
}
namespace RPC {
static
UseCoroutines defaultUseCoroutines = UseCoroutines::no;
Suspend const dontSuspend = [] (Continuation const& continuation)
{
continuation([] () {});
};
namespace {
void runOnJobQueue(
Application& app, std::string const& name, Callback const& callback)
{
auto cb = [callback] (Job&) { callback(); };
app.getJobQueue().addJob(jtCLIENT, name, cb);
};
Callback suspendForJobQueue(
Application& app, Suspend const& suspend, std::string const& jobName)
{
assert(suspend);
return Callback( [suspend, jobName, &app] () {
suspend([jobName, &app] (Callback const& callback) {
runOnJobQueue(app, jobName, callback);
});
});
}
} // namespace
Json::Output chunkedYieldingOutput (
Json::Output const& output, Callback const& yield, std::size_t chunkSize)
{
if (!yield)
return output;
auto count = std::make_shared <std::size_t> (0);
return [chunkSize, count, output, yield] (boost::string_ref const& bytes)
{
if (*count > chunkSize)
{
yield();
*count = 0;
}
output (bytes);
*count += bytes.size();
};
}
CountedYield::CountedYield (std::size_t yieldCount, Callback const& yield)
: yieldCount_ (yieldCount), yield_ (yield)
{
}
void CountedYield::yield()
{
if (yieldCount_ && yield_)
{
if (++count_ >= yieldCount_)
{
yield_();
count_ = 0;
}
}
}
UseCoroutines useCoroutines(BasicConfig const& config)
{
if (auto use = config["section"].get<bool>("use_coroutines"))
return *use ? UseCoroutines::yes : UseCoroutines::no;
return defaultUseCoroutines;
}
YieldStrategy makeYieldStrategy (BasicConfig const& config)
{
auto s = config["section"];
YieldStrategy ys;
ys.streaming = get<bool> (s, "streaming") ?
YieldStrategy::Streaming::yes :
YieldStrategy::Streaming::no;
ys.useCoroutines = useCoroutines(config);
ys.accountYieldCount = get<std::size_t> (s, "account_yield_count");
ys.transactionYieldCount = get<std::size_t> (s, "transaction_yield_count");
return ys;
}
JobQueueSuspender::JobQueueSuspender(
Application& app, Suspend const& susp, std::string const& jobName)
: suspend(susp ? susp : dontSuspend),
yield(suspendForJobQueue(app, suspend, jobName))
{
// There's a non-empty jobName exactly if there's a non-empty Suspend.
assert(!(susp && jobName.empty()));
}
JobQueueSuspender::JobQueueSuspender(Application &app)
: JobQueueSuspender(app, {}, {})
{
}
} // RPC
/// Returns the two iterator pairs describing the first and second part
/// of the partitioned list.
std::array<range, 2> ranges() {
return {{range{begin(), separator()}, range{continuation(), end()}}};
}
static void fn_apply() {
eval_apply(check_function(lookup(sym_fn)));
cont = continuation(NULL, cont);
expr = check_list(lookup(sym_args));
}
/*
* Block current thread and continue execution in a new thread
*/
int
ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
int rslt = 0;
unsigned thread_id;
#ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
#define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000)
#endif
/*
* STACK_SIZE_PARAM_IS_A_RESERVATION is what we want, but it's not
* supported on older version of Windows. Try first with the flag; and
* if that fails try again without the flag. See MSDN document or HotSpot
* source (os_win32.cpp) for details.
*/
HANDLE thread_handle =
(HANDLE)_beginthreadex(NULL,
(unsigned)stack_size,
continuation,
args,
STACK_SIZE_PARAM_IS_A_RESERVATION,
&thread_id);
if (thread_handle == NULL) {
thread_handle =
(HANDLE)_beginthreadex(NULL,
(unsigned)stack_size,
continuation,
args,
0,
&thread_id);
}
/* AWT preloading (AFTER main thread start) */
#ifdef ENABLE_AWT_PRELOAD
/* D3D preloading */
if (awtPreloadD3D != 0) {
char *envValue;
/* D3D routines checks env.var J2D_D3D if no appropriate
* command line params was specified
*/
envValue = getenv("J2D_D3D");
if (envValue != NULL && JLI_StrCaseCmp(envValue, "false") == 0) {
awtPreloadD3D = 0;
}
/* Test that AWT preloading isn't disabled by J2D_D3D_PRELOAD env.var */
envValue = getenv("J2D_D3D_PRELOAD");
if (envValue != NULL && JLI_StrCaseCmp(envValue, "false") == 0) {
awtPreloadD3D = 0;
}
if (awtPreloadD3D < 0) {
/* If awtPreloadD3D is still undefined (-1), test
* if it is turned on by J2D_D3D_PRELOAD env.var.
* By default it's turned OFF.
*/
awtPreloadD3D = 0;
if (envValue != NULL && JLI_StrCaseCmp(envValue, "true") == 0) {
awtPreloadD3D = 1;
}
}
}
if (awtPreloadD3D) {
AWTPreload(D3D_PRELOAD_FUNC);
}
#endif /* ENABLE_AWT_PRELOAD */
if (thread_handle) {
WaitForSingleObject(thread_handle, INFINITE);
GetExitCodeThread(thread_handle, &rslt);
CloseHandle(thread_handle);
} else {
rslt = continuation(args);
}
#ifdef ENABLE_AWT_PRELOAD
if (awtPreloaded) {
AWTPreloadStop();
}
#endif /* ENABLE_AWT_PRELOAD */
return rslt;
}
std::ostream& CFNode::stream(std::ostream& out) const { return streamf(out, "{}", continuation()); }
