void test_generic_assoc<ValueTraits, ContainerDefiner>::test_rebalance (value_cont_type& values, detail::true_type) { typedef typename ContainerDefiner::template container <>::type assoc_type; typedef value_cont_type orig_set_t; orig_set_t original_testset; { assoc_type testset (values.begin(), values.end()); original_testset.assign(testset.begin(), testset.end()); } { assoc_type testset(values.begin(), values.end()); testset.rebalance(); TEST_INTRUSIVE_SEQUENCE_EXPECTED(original_testset, testset.begin()); } { std::size_t numdata; { assoc_type testset(values.begin(), values.end()); numdata = testset.size(); } for(int i = 0; i != (int)numdata; ++i){ assoc_type testset(values.begin(), values.end()); typename assoc_type::iterator it = testset.begin(); for(int j = 0; j != i; ++j) ++it; testset.rebalance_subtree(it); TEST_INTRUSIVE_SEQUENCE_EXPECTED(original_testset, testset.begin()); } } }
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_down (value_cont_type& values, detail::true_type) { typedef typename ContainerDefiner::template container <>::type assoc_type; typedef typename assoc_type::iterator iterator; typedef value_cont_type orig_set_t; std::size_t num_values; orig_set_t original_testset; { assoc_type testset (values.begin(), values.end()); num_values = testset.size(); original_testset = value_cont_type(testset.begin(), testset.end()); } for(std::size_t i = 0; i != num_values; ++i){ assoc_type testset (values.begin(), values.end()); BOOST_TEST(testset.size() == num_values); { iterator it = testset.begin(); for(std::size_t j = 0; j != i; ++j, ++it){} BOOST_TEST(*it == *testset.splay_down(*it)); } BOOST_TEST (testset.size() == num_values); iterator it = testset.begin(); for( typename orig_set_t::const_iterator origit = original_testset.begin() , origitend = original_testset.end() ; origit != origitend ; ++origit, ++it){ BOOST_TEST(*origit == *it); } } }
void test_generic_set<ValueTraits, ContainerDefiner>::test_all() { typedef typename ValueTraits::value_type value_type; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; std::vector<value_type> values (6); for (int i = 0; i < 6; ++i) values[i].value_ = random_init[i]; typedef typename ContainerDefiner < value_type , value_traits<ValueTraits> , constant_time_size<value_type::constant_time_size> >::type set_type; { set_type testset(values.begin(), values.end()); test::test_container(testset); testset.clear(); testset.insert(values.begin(), values.end()); test::test_common_unordered_and_associative_container(testset, values); testset.clear(); testset.insert(values.begin(), values.end()); test::test_associative_container(testset, values); testset.clear(); testset.insert(values.begin(), values.end()); test::test_unique_container(testset, values); } test_sort(values); test_insert(values); test_insert_advanced(values); test_swap(values); test_find(values); test_impl(); test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values); }
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(std::vector<typename ValueTraits::value_type>& values) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner < value_type , value_traits<ValueTraits> , constant_time_size<value_type::constant_time_size> >::type set_type; set_type testset (values.begin(), values.end()); typedef typename set_type::iterator iterator; value_type cmp_val; cmp_val.value_ = 2; iterator i = testset.find (cmp_val); BOOST_TEST (i->value_ == 2); BOOST_TEST ((++i)->value_ != 2); std::pair<iterator,iterator> range = testset.equal_range (cmp_val); BOOST_TEST (range.first->value_ == 2); BOOST_TEST (range.second->value_ == 3); BOOST_TEST (std::distance (range.first, range.second) == 1); cmp_val.value_ = 7; BOOST_TEST (testset.find (cmp_val) == testset.end()); }
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_all () { typedef typename ValueTraits::value_type value_type; static const int random_init[6] = { 3, 2, 4, 1, 5, 2 }; value_cont_type values (6); for (int i = 0; i < 6; ++i) (&values[i])->value_ = random_init[i]; typedef ContainerDefiner < value_type , value_traits<ValueTraits> , constant_time_size<value_type::constant_time_size> > definer_function; typedef typename definer_function::type multiset_type; { multiset_type testset(values.begin(), values.end()); test::test_container(testset); testset.clear(); testset.insert(values.begin(), values.end()); test::test_common_unordered_and_associative_container(testset, values); testset.clear(); testset.insert(values.begin(), values.end()); test::test_associative_container(testset, values); testset.clear(); testset.insert(values.begin(), values.end()); test::test_non_unique_container(testset, values); } test_sort(values); test_insert(values); test_swap(values); test_find(values); test_impl(); test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values); }
void Tester::runXQTS() { XQTSTestSet testset(baseDir); sednaInstance.startSedna(); sedna::Database *dbInstance = sednaInstance.getDatabase(dbName); dbInstance->create(); dbInstance->start(); sedna::Session *session = dbInstance->createSession(); testset.initTestSet(session); ISednaTestCase *testIt = testset.nextCase(); while (testIt != 0) { testIt->execute(session); testIt = testset.nextCase(); } dbInstance->stop(); dbInstance->drop(); testset.generateReport(); sednaInstance.stopSedna(); }
void test_generic_assoc<ValueTraits, ContainerDefiner> ::test_container_from_end(value_cont_type& values, detail::true_type) { typedef typename ContainerDefiner::template container <>::type assoc_type; assoc_type testset (values.begin(), values.begin() + values.size()); BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end())); BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend())); }
void DocumentDecoder::runMaster(const std::string &infile) { NistXmlTestset testset(infile); boost::thread manager(manageTranslators, communicator_, testset); translate(); manager.join(); testset.outputTranslation(std::cout); }
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_insert_erase_burst() { //value_cont_type values; const std::size_t MaxValues = 200; value_cont_type values(MaxValues); for(std::size_t i = 0; i != MaxValues; ++i){ (&values[i])->value_ = i; } typedef typename ContainerDefiner::template container <>::type assoc_type; typedef typename assoc_type::iterator iterator; { //Ordered insertion + erasure assoc_type testset (values.begin(), values.begin() + values.size()); TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin()); testset.check(); iterator it(testset.begin()), itend(testset.end()); for(std::size_t i = 0; it != itend; ++i){ BOOST_TEST(&*it == &values[i]); it = testset.erase(it); testset.check(); } BOOST_TEST(testset.empty()); } { //Now random insertions + erasure assoc_type testset; typedef typename value_cont_type::iterator vec_iterator; boost::container::vector<vec_iterator> it_vector; //Random insertion for(vec_iterator it(values.begin()), itend(values.end()) ; it != itend ; ++it){ it_vector.push_back(it); } for(std::size_t i = 0; i != MaxValues; ++i){ testset.insert(*it_vector[i]); testset.check(); } TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin()); //Random erasure std::random_shuffle(it_vector.begin(), it_vector.end()); for(std::size_t i = 0; i != MaxValues; ++i){ testset.erase(testset.iterator_to(*it_vector[i])); testset.check(); } BOOST_TEST(testset.empty()); } }
void test_generic_assoc<ValueTraits, ContainerDefiner>:: test_container_from_iterator(value_cont_type& values, detail::true_type) { typedef typename ContainerDefiner::template container <>::type assoc_type; assoc_type testset(values.begin(), values.end()); typedef typename assoc_type::iterator it_type; typedef typename assoc_type::const_iterator cit_type; typedef typename assoc_type::size_type sz_type; sz_type sz = testset.size(); for(it_type b(testset.begin()), e(testset.end()); b != e; ++b) { assoc_type &s = assoc_type::container_from_iterator(b); const assoc_type &cs = assoc_type::container_from_iterator(cit_type(b)); BOOST_TEST(&s == &cs); BOOST_TEST(&s == &testset); s.erase(b); BOOST_TEST(testset.size() == (sz-1)); s.insert(*b); BOOST_TEST(testset.size() == sz); } }
static void testDynamicBitSet( int times, int maximum, int nofElements) { if (nofElements >= maximum) throw std::runtime_error("potential endless loop in test"); for (int ti=0; ti<times; ++ti) { strus::dynamic_bitset testset( maximum); std::set<int> eset; for (int ei=0; ei<nofElements; ++ei) { int elem = g_random.get( 0, maximum); eset.insert( elem); testset.set( elem, true); } std::set<int>::const_iterator si = eset.begin(), se = eset.end(); for (; si != se; ++si) { if (!testset.test( *si)) { std::cerr << "element " << *si << " inserted not found in dynamic bitset" << std::endl; if (++g_nof_errors >= g_max_nof_errors) throw std::runtime_error( "dynamic bitset test failed"); } } for (int ei=0; ei<nofElements; ++ei) { int elem = g_random.get( 0, maximum); if (eset.find( elem) != eset.end()) { --ei; continue; } if (testset.test( elem)) { std::cerr << "element " << elem << " not inserted but found in dynamic bitset" << std::endl; if (++g_nof_errors >= g_max_nof_errors) throw std::runtime_error( "dynamic bitset test failed"); } } } std::cerr << "executed testDynamicBitSet( " << times << ", " << maximum << ", " << nofElements << ")" << std::endl; }
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(std::vector<typename ValueTraits::value_type>& values) { typedef typename ValueTraits::value_type value_type; typedef typename ContainerDefiner < value_type , value_traits<ValueTraits> , constant_time_size<value_type::constant_time_size> >::type set_type; set_type testset (values.begin(), values.end()); typedef typename set_type::iterator iterator; { value_type cmp_val; cmp_val.value_ = 2; iterator i = testset.find (cmp_val); BOOST_TEST (i->value_ == 2); BOOST_TEST ((++i)->value_ != 2); std::pair<iterator,iterator> range = testset.equal_range (cmp_val); BOOST_TEST (range.first->value_ == 2); BOOST_TEST (range.second->value_ == 3); BOOST_TEST (std::distance (range.first, range.second) == 1); cmp_val.value_ = 7; BOOST_TEST (testset.find (cmp_val) == testset.end()); } { typename search_const_container<set_type>::type &const_testset = testset; std::pair<iterator,iterator> range; std::pair<typename search_const_iterator<set_type>::type ,typename search_const_iterator<set_type>::type> const_range; value_type cmp_val_lower, cmp_val_upper; { cmp_val_lower.value_ = 1; cmp_val_upper.value_ = 2; //left-closed, right-closed range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true); BOOST_TEST (range.first->value_ == 1); BOOST_TEST (range.second->value_ == 3); BOOST_TEST (std::distance (range.first, range.second) == 2); } { cmp_val_lower.value_ = 1; cmp_val_upper.value_ = 2; const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false); BOOST_TEST (const_range.first->value_ == 1); BOOST_TEST (const_range.second->value_ == 2); BOOST_TEST (std::distance (const_range.first, const_range.second) == 1); cmp_val_lower.value_ = 1; cmp_val_upper.value_ = 3; range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false); BOOST_TEST (range.first->value_ == 1); BOOST_TEST (range.second->value_ == 3); BOOST_TEST (std::distance (range.first, range.second) == 2); } { cmp_val_lower.value_ = 1; cmp_val_upper.value_ = 2; const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, false, true); BOOST_TEST (const_range.first->value_ == 2); BOOST_TEST (const_range.second->value_ == 3); BOOST_TEST (std::distance (const_range.first, const_range.second) == 1); } { cmp_val_lower.value_ = 1; cmp_val_upper.value_ = 2; range = testset.bounded_range (cmp_val_lower, cmp_val_upper, false, false); BOOST_TEST (range.first->value_ == 2); BOOST_TEST (range.second->value_ == 2); BOOST_TEST (std::distance (range.first, range.second) == 0); } { cmp_val_lower.value_ = 5; cmp_val_upper.value_ = 6; const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false); BOOST_TEST (const_range.first->value_ == 5); BOOST_TEST (const_range.second == const_testset.end()); BOOST_TEST (std::distance (const_range.first, const_range.second) == 1); } } }
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(value_cont_type& values) { typedef typename ValueTraits::value_type value_type; typedef ContainerDefiner < value_type , value_traits<ValueTraits> , constant_time_size<value_type::constant_time_size> > definer_function; typedef typename definer_function::type set_type; set_type testset (values.begin(), values.end()); typedef typename set_type::iterator iterator; { //value_type cmp_val; value_cont_type cmp_val_cont(1); reference cmp_val = cmp_val_cont.front(); (&cmp_val)->value_ = 2; iterator i = testset.find (cmp_val); BOOST_TEST (i->value_ == 2); BOOST_TEST ((++i)->value_ != 2); std::pair<iterator,iterator> range = testset.equal_range (cmp_val); BOOST_TEST (range.first->value_ == 2); BOOST_TEST (range.second->value_ == 3); BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 1); (&cmp_val)->value_ = 7; BOOST_TEST (testset.find (cmp_val) == testset.end()); } { typename search_const_container<set_type>::type &const_testset = testset; std::pair<iterator,iterator> range; std::pair<typename search_const_iterator<set_type>::type ,typename search_const_iterator<set_type>::type> const_range; //value_type cmp_val_lower, cmp_val_upper; value_cont_type cmp_val_cont(2); reference cmp_val_lower = cmp_val_cont.front(); reference cmp_val_upper = cmp_val_cont.back(); { (&cmp_val_lower)->value_ = 1; (&cmp_val_upper)->value_ = 2; //left-closed, right-closed range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true); BOOST_TEST (range.first->value_ == 1); BOOST_TEST (range.second->value_ == 3); BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 2); } { (&cmp_val_lower)->value_ = 1; (&cmp_val_upper)->value_ = 2; const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false); BOOST_TEST (const_range.first->value_ == 1); BOOST_TEST (const_range.second->value_ == 2); BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1); (&cmp_val_lower)->value_ = 1; (&cmp_val_upper)->value_ = 3; range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false); BOOST_TEST (range.first->value_ == 1); BOOST_TEST (range.second->value_ == 3); BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 2); } { (&cmp_val_lower)->value_ = 1; (&cmp_val_upper)->value_ = 2; const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, false, true); BOOST_TEST (const_range.first->value_ == 2); BOOST_TEST (const_range.second->value_ == 3); BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1); } { (&cmp_val_lower)->value_ = 1; (&cmp_val_upper)->value_ = 2; range = testset.bounded_range (cmp_val_lower, cmp_val_upper, false, false); BOOST_TEST (range.first->value_ == 2); BOOST_TEST (range.second->value_ == 2); BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 0); } { (&cmp_val_lower)->value_ = 5; (&cmp_val_upper)->value_ = 6; const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false); BOOST_TEST (const_range.first->value_ == 5); BOOST_TEST (const_range.second == const_testset.end()); BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1); } } }
/************************************************************************* Internal cross-validation subroutine *************************************************************************/ static void mlpkfoldcvgeneral(const multilayerperceptron& n, const ap::real_2d_array& xy, int npoints, double decay, int restarts, int foldscount, bool lmalgorithm, double wstep, int maxits, int& info, mlpreport& rep, mlpcvreport& cvrep) { int i; int fold; int j; int k; multilayerperceptron network; int nin; int nout; int rowlen; int wcount; int nclasses; int tssize; int cvssize; ap::real_2d_array cvset; ap::real_2d_array testset; ap::integer_1d_array folds; int relcnt; mlpreport internalrep; ap::real_1d_array x; ap::real_1d_array y; // // Read network geometry, test parameters // mlpproperties(n, nin, nout, wcount); if( mlpissoftmax(n) ) { nclasses = nout; rowlen = nin+1; } else { nclasses = -nout; rowlen = nin+nout; } if( npoints<=0||foldscount<2||foldscount>npoints ) { info = -1; return; } mlpcopy(n, network); // // K-fold out cross-validation. // First, estimate generalization error // testset.setbounds(0, npoints-1, 0, rowlen-1); cvset.setbounds(0, npoints-1, 0, rowlen-1); x.setbounds(0, nin-1); y.setbounds(0, nout-1); mlpkfoldsplit(xy, npoints, nclasses, foldscount, false, folds); cvrep.relclserror = 0; cvrep.avgce = 0; cvrep.rmserror = 0; cvrep.avgerror = 0; cvrep.avgrelerror = 0; rep.ngrad = 0; rep.nhess = 0; rep.ncholesky = 0; relcnt = 0; for(fold = 0; fold <= foldscount-1; fold++) { // // Separate set // tssize = 0; cvssize = 0; for(i = 0; i <= npoints-1; i++) { if( folds(i)==fold ) { ap::vmove(&testset(tssize, 0), &xy(i, 0), ap::vlen(0,rowlen-1)); tssize = tssize+1; } else { ap::vmove(&cvset(cvssize, 0), &xy(i, 0), ap::vlen(0,rowlen-1)); cvssize = cvssize+1; } } // // Train on CV training set // if( lmalgorithm ) { mlptrainlm(network, cvset, cvssize, decay, restarts, info, internalrep); } else { mlptrainlbfgs(network, cvset, cvssize, decay, restarts, wstep, maxits, info, internalrep); } if( info<0 ) { cvrep.relclserror = 0; cvrep.avgce = 0; cvrep.rmserror = 0; cvrep.avgerror = 0; cvrep.avgrelerror = 0; return; } rep.ngrad = rep.ngrad+internalrep.ngrad; rep.nhess = rep.nhess+internalrep.nhess; rep.ncholesky = rep.ncholesky+internalrep.ncholesky; // // Estimate error using CV test set // if( mlpissoftmax(network) ) { // // classification-only code // cvrep.relclserror = cvrep.relclserror+mlpclserror(network, testset, tssize); cvrep.avgce = cvrep.avgce+mlperrorn(network, testset, tssize); } for(i = 0; i <= tssize-1; i++) { ap::vmove(&x(0), &testset(i, 0), ap::vlen(0,nin-1)); mlpprocess(network, x, y); if( mlpissoftmax(network) ) { // // Classification-specific code // k = ap::round(testset(i,nin)); for(j = 0; j <= nout-1; j++) { if( j==k ) { cvrep.rmserror = cvrep.rmserror+ap::sqr(y(j)-1); cvrep.avgerror = cvrep.avgerror+fabs(y(j)-1); cvrep.avgrelerror = cvrep.avgrelerror+fabs(y(j)-1); relcnt = relcnt+1; } else { cvrep.rmserror = cvrep.rmserror+ap::sqr(y(j)); cvrep.avgerror = cvrep.avgerror+fabs(y(j)); } } } else { // // Regression-specific code // for(j = 0; j <= nout-1; j++) { cvrep.rmserror = cvrep.rmserror+ap::sqr(y(j)-testset(i,nin+j)); cvrep.avgerror = cvrep.avgerror+fabs(y(j)-testset(i,nin+j)); if( ap::fp_neq(testset(i,nin+j),0) ) { cvrep.avgrelerror = cvrep.avgrelerror+fabs((y(j)-testset(i,nin+j))/testset(i,nin+j)); relcnt = relcnt+1; } } } } } if( mlpissoftmax(network) ) { cvrep.relclserror = cvrep.relclserror/npoints; cvrep.avgce = cvrep.avgce/(log(double(2))*npoints); } cvrep.rmserror = sqrt(cvrep.rmserror/(npoints*nout)); cvrep.avgerror = cvrep.avgerror/(npoints*nout); cvrep.avgrelerror = cvrep.avgrelerror/relcnt; info = 1; }
bool in_struct(void *struct_ptr, struct_desc *sd , pb_stream *ins, pb_stream *obj_pbs) { err_t ugh = NULL; u_int8_t *cur = ins->cur; if (ins->roof - cur < (ptrdiff_t)sd->size) { ugh = builddiag("not enough room in input packet for %s", sd->name); } else { u_int8_t *roof = cur + sd->size; /* may be changed by a length field */ u_int8_t *outp = struct_ptr; bool immediate = FALSE; field_desc *fp; for (fp = sd->fields; ugh == NULL; fp++) { size_t i = fp->size; passert(ins->roof - cur >= (ptrdiff_t)i); passert(cur - ins->cur <= (ptrdiff_t)(sd->size - i)); passert(outp - (cur - ins->cur) == struct_ptr); #if 0 DBG(DBG_PARSING, DBG_log("%d %s" , (int) (cur - ins->cur), fp->name == NULL? "" : fp->name)); #endif switch (fp->field_type) { case ft_mbz: /* must be zero */ for (; i != 0; i--) { if (*cur++ != 0) { ugh = builddiag("byte %d of %s must be zero, but is not" , (int) (cur - ins->cur), sd->name); break; } *outp++ = '\0'; /* probably redundant */ } break; case ft_nat: /* natural number (may be 0) */ case ft_len: /* length of this struct and any following crud */ case ft_lv: /* length/value field of attribute */ case ft_enum: /* value from an enumeration */ case ft_loose_enum: /* value from an enumeration with only some names known */ case ft_af_enum: /* Attribute Format + value from an enumeration */ case ft_set: /* bits representing set */ { u_int32_t n = 0; for (; i != 0; i--) n = (n << BITS_PER_BYTE) | *cur++; switch (fp->field_type) { case ft_len: /* length of this struct and any following crud */ case ft_lv: /* length/value field of attribute */ { u_int32_t len = fp->field_type == ft_len? n : immediate? sd->size : n + sd->size; if (len < sd->size) { ugh = builddiag("%s of %s is smaller than minimum" , fp->name, sd->name); } else if (pbs_left(ins) < len) { ugh = builddiag("%s of %s is larger than can fit" , fp->name, sd->name); } else { roof = ins->cur + len; } break; } case ft_af_enum: /* Attribute Format + value from an enumeration */ if ((n & ISAKMP_ATTR_AF_MASK) == ISAKMP_ATTR_AF_TV) immediate = TRUE; /* FALL THROUGH */ case ft_enum: /* value from an enumeration */ if (enum_name(fp->desc, n) == NULL) { ugh = builddiag("%s of %s has an unknown value: %lu" , fp->name, sd->name, (unsigned long)n); } /* FALL THROUGH */ case ft_loose_enum: /* value from an enumeration with only some names known */ break; case ft_set: /* bits representing set */ if (!testset(fp->desc, n)) { ugh = builddiag("bitset %s of %s has unknown member(s): %s" , fp->name, sd->name, bitnamesof(fp->desc, n)); } break; default: break; } i = fp->size; switch (i) { case 8/BITS_PER_BYTE: *(u_int8_t *)outp = n; break; case 16/BITS_PER_BYTE: *(u_int16_t *)outp = n; break; case 32/BITS_PER_BYTE: *(u_int32_t *)outp = n; break; default: impossible(); } outp += i; break; } case ft_raw: /* bytes to be left in network-order */ for (; i != 0; i--) { *outp++ = *cur++; } break; case ft_end: /* end of field list */ passert(cur == ins->cur + sd->size); if (obj_pbs != NULL) { init_pbs(obj_pbs, ins->cur, roof - ins->cur, sd->name); obj_pbs->container = ins; obj_pbs->desc = sd; obj_pbs->cur = cur; } ins->cur = roof; DBG(DBG_PARSING , DBG_prefix_print_struct(ins, "parse ", struct_ptr, sd, TRUE)); return TRUE; default: impossible(); } } } /* some failure got us here: report it */ loglog(RC_LOG_SERIOUS, ugh); return FALSE; }
int main(){ testset(); return 0; }