unsigned list_cases_on(vm_obj const & o, buffer<vm_obj> & data) {
if (is_simple(o)) {
return 0;
} else if (is_constructor(o)) {
data.append(csize(o), cfields(o));
return 1;
} else {
lean_assert(is_external(o));
if (auto l = dynamic_cast<vm_list<name>*>(to_external(o))) {
return list_cases_on_core(l->m_val, data);
} else if (auto l = dynamic_cast<vm_list<expr>*>(to_external(o))) {
return list_cases_on_core(l->m_val, data);
} else if (auto l = dynamic_cast<vm_list<level>*>(to_external(o))) {
return list_cases_on_core(l->m_val, data);
} else {
lean_unreachable();
}
}
}
int test_main( int argc, char * /*argv*/[] )
{
if ( argc > 1 ) cleanup = false;
// So that tests are run with known encoding, use Boost UTF-8 codecvt
std::locale global_loc = std::locale();
std::locale loc( global_loc, new fs::detail::utf8_codecvt_facet );
fs::wpath_traits::imbue( loc );
std::string s( to_external( L"\x2780" ) );
for (std::size_t i = 0; i < s.size(); ++i )
std::cout << std::hex << int( static_cast<unsigned char>(s[i]) ) << " ";
std::cout << std::dec << std::endl;
BOOST_CHECK( to_external( L"\x2780" ).size() == 3 );
BOOST_CHECK( to_external( L"\x2780" ) == "\xE2\x9E\x80" );
// test fs::path
std::cout << "begin path test..." << std::endl;
test( fs::path( "foo" ), fs::path( "bar" ), fs::path( "." ) );
std::cout << "complete\n\n";
// test fs::wpath
// x2780 is circled 1 against white background == e2 9e 80 in UTF-8
// x2781 is circled 2 against white background == e2 9e 81 in UTF-8
std::cout << "begin wpath test..." << std::endl;
test( fs::wpath( L"\x2780" ), fs::wpath( L"\x2781" ), fs::wpath( L"." ) );
std::cout << "complete\n\n";
// test user supplied basic_path
const long dir[] = { 'b', 'o', 'o', 0 };
const long file[] = { 'f', 'a', 'r', 0 };
const long dot[] = { '.', 0 };
std::cout << "begin lpath test..." << std::endl;
test( ::user::lpath( dir ), ::user::lpath( file ), ::user::lpath( dot ) );
std::cout << "complete\n\n";
return 0;
}
struct rmDsummary *rmsummary_to_rmDsummary(struct rmsummary *so) {
struct rmDsummary *s = malloc(sizeof(struct rmDsummary));
bzero(s, sizeof(*s));
if(so->command) {
s->command = xxstrdup(so->command);
}
if(so->category)
{
s->category = xxstrdup(so->category);
}
else if(so->command)
{
s->category = parse_executable_name(so->command);
}
else
{
s->category = xxstrdup(DEFAULT_CATEGORY);
s->command = xxstrdup(DEFAULT_CATEGORY);
}
if(so->task_id)
{
s->task_id = xxstrdup(so->task_id);
}
to_external(s, so, start);
to_external(s, so, end);
to_external(s, so, wall_time);
to_external(s, so, cpu_time);
to_external(s, so, cores);
to_external(s, so, total_processes);
to_external(s, so, max_concurrent_processes);
to_external(s, so, memory);
to_external(s, so, virtual_memory);
to_external(s, so, swap_memory);
to_external(s, so, bytes_read);
to_external(s, so, bytes_written);
to_external(s, so, bytes_received);
to_external(s, so, bytes_sent);
to_external(s, so, bandwidth);
to_external(s, so, disk);
to_external(s, so, total_files);
struct field *f;
for(f = &fields[WALL_TIME]; f->name != NULL; f++)
{
if(value_of_field(s, f) < 0)
{
assign_to_field(s, f, 0);
}
}
return s;
}
vm_obj_map const & to_map(vm_obj const & o) {
lean_assert(is_external(o));
lean_assert(dynamic_cast<vm_rb_map*>(to_external(o)));
return static_cast<vm_rb_map*>(to_external(o))->m_map;
}
parray<vm_obj> const & to_array(vm_obj const & o) {
lean_vm_check(dynamic_cast<vm_array*>(to_external(o)));
return static_cast<vm_array*>(to_external(o))->m_array;
}
throwable * to_throwable(vm_obj const & o) {
lean_vm_check(dynamic_cast<vm_throwable*>(to_external(o)));
return static_cast<vm_throwable*>(to_external(o))->m_val;
}
level const & to_level(vm_obj const & o) {
lean_assert(is_external(o));
lean_assert(dynamic_cast<vm_level*>(to_external(o)));
return static_cast<vm_level*>(to_external(o))->m_val;
}
format const & to_format(vm_obj const & o) {
lean_vm_check(dynamic_cast<vm_format*>(to_external(o)));
return static_cast<vm_format*>(to_external(o))->m_val;
}
bool is_format(vm_obj const & o) {
return is_external(o) && dynamic_cast<vm_format*>(to_external(o));
}
std::function<format()> const & to_format_thunk(vm_obj const & o) {
lean_vm_check(dynamic_cast<vm_format_thunk*>(to_external(o)));
return static_cast<vm_format_thunk*>(to_external(o))->m_val;
}
bool is_options(vm_obj const & o) {
return is_external(o) && dynamic_cast<vm_options*>(to_external(o));
}
options const & to_options(vm_obj const & o) {
lean_assert(is_external(o));
lean_assert(dynamic_cast<vm_options*>(to_external(o)));
return static_cast<vm_options*>(to_external(o))->m_val;
}
