GpgME::KeyListResult Kleo::QGpgMEKeyListJob::attemptSyncKeyListing( std::vector<GpgME::Key> & keys ) {
GpgME::KeyListResult result;
for ( const char* * chunk = patterns() ; chunk ; chunk = nextChunk() ) {
if ( const GpgME::Error err = mCtx->startKeyListing( chunk, mSecretOnly ) )
return GpgME::KeyListResult( 0, err );
GpgME::Error err;
do
keys.push_back( mCtx->nextKey( err ) );
while ( !err );
keys.pop_back();
result.mergeWith( mCtx->endKeyListing() );
if ( result.error() )
break;
}
return result;
}
int main(int, char* [])
{
std::ifstream patterns("patterns.tsv");
int count_cases = 0;
int count_failures = 0;
std::string s;
while(std::getline(patterns, s).good())
{
++count_cases;
Pattern pattern(s);
std::string actual = solve(pattern.input);
if(actual != pattern.expected)
{
++count_failures;
std::cout << "Failure in " << pattern.name << "\n"
<< "expected: \"" << pattern.expected << "\"\n"
<< " actual: \"" << actual << "\"\n";
}
}
std::cout << "\nCases: " << count_cases << " Failures: " << count_failures << "\n";
return 0;
}
NetworkStateNotifier::NetworkStateNotifier()
: m_isOnLine(false)
, m_networkStateChangedFunction(0)
, m_networkStateChangeTimer(this, &NetworkStateNotifier::networkStateChangeTimerFired)
{
SCDynamicStoreContext context = { 0, this, 0, 0, 0 };
m_store.adoptCF(SCDynamicStoreCreate(0, CFSTR("com.apple.WebCore"), dynamicStoreCallback, &context));
if (!m_store)
return;
RetainPtr<CFRunLoopSourceRef> configSource = SCDynamicStoreCreateRunLoopSource(0, m_store.get(), 0);
if (!configSource)
return;
CFRunLoopAddSource(CFRunLoopGetMain(), configSource.get(), kCFRunLoopCommonModes);
RetainPtr<CFMutableArrayRef> keys(AdoptCF, CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));
RetainPtr<CFMutableArrayRef> patterns(AdoptCF, CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));
RetainPtr<CFStringRef> key;
RetainPtr<CFStringRef> pattern;
key.adoptCF(SCDynamicStoreKeyCreateNetworkGlobalEntity(0, kSCDynamicStoreDomainState, kSCEntNetIPv4));
CFArrayAppendValue(keys.get(), key.get());
pattern.adoptCF(SCDynamicStoreKeyCreateNetworkInterfaceEntity(0, kSCDynamicStoreDomainState, kSCCompAnyRegex, kSCEntNetIPv4));
CFArrayAppendValue(patterns.get(), pattern.get());
key.adoptCF(SCDynamicStoreKeyCreateNetworkGlobalEntity(0, kSCDynamicStoreDomainState, kSCEntNetDNS));
CFArrayAppendValue(keys.get(), key.get());
SCDynamicStoreSetNotificationKeys(m_store.get(), keys.get(), patterns.get());
updateState();
}
void Kleo::QGpgMEKeyListJob::setup( const QStringList & pats, bool secretOnly ) {
assert( !patterns() );
mSecretOnly = secretOnly;
setPatterns( pats );
}
void expr_abstractor::operator()(unsigned base, unsigned num_bound, expr* const* bound, expr* n, expr_ref& result) {
expr * curr = 0, *b = 0;
SASSERT(n->get_ref_count() > 0);
m_stack.push_back(n);
for (unsigned i = 0; i < num_bound; ++i) {
b = bound[i];
expr* v = m.mk_var(base + num_bound - i - 1, m.get_sort(b));
m_pinned.push_back(v);
m_map.insert(b, v);
}
while(!m_stack.empty()) {
curr = m_stack.back();
if (m_map.contains(curr)) {
m_stack.pop_back();
continue;
}
switch(curr->get_kind()) {
case AST_VAR: {
m_map.insert(curr, curr);
m_stack.pop_back();
break;
}
case AST_APP: {
app* a = to_app(curr);
bool all_visited = true;
m_args.reset();
for (unsigned i = 0; i < a->get_num_args(); ++i) {
if (!m_map.find(a->get_arg(i), b)) {
m_stack.push_back(a->get_arg(i));
all_visited = false;
}
else {
m_args.push_back(b);
}
}
if (all_visited) {
b = m.mk_app(a->get_decl(), m_args.size(), m_args.c_ptr());
m_pinned.push_back(b);
m_map.insert(curr, b);
m_stack.pop_back();
}
break;
}
case AST_QUANTIFIER: {
quantifier* q = to_quantifier(curr);
expr_ref_buffer patterns(m);
expr_ref result1(m);
unsigned new_base = base + q->get_num_decls();
for (unsigned i = 0; i < q->get_num_patterns(); ++i) {
expr_abstract(m, new_base, num_bound, bound, q->get_pattern(i), result1);
patterns.push_back(result1.get());
}
expr_abstract(m, new_base, num_bound, bound, q->get_expr(), result1);
b = m.update_quantifier(q, patterns.size(), patterns.c_ptr(), result1.get());
m_pinned.push_back(b);
m_map.insert(curr, b);
m_stack.pop_back();
break;
}
default:
UNREACHABLE();
}
}
VERIFY (m_map.find(n, b));
result = b;
m_pinned.reset();
m_map.reset();
m_stack.reset();
m_args.reset();
}
FunctionParameters::~FunctionParameters()
{
for (unsigned i = 0; i < m_size; ++i)
patterns()[i]->deref();
}
void multi_tile_pattern::init(variant node)
{
patterns().clear();
}
const std::deque<multi_tile_pattern>& multi_tile_pattern::get_all()
{
return patterns();
}
expr_ref bind_variables::abstract(expr* term, cache_t& cache, unsigned scope) {
unsigned sz = m_todo.size();
m_todo.push_back(term);
m_args.reset();
expr* b, *arg;
while (m_todo.size() > sz) {
expr* e = m_todo.back();
if (cache.contains(e)) {
m_todo.pop_back();
continue;
}
switch(e->get_kind()) {
case AST_VAR: {
SASSERT(to_var(e)->get_idx() < scope);
// mixing bound variables and free is possible for the caller,
// but not proper use.
// So we assert here even though we don't check for it.
cache.insert(e, e);
m_todo.pop_back();
break;
}
case AST_APP: {
app* a = to_app(e);
var2bound::obj_map_entry* w = m_var2bound.find_core(a);
if (w) {
var* v = w->get_data().m_value;
if (!v) {
// allocate a bound index.
v = m.mk_var(m_names.size(), m.get_sort(a));
m_names.push_back(a->get_decl()->get_name());
m_bound.push_back(m.get_sort(a));
w->get_data().m_value = v;
m_pinned.push_back(v);
}
if (scope == 0) {
cache.insert(e, v);
}
else {
var* v1 = m.mk_var(scope + v->get_idx(), m.get_sort(v));
m_pinned.push_back(v1);
cache.insert(e, v1);
}
m_todo.pop_back();
break;
}
bool all_visited = true;
bool some_diff = false;
m_args.reset();
for (unsigned i = 0; i < a->get_num_args(); ++i) {
arg = a->get_arg(i);
if (!cache.find(arg, b)) {
m_todo.push_back(arg);
all_visited = false;
}
else if (all_visited) {
m_args.push_back(b);
if (b != arg) {
some_diff = true;
}
}
}
if (all_visited) {
if (some_diff) {
b = m.mk_app(a->get_decl(), m_args.size(), m_args.c_ptr());
m_pinned.push_back(b);
}
else {
b = a;
}
cache.insert(e, b);
m_todo.pop_back();
}
break;
}
case AST_QUANTIFIER: {
quantifier* q = to_quantifier(e);
expr_ref_buffer patterns(m);
expr_ref result1(m);
unsigned new_scope = scope + q->get_num_decls();
cache_t new_cache;
for (unsigned i = 0; i < q->get_num_patterns(); ++i) {
patterns.push_back(abstract(q->get_pattern(i), new_cache, new_scope));
}
result1 = abstract(q->get_expr(), new_cache, new_scope);
b = m.update_quantifier(q, patterns.size(), patterns.c_ptr(), result1.get());
m_pinned.push_back(b);
cache.insert(e, b);
m_todo.pop_back();
break;
}
default:
UNREACHABLE();
}
}
return expr_ref(cache.find(term), m);
}
