void
timer_call_shutdown(
processor_t processor)
{
timer_call_t call;
queue_t queue, myqueue;
assert(processor != current_processor());
queue = &PROCESSOR_DATA(processor, timer_call_queue);
myqueue = &PROCESSOR_DATA(current_processor(), timer_call_queue);
simple_lock(&timer_call_lock);
call = TC(queue_first(queue));
while (!queue_end(queue, qe(call))) {
_delayed_call_dequeue(call);
_delayed_call_enqueue(myqueue, call);
call = TC(queue_first(queue));
}
call = TC(queue_first(myqueue));
if (!queue_end(myqueue, qe(call)))
_set_delayed_call_timer(call);
simple_unlock(&timer_call_lock);
}
static void test2(char const *ex) {
smt_params params;
params.m_model = true;
ast_manager m;
reg_decl_plugins(m);
arith_util a(m);
expr_ref fml = parse_fml(m, ex);
app_ref_vector vars(m);
expr_ref_vector lits(m);
vars.push_back(m.mk_const(symbol("x"), a.mk_real()));
vars.push_back(m.mk_const(symbol("y"), a.mk_real()));
vars.push_back(m.mk_const(symbol("z"), a.mk_real()));
flatten_and(fml, lits);
smt::context ctx(m, params);
ctx.push();
ctx.assert_expr(fml);
lbool result = ctx.check();
VERIFY(result == l_true);
ref<model> md;
ctx.get_model(md);
ctx.pop(1);
std::cout << mk_pp(fml, m) << "\n";
expr_ref pr1(m), pr2(m), fml2(m);
expr_ref_vector bound(m);
ptr_vector<sort> sorts;
svector<symbol> names;
for (unsigned i = 0; i < vars.size(); ++i) {
bound.push_back(vars[i].get());
names.push_back(vars[i]->get_decl()->get_name());
sorts.push_back(m.get_sort(vars[i].get()));
}
expr_abstract(m, 0, bound.size(), bound.c_ptr(), fml, fml2);
fml2 = m.mk_exists(bound.size(), sorts.c_ptr(), names.c_ptr(), fml2);
qe::expr_quant_elim qe(m, params);
for (unsigned i = 0; i < vars.size(); ++i) {
VERIFY(qe::arith_project(*md, vars[i].get(), lits));
}
pr1 = mk_and(lits);
qe(m.mk_true(), fml2, pr2);
std::cout << mk_pp(pr1, m) << "\n";
std::cout << mk_pp(pr2, m) << "\n";
expr_ref npr2(m);
npr2 = m.mk_not(pr2);
ctx.push();
ctx.assert_expr(pr1);
ctx.assert_expr(npr2);
VERIFY(l_false == ctx.check());
ctx.pop(1);
}
boolean_t
thread_call_enter1_delayed(
thread_call_t call,
thread_call_param_t param1,
uint64_t deadline)
{
boolean_t result = TRUE;
thread_call_group_t group;
spl_t s;
group = thread_call_get_group(call);
s = splsched();
thread_call_lock_spin();
result = _delayed_call_enqueue(call, group, deadline);
if (queue_first(&group->delayed_queue) == qe(call))
_set_delayed_call_timer(call, group);
call->tc_call.param1 = param1;
thread_call_unlock();
splx(s);
return (result);
}
mpqueue_head_t *
timer_call_dequeue_unlocked(
timer_call_t call)
{
call_entry_t entry = CE(call);
mpqueue_head_t *old_queue;
DBG("timer_call_dequeue_unlocked(%p)\n", call);
simple_lock(&call->lock);
old_queue = MPQUEUE(entry->queue);
if (old_queue != NULL) {
timer_call_lock_spin(old_queue);
if (call->async_dequeue) {
/* collision (1c): null queue pointer and reset flag */
call->async_dequeue = FALSE;
#if TIMER_ASSERT
timer_call_dequeue_unlocked_async1++;
#endif
} else {
(void)remque(qe(entry));
#if TIMER_ASSERT
timer_call_dequeue_unlocked_async2++;
#endif
}
entry->queue = NULL;
timer_call_unlock(old_queue);
}
simple_unlock(&call->lock);
return (old_queue);
}
boolean_t
timer_call_cancel(
timer_call_t call)
{
boolean_t result = TRUE;
spl_t s;
s = splclock();
simple_lock(&timer_call_lock);
if (call->state == DELAYED) {
queue_t queue = &PROCESSOR_DATA(current_processor(), timer_call_queue);
if (queue_first(queue) == qe(call)) {
_delayed_call_dequeue(call);
if (!queue_empty(queue))
_set_delayed_call_timer((timer_call_t)queue_first(queue));
}
else
_delayed_call_dequeue(call);
}
else
result = FALSE;
simple_unlock(&timer_call_lock);
splx(s);
return (result);
}
boolean_t
timer_call_enter1(
timer_call_t call,
timer_call_param_t param1,
uint64_t deadline)
{
boolean_t result = TRUE;
queue_t queue;
spl_t s;
s = splclock();
simple_lock(&timer_call_lock);
if (call->state == DELAYED)
_delayed_call_dequeue(call);
else
result = FALSE;
call->param1 = param1;
call->deadline = deadline;
queue = &PROCESSOR_DATA(current_processor(), timer_call_queue);
_delayed_call_enqueue(queue, call);
if (queue_first(queue) == qe(call))
_set_delayed_call_timer(call);
simple_unlock(&timer_call_lock);
splx(s);
return (result);
}
/*
* thread_call_func_delayed:
*
* Enqueue a function callout to
* occur at the stated time.
*/
void
thread_call_func_delayed(
thread_call_func_t func,
thread_call_param_t param,
uint64_t deadline)
{
thread_call_t call;
thread_call_group_t group = &thread_call_groups[THREAD_CALL_PRIORITY_HIGH];
spl_t s;
s = splsched();
thread_call_lock_spin();
call = _internal_call_allocate();
call->tc_call.func = func;
call->tc_call.param0 = param;
call->tc_call.param1 = 0;
_delayed_call_enqueue(call, group, deadline);
if (queue_first(&group->delayed_queue) == qe(call))
_set_delayed_call_timer(call, group);
thread_call_unlock();
splx(s);
}
/*
* _internal_call_release:
*
* Release an internal callout entry which
* is no longer pending (or delayed).
*
* Called with thread_call_lock held.
*/
static __inline__ void
_internal_call_release(
thread_call_t call)
{
if ( call >= internal_call_storage &&
call < &internal_call_storage[internal_call_count] )
enqueue_head(&thread_call_internal_queue, qe(call));
}
void execute(cmd_context & ctx) override {
proof_ref pr(ctx.m());
qe::simplify_rewriter_star qe(ctx.m());
expr_ref result(ctx.m());
qe(m_target, result, pr);
if (m_params.get_bool("print", true)) {
ctx.display(ctx.regular_stream(), result);
ctx.regular_stream() << std::endl;
}
if (m_params.get_bool("print_statistics", false)) {
statistics st;
qe.collect_statistics(st);
st.display(ctx.regular_stream());
}
}
/*
* _internal_call_release:
*
* Release an internal callout entry which
* is no longer pending (or delayed).
*
* Called with thread_call_lock held.
*/
static __inline__ void
_internal_call_release(
thread_call_t call)
{
if ( call >= internal_call_storage &&
call < &internal_call_storage[INTERNAL_CALL_COUNT] )
enqueue_head(&thread_call_internal_queue, qe(call));
}
static __inline__
void
_delayed_call_dequeue(
timer_call_t call)
{
(void)remque(qe(call));
call->state = IDLE;
}
void RT_IndicationProvider::_checkOperationContext(const OperationContext& context,
const String & funcName)
{
//
// Test the filter query container
//
SubscriptionFilterQueryContainer qContainer = context.get(SubscriptionFilterQueryContainer::NAME);
if (qContainer.getFilterQuery() == String::EMPTY)
{
PEGASUS_STD(cout) << funcName << "- empty filter query" << PEGASUS_STD(endl);
throw CIMOperationFailedException(funcName + "- empty filter query");
}
if (qContainer.getQueryLanguage() == String::EMPTY)
{
PEGASUS_STD(cout) << funcName << "- empty filter query lang" << PEGASUS_STD(endl);
throw CIMOperationFailedException(funcName + "- empty filter query lang");
}
CIMNamespaceName tst("root/SampleProvider");
if (!qContainer.getSourceNameSpace().equal(tst))
{
PEGASUS_STD(cout) << funcName << "- incorrect source namespace" << PEGASUS_STD(endl);
throw CIMOperationFailedException(funcName + "- incorrect source namespace");
}
try
{
//
// Try to parse the filter query from the filter query container
//
CIMOMHandleQueryContext ctx(qContainer.getSourceNameSpace(), _cimom);
QueryExpression qe(qContainer.getQueryLanguage(),
qContainer.getFilterQuery(),
ctx);
// Exercise the QueryExpression...this will cause repository access through
// the CIMOMHandleQueryContext.
qe.validate();
}
catch (Exception & e)
{
PEGASUS_STD(cout) << funcName << "- parse error: " << e.getMessage() << PEGASUS_STD(endl);
throw CIMOperationFailedException(funcName + "- parse error: " + e.getMessage());
}
//
// Test the filter condition container.
// Note: since this only contains the WHERE clause, the condition could be empty (and will
// be for some testcases)
//
SubscriptionFilterConditionContainer cContainer = context.get(SubscriptionFilterConditionContainer::NAME);
if (cContainer.getQueryLanguage() == String::EMPTY)
{
PEGASUS_STD(cout) << funcName << "- empty filter condition lang" << PEGASUS_STD(endl);
throw CIMOperationFailedException(funcName + "- empty filter condition lang");
}
}
/*
* thread_call_initialize:
*
* Initialize this module, called
* early during system initialization.
*/
void
thread_call_initialize(void)
{
thread_call_t call;
thread_call_group_t group = &thread_call_group0;
kern_return_t result;
thread_t thread;
int i;
spl_t s;
i = sizeof (thread_call_data_t);
thread_call_zone = zinit(i, 4096 * i, 16 * i, "thread_call");
zone_change(thread_call_zone, Z_CALLERACCT, FALSE);
zone_change(thread_call_zone, Z_NOENCRYPT, TRUE);
lck_attr_setdefault(&thread_call_lck_attr);
lck_grp_attr_setdefault(&thread_call_lck_grp_attr);
lck_grp_init(&thread_call_queues_lck_grp, "thread_call_queues", &thread_call_lck_grp_attr);
lck_grp_init(&thread_call_lck_grp, "thread_call", &thread_call_lck_grp_attr);
#if defined(__i386__) || defined(__x86_64__)
lck_mtx_init(&thread_call_lock_data, &thread_call_lck_grp, &thread_call_lck_attr);
#else
lck_spin_init(&thread_call_lock_data, &thread_call_lck_grp, &thread_call_lck_attr);
#endif
queue_init(&group->pending_queue);
queue_init(&group->delayed_queue);
s = splsched();
thread_call_lock_spin();
timer_call_setup(&group->delayed_timer, thread_call_delayed_timer, group);
wait_queue_init(&group->idle_wqueue, SYNC_POLICY_FIFO);
wait_queue_init(&group->daemon_wqueue, SYNC_POLICY_FIFO);
queue_init(&thread_call_internal_queue);
for (
call = internal_call_storage;
call < &internal_call_storage[internal_call_count];
call++) {
enqueue_tail(&thread_call_internal_queue, qe(call));
}
thread_call_daemon_awake = TRUE;
thread_call_unlock();
splx(s);
result = kernel_thread_start_priority((thread_continue_t)thread_call_daemon, group, BASEPRI_PREEMPT + 1, &thread);
if (result != KERN_SUCCESS)
panic("thread_call_initialize");
thread_deallocate(thread);
}
/*
* thread_call_initialize:
*
* Initialize this module, called
* early during system initialization.
*/
void
thread_call_initialize(void)
{
thread_call_t call;
kern_return_t result;
thread_t thread;
int i;
i = sizeof (thread_call_data_t);
thread_call_zone = zinit(i, 4096 * i, 16 * i, "thread_call");
zone_change(thread_call_zone, Z_CALLERACCT, FALSE);
zone_change(thread_call_zone, Z_NOENCRYPT, TRUE);
lck_attr_setdefault(&thread_call_lck_attr);
lck_grp_attr_setdefault(&thread_call_lck_grp_attr);
lck_grp_init(&thread_call_queues_lck_grp, "thread_call_queues", &thread_call_lck_grp_attr);
lck_grp_init(&thread_call_lck_grp, "thread_call", &thread_call_lck_grp_attr);
#if defined(__i386__) || defined(__x86_64__)
lck_mtx_init(&thread_call_lock_data, &thread_call_lck_grp, &thread_call_lck_attr);
#else
lck_spin_init(&thread_call_lock_data, &thread_call_lck_grp, &thread_call_lck_attr);
#endif
nanotime_to_absolutetime(0, THREAD_CALL_DEALLOC_INTERVAL_NS, &thread_call_dealloc_interval_abs);
wait_queue_init(&daemon_wqueue, SYNC_POLICY_FIFO);
thread_call_group_setup(&thread_call_groups[THREAD_CALL_PRIORITY_LOW], THREAD_CALL_PRIORITY_LOW, 0, TRUE);
thread_call_group_setup(&thread_call_groups[THREAD_CALL_PRIORITY_USER], THREAD_CALL_PRIORITY_USER, 0, TRUE);
thread_call_group_setup(&thread_call_groups[THREAD_CALL_PRIORITY_KERNEL], THREAD_CALL_PRIORITY_KERNEL, 1, TRUE);
thread_call_group_setup(&thread_call_groups[THREAD_CALL_PRIORITY_HIGH], THREAD_CALL_PRIORITY_HIGH, THREAD_CALL_THREAD_MIN, FALSE);
disable_ints_and_lock();
queue_init(&thread_call_internal_queue);
for (
call = internal_call_storage;
call < &internal_call_storage[INTERNAL_CALL_COUNT];
call++) {
enqueue_tail(&thread_call_internal_queue, qe(call));
}
thread_call_daemon_awake = TRUE;
enable_ints_and_unlock();
result = kernel_thread_start_priority((thread_continue_t)thread_call_daemon, NULL, BASEPRI_PREEMPT + 1, &thread);
if (result != KERN_SUCCESS)
panic("thread_call_initialize");
thread_deallocate(thread);
}
/*
* Remove timer entry from its queue but don't change the queue pointer
* and set the async_dequeue flag. This is locking case 2b.
*/
static __inline__ void
timer_call_entry_dequeue_async(
timer_call_t entry)
{
mpqueue_head_t *old_queue = MPQUEUE(CE(entry)->queue);
if (old_queue) {
old_queue->count--;
(void) remque(qe(entry));
entry->async_dequeue = TRUE;
}
return;
}
/*
* thread_call_func:
*
* Enqueue a function callout.
*
* Guarantees { function, argument }
* uniqueness if unique_call is TRUE.
*/
void
thread_call_func(
thread_call_func_t func,
thread_call_param_t param,
boolean_t unique_call)
{
thread_call_t call;
thread_call_group_t group = &thread_call_group0;
spl_t s;
s = splsched();
thread_call_lock_spin();
call = TC(queue_first(&group->pending_queue));
while (unique_call && !queue_end(&group->pending_queue, qe(call))) {
if ( call->func == func &&
call->param0 == param ) {
break;
}
call = TC(queue_next(qe(call)));
}
if (!unique_call || queue_end(&group->pending_queue, qe(call))) {
call = _internal_call_allocate();
call->func = func;
call->param0 = param;
call->param1 = NULL;
_pending_call_enqueue(call, group);
if (group->active_count == 0)
thread_call_wake(group);
}
thread_call_unlock();
splx(s);
}
int main()
{
Eigen::VectorXd qs(2); //Start goal coordinates (x,y)
Eigen::VectorXd qe(2); //End goal coordinates (x,y)
Eigen::VectorXd xi; //Trajectory points (x0,y0,x1,y1,....)
Eigen::MatrixXd obs; //obstacles |x0,y0,R0|
// |x1,y1,R1|
// | .......|
qs<<0,0;
qe<<3,5;
chomp::generatePath(qs,qe,xi,obs);
std::cout<<xi<<std::endl;
}
void QueryList::editQuery(QListWidgetItem* lbitem)
{
if(lbitem)
{
// run the editor dialog
QuerySource * qs = qsList->get(lbitem->text());
if(qs == 0)
{
//qDebug("QueryList::editQuery(): Could not find '%s' in querylist\n",lbitem->text().latin1());
return;
}
QueryEditor qe(this);
qe.tbName->setText(qs->name());
qe._metasql->setChecked(qs->loadFromDb());
qe.tbQuery->setEnabled(!qs->loadFromDb());
qe._mqlGroup->insertItem(0, qs->metaSqlGroup());
qe._mqlGroup->setCurrentIndex(0);
qe._mqlName->insertItem(0, qs->metaSqlName());
qe._mqlName->setCurrentIndex(0);
if(!qs->loadFromDb())
qe.tbQuery->setText(qs->query());
if(qe.exec() == QDialog::Accepted)
{
QString nname = qe.tbName->text();
QString nquery = qe.tbQuery->toPlainText();
bool mlfdb = qe._metasql->isChecked();
QString mgroup = qe._mqlGroup->currentText();
QString mname = qe._mqlName->currentText();
if(qs->name() != nname)
{
// we changed the name of the query.
// lets check to make sure we didn't change it to
// something that already exists
if(qsList->get(nname) != 0)
{
QMessageBox::warning(this, tr("Duplicate Name"), tr("The name you specified already exists in the list of query names."));
return;
}
lbitem->setText(nname);
}
qs->setName(nname);
qs->setQuery(nquery);
qs->setLoadFromDb(mlfdb);
qs->setMetaSqlGroup(mgroup);
qs->setMetaSqlName(mname);
}
}
}
static __inline__
void
_delayed_call_enqueue(
queue_t queue,
timer_call_t call)
{
timer_call_t current;
current = TC(queue_first(queue));
while (TRUE) {
if ( queue_end(queue, qe(current)) ||
call->deadline < current->deadline ) {
current = TC(queue_prev(qe(current)));
break;
}
current = TC(queue_next(qe(current)));
}
insque(qe(call), qe(current));
call->state = DELAYED;
}
void
thread_call_delayed_timer(
timer_call_param_t p0,
__unused timer_call_param_t p1
)
{
thread_call_t call;
thread_call_group_t group = p0;
boolean_t new_pending = FALSE;
uint64_t timestamp;
thread_call_lock_spin();
timestamp = mach_absolute_time();
call = TC(queue_first(&group->delayed_queue));
while (!queue_end(&group->delayed_queue, qe(call))) {
if (call->deadline <= timestamp) {
_pending_call_enqueue(call, group);
new_pending = TRUE;
}
else
break;
call = TC(queue_first(&group->delayed_queue));
}
if (!queue_end(&group->delayed_queue, qe(call)))
_set_delayed_call_timer(call, group);
if (new_pending && group->active_count == 0)
thread_call_wake(group);
thread_call_unlock();
}
static void test_qe(ast_manager& m, lbool expected_outcome, expr* fml, char const* option) {
// enable_trace("bit2int");
//enable_trace("gomory_cut");
enable_trace("final_check_arith");
enable_trace("arith_final_check");
//enable_trace("arith_branching");
enable_trace("theory_arith_int");
enable_trace("presburger");
enable_trace("quant_elim");
// enable_trace("arith_simplifier_plugin");
// enable_trace("non_linear");
// enable_trace("gomory_cut_detail");
// enable_trace("arith");
// enable_trace("bv");
// enable_trace("after_search");
// enable_trace("bv_bit_prop");
simplifier simp(m);
front_end_params params;
params.m_quant_elim = true;
std::cout << mk_pp(fml, m) << "\n";
qe::expr_quant_elim qe(m, params);
expr_ref result(m);
qe(m.mk_true(), fml, result);
std::cout << " -> " << mk_pp(result, m) << " " << expected_outcome << "\n";
if (expected_outcome == l_true && !m.is_true(result)) {
std::cout << "ERROR: expected true, instead got " << ast_pp(result, m).c_str() << "\n";
//exit(-1);
}
if (expected_outcome == l_false && !m.is_false(result)) {
std::cout << "ERROR: expected false, instead got " << ast_pp(result, m).c_str() << "\n";
//exit(-1);
}
}
Z3_ast Z3_API Z3_qe_lite (Z3_context c, Z3_ast_vector vars, Z3_ast body)
{
Z3_TRY;
LOG_Z3_qe_lite (c, vars, body);
RESET_ERROR_CODE();
ast_ref_vector &vVars = to_ast_vector_ref (vars);
app_ref_vector vApps (mk_c(c)->m());
for (unsigned i = 0; i < vVars.size (); ++i) {
app *a = to_app (vVars.get (i));
if (a->get_kind () != AST_APP) {
SET_ERROR_CODE (Z3_INVALID_ARG);
RETURN_Z3(0);
}
vApps.push_back (a);
}
expr_ref result (mk_c(c)->m ());
result = to_expr (body);
params_ref p;
qe_lite qe (mk_c(c)->m (), p);
qe (vApps, result);
// -- copy back variables that were not eliminated
if (vApps.size () < vVars.size ()) {
vVars.reset ();
for (app* v : vApps) {
vVars.push_back (v);
}
}
mk_c(c)->save_ast_trail (result.get ());
return of_expr (result);
Z3_CATCH_RETURN(0);
}
void
timer_queue_shutdown(
mpqueue_head_t *queue)
{
timer_call_t call;
mpqueue_head_t *new_queue;
spl_t s;
DBG("timer_queue_shutdown(%p)\n", queue);
s = splclock();
/* Note comma operator in while expression re-locking each iteration */
while (timer_call_lock_spin(queue), !queue_empty(&queue->head)) {
call = TIMER_CALL(queue_first(&queue->head));
if (!simple_lock_try(&call->lock)) {
/*
* case (2b) lock order inversion, dequeue and skip
* Don't change the call_entry queue back-pointer
* but set the async_dequeue field.
*/
timer_queue_shutdown_lock_skips++;
(void) remque(qe(call));
call->async_dequeue = TRUE;
timer_call_unlock(queue);
continue;
}
/* remove entry from old queue */
timer_call_entry_dequeue(call);
timer_call_unlock(queue);
/* and queue it on new */
new_queue = timer_queue_assign(CE(call)->deadline);
timer_call_lock_spin(new_queue);
timer_call_entry_enqueue_deadline(
call, new_queue, CE(call)->deadline);
timer_call_unlock(new_queue);
simple_unlock(&call->lock);
}
timer_call_unlock(queue);
splx(s);
}
static void test_quant_solver(ast_manager& m, unsigned sz, app*const* xs, expr* fml, bool validate) {
front_end_params params;
qe::expr_quant_elim qe(m, params);
qe::guarded_defs defs(m);
bool success = qe.solve_for_vars(sz, xs, fml, defs);
std::cout << "------------------------\n";
std::cout << mk_pp(fml, m) << "\n";
if (success) {
defs.display(std::cout);
for (unsigned i = 0; validate && i < defs.size(); ++i) {
validate_quant_solution(m, fml, defs.guard(i), defs.defs(i));
}
}
else {
std::cout << "failed\n";
}
}
void mk_quantifier_instantiation::instantiate_quantifier(quantifier* q, expr_ref_vector & conjs) {
expr_ref qe(m);
qe = q;
m_var2cnst(qe);
q = to_quantifier(qe);
if (q->get_num_patterns() == 0) {
proof_ref new_pr(m);
pattern_inference_params params;
pattern_inference infer(m, params);
infer(q, qe, new_pr);
q = to_quantifier(qe);
}
unsigned num_patterns = q->get_num_patterns();
for (unsigned i = 0; i < num_patterns; ++i) {
expr * pat = q->get_pattern(i);
SASSERT(m.is_pattern(pat));
instantiate_quantifier(q, to_app(pat), conjs);
}
}
void main()
{
cout<<"Test class"<<endl;
QueueWithPriority queue;
QueueElement qe("element1", LOW);
queue.putElement(qe);
queue.putElement(QueueElement("element2", NORMAL));
queue.putElement("element3", NORMAL);
queue.putElement("element4", HIGH);
queue.putElement("element5", HIGH);
queue.putElement("element6", NORMAL);
queue.putElement("element7", HIGH);
queue.putElement("element8", LOW);
queue.print_queue();
cout<<endl<<"First element:"<<endl<<queue.getElement()<<endl;
getch();
}
/*
* Assumes call_entry and queues unlocked, interrupts disabled.
*/
__inline__ mpqueue_head_t *
timer_call_enqueue_deadline_unlocked(
timer_call_t call,
mpqueue_head_t *queue,
uint64_t deadline)
{
call_entry_t entry = CE(call);
mpqueue_head_t *old_queue;
DBG("timer_call_enqueue_deadline_unlocked(%p,%p,)\n", call, queue);
simple_lock(&call->lock);
old_queue = MPQUEUE(entry->queue);
if (old_queue != NULL) {
timer_call_lock_spin(old_queue);
if (call->async_dequeue) {
/* collision (1c): null queue pointer and reset flag */
call->async_dequeue = FALSE;
entry->queue = NULL;
#if TIMER_ASSERT
timer_call_enqueue_deadline_unlocked_async1++;
#endif
} else if (old_queue != queue) {
(void)remque(qe(entry));
entry->queue = NULL;
#if TIMER_ASSERT
timer_call_enqueue_deadline_unlocked_async2++;
#endif
}
if (old_queue != queue) {
timer_call_unlock(old_queue);
timer_call_lock_spin(queue);
}
} else {
timer_call_lock_spin(queue);
}
timer_call_entry_enqueue_deadline(call, queue, deadline);
timer_call_unlock(queue);
simple_unlock(&call->lock);
return (old_queue);
}
MatchObject::MatchObject(QueryExpr* query, bool has_reductions, uint32_t langid) :
_query(NULL),
_qt(),
_nonterms(),
_match_overlap(false),
_max_arity(0),
_has_reductions(has_reductions),
_qt_byname(),
_reduce_matchers()
{
LOG(debug, "MatchObject(language %d)", langid);
query_expander qe(*this, langid);
query->Accept(qe); // Create a new, modified query
_query = qe.NewQuery(); // Fetch the new query..
if (LOG_WOULD_LOG(debug)) {
std::string s;
_query->Dump(s);
LOG(debug, "juniper::MatchObject(language id %d): modified stack: %s",
langid, s.c_str());
}
_max_arity = _query->MaxArity();
}
void QueryList::btnAdd_clicked()
{
// add a new querySource item
QueryEditor qe(this);
if(qe.exec() == QDialog::Accepted)
{
QString nname = qe.tbName->text();
QString nquery = qe.tbQuery->toPlainText();
bool nmql = qe._metasql->isChecked();
QString mgroup = qe._mqlGroup->currentText();
QString mname = qe._mqlName->currentText();
QuerySource * qs = new QuerySource(nname, nquery, nmql, mgroup, mname);
if(qsList->add(qs) == TRUE)
{
lbQuerys->addItem(nname);
}
else
{
// The item was not inserted for some reason
qDebug("Failed to insert into into QuerySourceList");
delete qs;
}
}
}
/*
* thread_call_enter_delayed:
*
* Enqueue a callout entry to occur
* at the stated time.
*
* Returns TRUE if the call was
* already on a queue.
*/
boolean_t
thread_call_enter_delayed(
thread_call_t call,
uint64_t deadline)
{
boolean_t result = TRUE;
thread_call_group_t group = &thread_call_group0;
spl_t s;
s = splsched();
thread_call_lock_spin();
result = _delayed_call_enqueue(call, group, deadline);
if (queue_first(&group->delayed_queue) == qe(call))
_set_delayed_call_timer(call, group);
call->param1 = 0;
thread_call_unlock();
splx(s);
return (result);
}
