Datasets:

AISE-TUDelft

/

Capybara

like 2

Follow

AISE research lab at TU Delft 43

[ "writes", "ints", "using", "the", "auto", "int()", "uint()", "functions" ]

[ "'static", "void", "test_write_simple_auto_int", "()", "{", "char", "buf", "[", "4096", "]", ";", "//", "positive", "fixnums", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7e\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0x7e", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "//", "positive", "fixnums", "with", "signed", "int", "functions", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_int", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_int", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7e\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0x7e", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "//", "negative", "fixnums", "TEST_SIMPLE_WRITE", "(", "\"\\\\xff\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xfe\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xf0\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "16", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xe1\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "31", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xe0\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "32", ")", ")", ";", "//", "uints", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\x80\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0x80", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\xff\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0xff", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\x01\\\\x00\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0x100", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\xff\\\\xff\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0xffff", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\x00\\\\x01\\\\x00\\\\x00\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0x10000", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "0xffffffff", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\x00\\\\x00\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "UINT64_C", "(", "0x100000000", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_uint", "(", "&", "writer", ",", "UINT64_C", "(", "0xffffffffffffffff", ")", ")", ")", ";", "//", "positive", "ints", "with", "signed", "value", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\x80\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0x80", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\xff\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0xff", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\x01\\\\x00\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0x100", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\xff\\\\xff\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0xffff", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\x00\\\\x01\\\\x00\\\\x00\"", ",", "mpack_write_int", "(", "&", "writer", ",", "0x10000", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_int", "(", "&", "writer", ",", "INT64_C", "(", "0xffffffff", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\x00\\\\x00\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_int", "(", "&", "writer", ",", "INT64_C", "(", "0x100000000", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\x7f\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_int", "(", "&", "writer", ",", "INT64_C", "(", "0x7fffffffffffffff", ")", ")", ")", ";", "//", "ints", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd0\\\\xdf\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "33", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd0\\\\x80\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "128", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd1\\\\xff\\\\x7f\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "129", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd1\\\\x80\\\\x00\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "32768", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd2\\\\xff\\\\xff\\\\x7f\\\\xff\"", ",", "mpack_write_int", "(", "&", "writer", ",", "-", "32769", ")", ")", ";", "//", "when", "using", "INT32_C()", "and", "compiling", "the", "test", "suite", "as", "c++,", "gcc", "complains:", "//", "error:", "this", "decimal", "constant", "is", "unsigned", "only", "in", "ISO", "C90", "[-Werror]", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd2\\\\x80\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_int", "(", "&", "writer", ",", "INT64_C", "(", "-", "2147483648", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd3\\\\xff\\\\xff\\\\xff\\\\xff\\\\x7f\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_int", "(", "&", "writer", ",", "INT64_C", "(", "-", "2147483649", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd3\\\\x80\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_int", "(", "&", "writer", ",", "INT64_MIN", ")", ")", ";", "}'" ]

[ "writes", "ints", "using", "the", "sized", "iXX()", "uXX()", "functions" ]

[ "'static", "void", "test_write_simple_size_int_fixnums", "()", "{", "char", "buf", "[", "4096", "]", ";", "//", "positive", "fixnums", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_u8", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_u8", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_u8", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_u8", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_u8", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_u8", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_u16", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_u16", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_u16", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_u16", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_u16", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_u16", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_u32", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_u32", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_u32", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_u32", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_u32", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_u32", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_u64", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_u64", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_u64", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_u64", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_u64", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_u64", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "//", "positive", "fixnums", "with", "signed", "int", "functions", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "0", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "0x0f", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "0x10", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "0x7f", ")", ")", ";", "//", "negative", "fixnums", "TEST_SIMPLE_WRITE", "(", "\"\\\\xff\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "-", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xfe\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "-", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xf0\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "-", "16", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xe0\"", ",", "mpack_write_i8", "(", "&", "writer", ",", "-", "32", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xff\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "-", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xfe\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "-", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xf0\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "-", "16", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xe0\"", ",", "mpack_write_i16", "(", "&", "writer", ",", "-", "32", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xff\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "-", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xfe\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "-", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xf0\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "-", "16", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xe0\"", ",", "mpack_write_i32", "(", "&", "writer", ",", "-", "32", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xff\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "-", "1", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xfe\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "-", "2", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xf0\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "-", "16", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xe0\"", ",", "mpack_write_i64", "(", "&", "writer", ",", "-", "32", ")", ")", ";", "}'" ]

[ "writes", "ints", "using", "the", "dynamic", "tag", "writer", "function" ]

[ "'static", "void", "test_write_simple_tag_int", "()", "{", "char", "buf", "[", "4096", "]", ";", "//", "positive", "fixnums", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "1", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "2", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0x0f", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0x10", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0x7f", ")", ")", ")", ";", "//", "positive", "fixnums", "with", "signed", "value", "TEST_SIMPLE_WRITE", "(", "\"\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x01\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "1", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x02\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "2", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x0f\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0x0f", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x10\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0x10", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\x7f\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0x7f", ")", ")", ")", ";", "//", "negative", "fixnums", "TEST_SIMPLE_WRITE", "(", "\"\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "1", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xfe\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "2", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xf0\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "16", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xe0\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "32", ")", ")", ")", ";", "//", "uints", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\x80\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0x80", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0xff", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\x01\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0x100", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\xff\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0xffff", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\x00\\\\x01\\\\x00\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0x10000", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "0xffffffff", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\x00\\\\x00\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "UINT64_C", "(", "0x100000000", ")", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_uint", "(", "UINT64_C", "(", "0xffffffffffffffff", ")", ")", ")", ")", ";", "//", "positive", "ints", "with", "signed", "value", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\x80\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0x80", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcc\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0xff", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\x01\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0x100", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcd\\\\xff\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0xffff", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\x00\\\\x01\\\\x00\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "0x10000", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xce\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "INT64_C", "(", "0xffffffff", ")", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\x00\\\\x00\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "INT64_C", "(", "0x100000000", ")", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xcf\\\\x7f\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "INT64_C", "(", "0x7fffffffffffffff", ")", ")", ")", ")", ";", "//", "ints", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd0\\\\xdf\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "33", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd0\\\\x80\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "128", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd1\\\\xff\\\\x7f\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "129", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd1\\\\x80\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "32768", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd2\\\\xff\\\\xff\\\\x7f\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "-", "32769", ")", ")", ")", ";", "//", "when", "using", "INT32_C()", "and", "compiling", "the", "test", "suite", "as", "c++,", "gcc", "complains:", "//", "error:", "this", "decimal", "constant", "is", "unsigned", "only", "in", "ISO", "C90", "[-Werror]", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd2\\\\x80\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "INT64_C", "(", "-", "2147483648", ")", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd3\\\\xff\\\\xff\\\\xff\\\\xff\\\\x7f\\\\xff\\\\xff\\\\xff\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "INT64_C", "(", "-", "2147483649", ")", ")", ")", ")", ";", "TEST_SIMPLE_WRITE", "(", "\"\\\\xd3\\\\x80\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\"", ",", "mpack_write_tag", "(", "&", "writer", ",", "mpack_tag_int", "(", "INT64_MIN", ")", ")", ")", ";", "}'" ]

[ "THIS", "SHOULD", "BE", "_SSE2", "in", "the", "future" ]

[ "'void", "eb_vp9_avc_style_copy_sse2", "(", "EbByte", "ref_pic", ",", "uint32_t", "src_stride", ",", "EbByte", "dst", ",", "uint32_t", "dst_stride", ",", "uint32_t", "pu_width", ",", "uint32_t", "pu_height", ",", "EbByte", "temp_buf", ",", "uint32_t", "frac_pos", ")", "{", "(", "void", ")", "temp_buf", ";", "(", "void", ")", "frac_pos", ";", "eb_vp9_picture_copy_kernel_sse2", "(", "ref_pic", ",", "src_stride", ",", "dst", ",", "dst_stride", ",", "pu_width", ",", "pu_height", ")", ";", "}'" ]

[ "'sharpen()'", "Sharpen", "an", "image", "using", "a", "convolution", "filter" ]

[ "'void", "sharpen", "(", "int", "width", ",", "int", "height", ",", "unsigned", "char", "*", "src_region", ",", "unsigned", "char", "*", "dest_region", ",", "int", "sharpen_percent", ")", "{", "unsigned", "char", "*", "src_rows", "[", "4", "]", ",", "/*", "Source", "pixel", "rows", "*/", "<type", "ref=\"prev\">", "*", "src_ptr", ",", "/*", "Current", "source", "pixel", "*/", "<type", "ref=\"prev\">", "*", "dst_row", ";", "/*", "Destination", "pixel", "row", "*/", "long", "int", "*", "neg_rows", "[", "4", "]", ",", "/*", "Negative", "coefficient", "rows", "*/", "<type", "ref=\"prev\">", "*", "neg_ptr", ";", "/*", "Current", "negative", "coefficient", "*/", "int", "i", ",", "/*", "Looping", "vars", "*/", "<type", "ref=\"prev\"/>", "y", ",", "/*", "Current", "location", "in", "image", "*/", "<type", "ref=\"prev\"/>", "row", ",", "/*", "Current", "row", "in", "src_rows", "*/", "<type", "ref=\"prev\"/>", "count", ",", "/*", "Current", "number", "of", "filled", "src_rows", "*/", "<type", "ref=\"prev\"/>", "pitch", ";", "/*", "Byte", "width", "of", "the", "image", "*/", "int", "img_bpp", "=", "3", ";", "/*", "Bytes-per-pixel", "in", "image", "*/", "int", "neg_lut", "[", "256", "]", ";", "/*", "Negative", "coefficient", "LUT", "*/", "int", "pos_lut", "[", "256", "]", ";", "/*", "Positive", "coefficient", "LUT", "*/", "compute_luts", "(", "sharpen_percent", ",", "pos_lut", ",", "neg_lut", ")", ";", "pitch", "=", "width", "*", "img_bpp", ";", "for", "(", "row", "=", "0", ";", "row", "<", "4", ";", "row", "++", ")", "{", "src_rows", "[", "row", "]", "=", "new", "(", "unsigned", "char", ",", "pitch", ")", ";", "neg_rows", "[", "row", "]", "=", "new", "(", "long", "int", ",", "pitch", ")", ";", "}", "dst_row", "=", "new", "(", "unsigned", "char", ",", "pitch", ")", ";", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "Pre-load", "the", "first", "row", "for", "the", "filter...", "**/", "memcpy", "(", "src_rows", "[", "0", "]", ",", "src_region", ",", "pitch", ")", ";", "for", "(", "i", "=", "pitch", ",", "src_ptr", "=", "src_rows", "[", "0", "]", ",", "neg_ptr", "=", "neg_rows", "[", "0", "]", ";", "i", ">", "0", ";", "i", "--", ",", "src_ptr", "++", ",", "neg_ptr", "++", ")", "*", "neg_ptr", "=", "neg_lut", "[", "*", "src_ptr", "]", ";", "row", "=", "1", ";", "count", "=", "1", ";", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "Sharpen...", "**/", "for", "(", "y", "=", "0", ";", "y", "<", "height", ";", "y", "++", ")", "{", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "Load", "the", "next", "pixel", "row...", "**/", "if", "(", "(", "y", "+", "1", ")", "<", "height", ")", "{", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "Check", "to", "see", "if", "our", "src_rows[]", "array", "is", "overflowing", "yet...", "**/", "if", "(", "count", ">=", "3", ")", "count", "--", ";", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "Grab", "the", "next", "row...", "**/", "memcpy", "(", "src_rows", "[", "row", "]", ",", "(", "src_region", "+", "pitch", "*", "(", "y", "+", "1", ")", ")", ",", "pitch", ")", ";", "for", "(", "i", "=", "pitch", ",", "src_ptr", "=", "src_rows", "[", "row", "]", ",", "neg_ptr", "=", "neg_rows", "[", "row", "]", ";", "i", ">", "0", ";", "i", "--", ",", "src_ptr", "++", ",", "neg_ptr", "++", ")", "*", "neg_ptr", "=", "neg_lut", "[", "*", "src_ptr", "]", ";", "count", "++", ";", "row", "=", "(", "row", "+", "1", ")", "&", "3", ";", "}", "else", "{", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "No", "more", "pixels", "at", "the", "bottom...", "Drop", "the", "oldest", "samples...", "**/", "count", "--", ";", "}", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "Now", "sharpen", "pixels", "and", "save", "the", "results...", "**/", "if", "(", "count", "==", "3", ")", "{", "rgb_filter", "(", "width", ",", "pos_lut", ",", "neg_lut", ",", "src_rows", "[", "(", "row", "+", "2", ")", "&", "3", "]", ",", "dst_row", ",", "neg_rows", "[", "(", "row", "+", "1", ")", "&", "3", "]", "+", "img_bpp", ",", "neg_rows", "[", "(", "row", "+", "2", ")", "&", "3", "]", "+", "img_bpp", ",", "neg_rows", "[", "(", "row", "+", "3", ")", "&", "3", "]", "+", "img_bpp", ")", ";", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "Set", "the", "row...", "**/", "memcpy", "(", "(", "dest_region", "+", "pitch", "*", "y", ")", ",", "dst_row", ",", "pitch", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "count", "==", "2", ")", "{", "if", "(", "y", "==", "0", ")", "/*", "first", "row", "*/", "memcpy", "(", "(", "dest_region", ")", ",", "src_rows", "[", "0", "]", ",", "pitch", ")", ";", "else", "/*", "last", "row", "*/", "memcpy", "(", "(", "dest_region", "+", "pitch", "*", "(", "y", ")", ")", ",", "src_rows", "[", "(", "height", "-", "1", ")", "&", "3", "]", ",", "pitch", ")", ";", "}", "}", "/*", "for", "*/", "<comment_type=\"block\"", "format=\"doxygen\">", "/**", "OK,", "we\\'re", "done.", "Free", "all", "memory", "used...", "**/", "for", "(", "row", "=", "0", ";", "row", "<", "4", ";", "row", "++", ")", "{", "free", "(", "src_rows", "[", "row", "]", ")", ";", "free", "(", "neg_rows", "[", "row", "]", ")", ";", "}", "free", "(", "dst_row", ")", ";", "}'" ]

[ "Determine", "if", "the", "manual", "input", "value", "is", "within", "acceptable", "limits" ]

[ "'bool", "validInputRange", "(", "int16_t", "min", ",", "int16_t", "max", ",", "uint16_t", "value", ")", "{", "if", "(", "min", ">", "max", ")", "{", "int16_t", "tmp", "=", "min", ";", "min", "=", "max", ";", "max", "=", "tmp", ";", "}", "return", "value", ">=", "min", "-", "CONNECTION_OFFSET", "&&", "value", "<=", "max", "+", "CONNECTION_OFFSET", ";", "}'" ]

[ "Apply", "Low", "Pass", "Filter", "to", "Throttle", "Roll", "Pitch", "Yaw", "or", "Accessory", "channel" ]

[ "'static", "void", "applyLPF", "(", "float", "*", "value", ",", "ManualControlSettingsResponseTimeElem", "channel", ",", "ManualControlSettingsResponseTimeData", "*", "responseTime", ",", "uint8_t", "deadband", ",", "float", "dT", ")", "{", "float", "rt", "=", "(", "float", ")", "ManualControlSettingsResponseTimeToArray", "(", "(", "*", "responseTime", ")", ")", "[", "channel", "]", ";", "if", "(", "rt", ">", "0.0f", ")", "{", "inputFiltered", "[", "channel", "]", "=", "(", "(", "rt", "*", "inputFiltered", "[", "channel", "]", ")", "+", "(", "dT", "*", "(", "*", "value", ")", ")", ")", "/", "(", "rt", "+", "dT", ")", ";", "float", "floatDeadband", "=", "(", "(", "float", ")", "deadband", ")", "*", "0.01f", ";", "//", "avoid", "a", "long", "tail", "of", "non-zero", "data.", "if", "we", "have", "deadband,", "once", "the", "filtered", "result", "reduces", "to", "1/10th", "//", "of", "deadband", "revert", "to", "0.", "We", "downstream", "rely", "on", "this", "to", "know", "when", "sticks", "are", "centered.", "if", "(", "floatDeadband", ">", "0.0f", "&&", "fabsf", "(", "inputFiltered", "[", "channel", "]", ")", "<", "floatDeadband", "*", "0.1f", ")", "{", "inputFiltered", "[", "channel", "]", "=", "0.0f", ";", "}", "*", "value", "=", "inputFiltered", "[", "channel", "]", ";", "}", "}'" ]

[ "Apply", "deadband", "to", "Roll", "Pitch", "Yaw", "channels" ]

[ "'static", "void", "applyDeadband", "(", "float", "*", "value", ",", "uint8_t", "deadband", ")", "{", "float", "floatDeadband", "=", "(", "(", "float", ")", "deadband", ")", "*", "0.01f", ";", "if", "(", "fabsf", "(", "*", "value", ")", "<", "floatDeadband", ")", "{", "*", "value", "=", "0.0f", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "*", "value", ">", "0.0f", ")", "{", "*", "value", "=", "(", "*", "value", "-", "floatDeadband", ")", "/", "(", "1.0f", "-", "floatDeadband", ")", ";", "}", "else", "{", "*", "value", "=", "(", "*", "value", "+", "floatDeadband", ")", "/", "(", "1.0f", "-", "floatDeadband", ")", ";", "}", "}'" ]

[ "at", "least", "1", "byte", "must", "be", "sent!" ]

[ "'int", "send_fd", "(", "int", "unix_socket", ",", "void", "*", "data", ",", "int", "data_len", ",", "int", "fd", ")", "{", "struct", "msghdr", "msg", ";", "struct", "iovec", "iov", "[", "1", "]", ";", "int", "ret", ";", "#", "ifdef", "HAVE_MSGHDR_MSG_CONTROL", "struct", "cmsghdr", "*", "cmsg", ";", "/*", "make", "sure", "msg_control", "will", "point", "to", "properly", "aligned", "data", "*/", "union", "{", "struct", "cmsghdr", "cm", ";", "char", "control", "[", "CMSG_SPACE", "(", "sizeof", "(", "fd", ")", ")", "]", ";", "}", "control_un", ";", "msg", ".", "msg_control", "=", "control_un", ".", "control", ";", "/*", "openbsd", "doesn\\'t", "like", "\"more", "space\",", "msg_controllen", "must", "not", "*", "include", "the", "end", "padding", "*/", "msg", ".", "msg_controllen", "=", "CMSG_LEN", "(", "sizeof", "(", "fd", ")", ")", ";", "cmsg", "=", "CMSG_FIRSTHDR", "(", "&", "msg", ")", ";", "cmsg", "->", "cmsg_level", "=", "SOL_SOCKET", ";", "cmsg", "->", "cmsg_type", "=", "SCM_RIGHTS", ";", "cmsg", "->", "cmsg_len", "=", "CMSG_LEN", "(", "sizeof", "(", "fd", ")", ")", ";", "put_unaligned_int", "(", "CMSG_DATA", "(", "cmsg", ")", ",", "fd", ")", ";", "msg", ".", "msg_flags", "=", "0", ";", "#", "else", "msg", ".", "msg_accrights", "=", "(", "caddr_t", ")", "&", "fd", ";", "msg", ".", "msg_accrightslen", "=", "sizeof", "(", "fd", ")", ";", "#", "endif", "msg", ".", "msg_name", "=", "0", ";", "msg", ".", "msg_namelen", "=", "0", ";", "iov", "[", "0", "]", ".", "iov_base", "=", "data", ";", "iov", "[", "0", "]", ".", "iov_len", "=", "data_len", ";", "msg", ".", "msg_iov", "=", "iov", ";", "msg", ".", "msg_iovlen", "=", "1", ";", "again", ":", "ret", "=", "sendmsg", "(", "unix_socket", ",", "&", "msg", ",", "0", ")", ";", "if", "(", "ret", "<", "0", ")", "{", "if", "(", "errno", "==", "EINTR", ")", "goto", "again", ";", "if", "(", "errno", "==", "EAGAIN", "||", "errno", "==", "EWOULDBLOCK", ")", "{", "LM_ERR", "(", "\"sendmsg", "would", "block", "on", "%d:", "%s\\\"", ",", "unix_socket", ",", "strerror", "(", "errno", ")", ")", ";", "}", "else", "{", "LM_CRIT", "(", "\"sendmsg", "failed", "on", "%d:", "%s\\\"", ",", "unix_socket", ",", "strerror", "(", "errno", ")", ")", ";", "}", "}", "return", "ret", ";", "}'" ]

[ "gcc", "does", "the", "right", "thing" ]

[ "'static", "inline", "int", "get_unaligned_int", "(", "const", "void", "*", "p", ")", "{", "const", "struct", "{", "int", "d", ";", "}", "__attribute__", "(", "(", "packed", ")", ")", "*", "pp", "=", "p", ";", "return", "pp", "->", "d", ";", "}'" ]

[ "gcc", "does", "the", "right", "thing" ]

[ "'static", "inline", "void", "put_unaligned_int", "(", "void", "*", "p", ",", "int", "value", ")", "{", "struct", "{", "int", "d", ";", "}", "__attribute__", "(", "(", "packed", ",", "may_alias", ")", ")", "*", "pp", "=", "p", ";", "pp", "->", "d", "=", "value", ";", "}'" ]

[ "Search", "for", "a", "\"shared\"", "file", "with", "lowlevel", "file", "info", "that", "matches" ]

[ "'H5F_shared_t", "*", "H5F__sfile_search", "(", "H5FD_t", "*", "lf", ")", "{", "H5F_sfile_node_t", "*", "curr", ";", "/*", "Current", "shared", "file", "node", "*/", "H5F_shared_t", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_PACKAGE_NOERR", "/*", "Sanity", "check", "*/", "HDassert", "(", "lf", ")", ";", "/*", "Iterate", "through", "low-level", "files", "for", "matching", "low-level", "file", "info", "*/", "curr", "=", "H5F_sfile_head_g", ";", "while", "(", "curr", ")", "{", "/*", "Check", "for", "match", "*/", "if", "(", "0", "==", "H5FD_cmp", "(", "curr", "->", "shared", "->", "lf", ",", "lf", ")", ")", "HGOTO_DONE", "(", "curr->shared", ")", "/*", "Advance", "to", "next", "shared", "file", "node", "*/", "curr", "=", "curr", "->", "next", ";", "}", "/*", "end", "while", "*/", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Sanity", "checking", "that", "shared", "file", "list", "is", "empty" ]

[ "'void", "H5F_sfile_assert_num", "(", "unsigned", "n", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "if", "(", "n", "==", "0", ")", "{", "/*", "Sanity", "checking", "*/", "HDassert", "(", "H5F_sfile_head_g", "==", "NULL", ")", ";", "}", "/*", "end", "if", "*/", "else", "{", "unsigned", "count", ";", "/*", "Number", "of", "open", "shared", "files", "*/", "H5F_sfile_node_t", "*", "curr", ";", "/*", "Current", "shared", "file", "node", "*/", "/*", "Iterate", "through", "low-level", "files", "for", "matching", "low-level", "file", "info", "*/", "curr", "=", "H5F_sfile_head_g", ";", "count", "=", "0", ";", "while", "(", "curr", ")", "{", "/*", "Increment", "#", "of", "open", "shared", "file", "structs", "*/", "count", "++", ";", "/*", "Advance", "to", "next", "shared", "file", "node", "*/", "curr", "=", "curr", "->", "next", ";", "}", "/*", "end", "while", "*/", "/*", "Sanity", "checking", "*/", "HDassert", "(", "count", "==", "n", ")", ";", "}", "/*", "end", "else", "*/", "FUNC_LEAVE_NOAPI_VOID", "}'" ]

[ "Remove", "a", "\"shared\"", "file", "struct", "from", "the", "list", "of", "open", "files" ]

[ "'herr_t", "H5F__sfile_remove", "(", "H5F_shared_t", "*", "shared", ")", "{", "H5F_sfile_node_t", "*", "curr", ";", "/*", "Current", "shared", "file", "node", "*/", "H5F_sfile_node_t", "*", "last", ";", "/*", "Last", "shared", "file", "node", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_PACKAGE", "/*", "Sanity", "check", "*/", "HDassert", "(", "shared", ")", ";", "/*", "Locate", "shared", "file", "node", "with", "correct", "shared", "file", "*/", "last", "=", "NULL", ";", "curr", "=", "H5F_sfile_head_g", ";", "while", "(", "curr", "&&", "curr", "->", "shared", "!=", "shared", ")", "{", "/*", "Advance", "to", "next", "node", "*/", "last", "=", "curr", ";", "curr", "=", "curr", "->", "next", ";", "}", "/*", "end", "while", "*/", "/*", "Indicate", "error", "if", "the", "node", "wasn\\'t", "found", "*/", "if", "(", "curr", "==", "NULL", ")", "HGOTO_ERROR", "(", "H5E_FILE", ",", "H5E_NOTFOUND", ",", "FAIL", ",", "\"can\\'t", "find", "shared", "file", "info\"", ")", "/*", "Remove", "node", "found", "from", "list", "*/", "if", "(", "last", "!=", "NULL", ")", "/*", "Removing", "middle", "or", "tail", "node", "in", "list", "*/", "last", "->", "next", "=", "curr", "->", "next", ";", "else", "/*", "Removing", "head", "node", "in", "list", "*/", "H5F_sfile_head_g", "=", "curr", "->", "next", ";", "/*", "Release", "the", "shared", "file", "node", "struct", "*/", "/*", "(the", "shared", "file", "info", "itself", "is", "freed", "elsewhere)", "*/", "curr", "=", "H5FL_FREE", "(", "H5F_sfile_node_t", ",", "curr", ")", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Add", "a", "\"shared\"", "file", "struct", "to", "the", "list", "of", "open", "files" ]

[ "'herr_t", "H5F__sfile_add", "(", "H5F_shared_t", "*", "shared", ")", "{", "H5F_sfile_node_t", "*", "new_shared", ";", "/*", "New", "shared", "file", "node", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_PACKAGE", "/*", "Sanity", "check", "*/", "HDassert", "(", "shared", ")", ";", "/*", "Allocate", "new", "shared", "file", "node", "*/", "if", "(", "NULL", "==", "(", "new_shared", "=", "H5FL_CALLOC", "(", "H5F_sfile_node_t", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "FAIL", ",", "\"memory", "allocation", "failed\"", ")", "/*", "Set", "shared", "file", "value", "*/", "new_shared", "->", "shared", "=", "shared", ";", "/*", "Prepend", "to", "list", "of", "shared", "files", "open", "*/", "new_shared", "->", "next", "=", "H5F_sfile_head_g", ";", "H5F_sfile_head_g", "=", "new_shared", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "This", "isn't", "meant", "to", "run", "particularly,", "it's", "just", "to", "test", "type", "checking" ]

[ "'int", "main", "(", "int", "argc", ",", "char", "*", "*", "argv", ")", "{", "X", "*", "x", "=", "NULL", ";", "unsigned", "char", "*", "*", "pp", "=", "NULL", ";", "M_ASN1_I2D_vars", "(", "x", ")", ";", "M_ASN1_I2D_len_SEQUENCE_opt_type", "(", "X509_EXTENSION", ",", "x", "->", "ext", ",", "i2d_X509_EXTENSION", ")", ";", "M_ASN1_I2D_seq_total", "()", ";", "M_ASN1_I2D_put_SEQUENCE_opt_type", "(", "X509_EXTENSION", ",", "x", "->", "ext", ",", "i2d_X509_EXTENSION", ")", ";", "M_ASN1_I2D_finish", "()", ";", "}'" ]

[ "Process", "character", "that", "may", "be", "part", "of", "ANSI", "escape", "sequence" ]

[ "'int", "ansiesc_process", "(", "struct", "ansiesc_context", "*", "ctx", ",", "int", "c", ")", "{", "if", "(", "ctx", "->", "count", "==", "0", ")", "{", "if", "(", "c", "==", "ESC", ")", "{", "/*", "First", "byte", "of", "CSI", ":", "begin", "escape", "sequence", "*/", "ctx", "->", "count", "=", "1", ";", "memset", "(", "ctx", "->", "params", ",", "0xff", ",", "sizeof", "(", "ctx", "->", "params", ")", ")", ";", "ctx", "->", "function", "=", "0", ";", "return", "-", "1", ";", "}", "else", "{", "/*", "Normal", "character", "*/", "return", "c", ";", "}", "}", "else", "{", "if", "(", "c", "==", "\\'[\\'", ")", "{", "/*", "Second", "byte", "of", "CSI", ":", "do", "nothing", "*/", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "c", ">=", "\\'0\\'", ")", "&&", "(", "c", "<=", "\\'9\\'", ")", ")", "{", "/*", "Parameter", "Byte", ":", "part", "of", "a", "parameter", "value", "*/", "int", "*", "param", "=", "&", "ctx", "->", "params", "[", "ctx", "->", "count", "-", "1", "]", ";", "if", "(", "*", "param", "<", "0", ")", "*", "param", "=", "0", ";", "*", "param", "=", "(", "(", "*", "param", "*", "10", ")", "+", "(", "c", "-", "\\'0\\'", ")", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "c", "==", "\\';\\'", ")", "{", "/*", "Parameter", "Byte", ":", "parameter", "delimiter", "*/", "ctx", "->", "count", "++", ";", "if", "(", "ctx", "->", "count", ">", "(", "sizeof", "(", "ctx", "->", "params", ")", "/", "sizeof", "(", "ctx", "->", "params", "[", "0", "]", ")", ")", ")", "{", "/*", "Excessive", "parameters", ":", "abort", "sequence", "*/", "ctx", "->", "count", "=", "0", ";", "DBG", "(", "\"Too", "many", "parameters", "in", "ANSI", "escape", "\"", "\"sequence\\\"", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "(", "c", ">=", "0x20", ")", "&&", "(", "c", "<=", "0x2f", ")", ")", "||", "(", "c", "==", "\\'?\\'", ")", ")", "{", "/*", "Intermediate", "Byte", "*/", "ctx", "->", "function", "<<=", "8", ";", "ctx", "->", "function", "|=", "c", ";", "}", "else", "{", "/*", "Treat", "as", "Final", "Byte.", "Zero", "ctx->count", "before", "*", "calling", "handler", "to", "avoid", "potential", "infinite", "loops.", "*/", "int", "count", "=", "ctx", "->", "count", ";", "ctx", "->", "count", "=", "0", ";", "ctx", "->", "function", "<<=", "8", ";", "ctx", "->", "function", "|=", "c", ";", "ansiesc_call_handler", "(", "ctx", ",", "ctx", "->", "function", ",", "count", ",", "ctx", "->", "params", ")", ";", "}", "return", "-", "1", ";", "}", "}'" ]

[ "ABQPop", "pop", "an", "element", "from", "the", "head", "of", "the", "ABQ" ]

[ "'Bool", "ABQPop", "(", "ABQ", "abq", ",", "void", "*", "elementReturn", ")", "{", "AVER", "(", "elementReturn", "!=", "NULL", ")", ";", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "METER_ACC", "(", "abq", "->", "pop", ",", "ABQDepth", "(", "abq", ")", ")", ";", "if", "(", "ABQIsEmpty", "(", "abq", ")", ")", "return", "FALSE", ";", "(", "void", ")", "mps_lib_memcpy", "(", "elementReturn", ",", "ABQElement", "(", "abq", ",", "abq", "->", "out", ")", ",", "abq", "->", "elementSize", ")", ";", "abq", "->", "out", "=", "ABQNextIndex", "(", "abq", ",", "abq", "->", "out", ")", ";", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "return", "TRUE", ";", "}'" ]

[ "ABQPush", "push", "an", "element", "onto", "the", "tail", "of", "the", "ABQ" ]

[ "'Bool", "ABQPush", "(", "ABQ", "abq", ",", "void", "*", "element", ")", "{", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "METER_ACC", "(", "abq", "->", "push", ",", "ABQDepth", "(", "abq", ")", ")", ";", "if", "(", "ABQIsFull", "(", "abq", ")", ")", "return", "FALSE", ";", "(", "void", ")", "mps_lib_memcpy", "(", "ABQElement", "(", "abq", ",", "abq", "->", "in", ")", ",", "element", ",", "abq", "->", "elementSize", ")", ";", "abq", "->", "in", "=", "ABQNextIndex", "(", "abq", ",", "abq", "->", "in", ")", ";", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "return", "TRUE", ";", "}'" ]

[ "ABQIsEmpty", "Is", "an", "ABQ", "empty?" ]

[ "'Bool", "ABQIsEmpty", "(", "ABQ", "abq", ")", "{", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "return", "abq", "->", "out", "==", "abq", "->", "in", ";", "}'" ]

[ "ABQPeek", "peek", "at", "the", "head", "of", "the", "ABQ" ]

[ "\"Bool", "ABQPeek", "(", "ABQ", "abq", ",", "void", "*", "elementReturn", ")", "{", "AVER", "(", "elementReturn", "!=", "NULL", ")", ";", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "METER_ACC", "(", "abq", "->", "peek", ",", "ABQDepth", "(", "abq", ")", ")", ";", "if", "(", "ABQIsEmpty", "(", "abq", ")", ")", "return", "FALSE", ";", "(", "void", ")", "mps_lib_memcpy", "(", "elementReturn", ",", "ABQElement", "(", "abq", ",", "abq", "->", "out", ")", ",", "abq", "->", "elementSize", ")", ";", "/*", "Identical", "to", "pop,", "but", "don't", "increment", "out", "*/", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "return", "TRUE", ";", "}\"" ]

[ "ABQFinish", "finish", "an", "ABQ" ]

[ "'void", "ABQFinish", "(", "Arena", "arena", ",", "ABQ", "abq", ")", "{", "AVERT", "(", "Arena", ",", "arena", ")", ";", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "METER_EMIT", "(", "&", "abq", "->", "push", ")", ";", "METER_EMIT", "(", "&", "abq", "->", "pop", ")", ";", "METER_EMIT", "(", "&", "abq", "->", "peek", ")", ";", "METER_EMIT", "(", "&", "abq", "->", "delete", ")", ";", "ControlFree", "(", "arena", ",", "abq", "->", "queue", ",", "ABQQueueSize", "(", "abq", "->", "elements", ",", "abq", "->", "elementSize", ")", ")", ";", "abq", "->", "elements", "=", "0", ";", "abq", "->", "queue", "=", "NULL", ";", "abq", "->", "sig", "=", "SigInvalid", ";", "}'" ]

[ "ABQDepth", "return", "the", "number", "of", "elements", "in", "an", "ABQ" ]

[ "'Count", "ABQDepth", "(", "ABQ", "abq", ")", "{", "Index", "out", ",", "<type", "ref=\"prev\"/>", "in", ";", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "out", "=", "abq", "->", "out", ";", "in", "=", "abq", "->", "in", ";", "if", "(", "in", ">=", "out", ")", "return", "in", "-", "out", ";", "else", "return", "in", "+", "abq", "->", "elements", "-", "out", ";", "}'" ]

[ "ABQCheck", "validate", "an", "ABQ" ]

[ "'Bool", "ABQCheck", "(", "ABQ", "abq", ")", "{", "CHECKS", "(", "ABQ", ",", "abq", ")", ";", "CHECKL", "(", "abq", "->", "elements", ">", "0", ")", ";", "CHECKL", "(", "abq", "->", "elementSize", ">", "0", ")", ";", "CHECKL", "(", "abq", "->", "in", "<", "abq", "->", "elements", ")", ";", "CHECKL", "(", "abq", "->", "out", "<", "abq", "->", "elements", ")", ";", "CHECKL", "(", "abq", "->", "queue", "!=", "NULL", ")", ";", "return", "TRUE", ";", "}'" ]

[ "ABQIterate", "call", "'visitor'", "for", "each", "element", "in", "an", "ABQ" ]

[ "'void", "ABQIterate", "(", "ABQ", "abq", ",", "ABQVisitor", "visitor", ",", "void", "*", "closure", ")", "{", "Index", "copy", ",", "<type", "ref=\"prev\"/>", "index", ",", "<type", "ref=\"prev\"/>", "in", ";", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "AVER", "(", "FUNCHECK", "(", "visitor", ")", ")", ";", "copy", "=", "abq", "->", "out", ";", "index", "=", "abq", "->", "out", ";", "in", "=", "abq", "->", "in", ";", "while", "(", "index", "!=", "in", ")", "{", "void", "*", "element", "=", "ABQElement", "(", "abq", ",", "index", ")", ";", "Bool", "delete", "=", "FALSE", ";", "Bool", "cont", ";", "cont", "=", "(", "*", "visitor", ")", "(", "&", "delete", ",", "element", ",", "closure", ")", ";", "AVERT", "(", "Bool", ",", "cont", ")", ";", "AVERT", "(", "Bool", ",", "delete", ")", ";", "if", "(", "!", "delete", ")", "{", "if", "(", "copy", "!=", "index", ")", "(", "void", ")", "mps_lib_memcpy", "(", "ABQElement", "(", "abq", ",", "copy", ")", ",", "element", ",", "abq", "->", "elementSize", ")", ";", "copy", "=", "ABQNextIndex", "(", "abq", ",", "copy", ")", ";", "}", "index", "=", "ABQNextIndex", "(", "abq", ",", "index", ")", ";", "if", "(", "!", "cont", ")", "break;", "}", "/*", "If", "any", "elements", "were", "deleted,", "need", "to", "copy", "remainder", "of", "queue.", "*/", "if", "(", "copy", "!=", "index", ")", "{", "while", "(", "index", "!=", "in", ")", "{", "(", "void", ")", "mps_lib_memcpy", "(", "ABQElement", "(", "abq", ",", "copy", ")", ",", "ABQElement", "(", "abq", ",", "index", ")", ",", "abq", "->", "elementSize", ")", ";", "copy", "=", "ABQNextIndex", "(", "abq", ",", "copy", ")", ";", "index", "=", "ABQNextIndex", "(", "abq", ",", "index", ")", ";", "}", "abq", "->", "in", "=", "copy", ";", "}", "AVERT", "(", "ABQ", ",", "abq", ")", ";", "}'" ]

[ "A", "header", "is", "available;", "parse", "it", "and", "wait", "for", "the", "entire", "packet" ]

[ "'static", "int", "callback_wait_gotheader", "(", "void", "*", "cookie", ",", "int", "status", ")", "{", "CRC32C_CTX", "ctx", ";", "struct", "wait_cookie", "*", "W", "=", "cookie", ";", "uint8_t", "*", "data", ";", "size_t", "datalen", ";", "size_t", "len", ";", "uint8_t", "cbuf", "[", "4", "]", ";", "int", "rc", ";", "/*", "Did", "we", "fail", "or", "prematurely", "EOF?", "*/", "if", "(", "status", ")", "goto", "failed", ";", "/*", "Grab", "the", "header", "and", "verify", "the", "checksum.", "*/", "netbuf_read_peek", "(", "W", "->", "R", ",", "&", "data", ",", "&", "datalen", ")", ";", "CRC32C_Init", "(", "&", "ctx", ")", ";", "CRC32C_Update", "(", "&", "ctx", ",", "data", ",", "12", ")", ";", "CRC32C_Final", "(", "cbuf", ",", "&", "ctx", ")", ";", "if", "(", "memcmp", "(", "&", "data", "[", "12", "]", ",", "cbuf", ",", "4", ")", ")", "{", "warn0", "(", "\"Incorrect", "CRC", "on", "packet", "header\"", ")", ";", "goto", "failed", ";", "}", "/*", "Parse", "length", "and", "wait", "for", "the", "complete", "packet", "to", "be", "available.", "*/", "len", "=", "be32dec", "(", "&", "data", "[", "8", "]", ")", ";", "if", "(", "len", ">", "SIZE_MAX", "-", "20", ")", "goto", "failed", ";", "if", "(", "netbuf_read_wait", "(", "W", "->", "R", ",", "len", "+", "20", ",", "callback_wait_gotdata", ",", "W", ")", ")", "goto", "failed", ";", "/*", "Success!", "*/", "return", "(", "0", ")", ";", "failed", ":", "/*", "Perform", "a", "failure", "callback.", "*/", "rc", "=", "(", "W", "->", "callback", ")", "(", "W", "->", "cookie", ",", "1", ")", ";", "/*", "Free", "the", "cookie.", "*/", "mpool_wait_cookie_free", "(", "W", ")", ";", "/*", "Return", "status", "from", "callback.", "*/", "return", "(", "rc", ")", ";", "}'" ]

[ "A", "packet", "is", "available;", "invoke", "the", "upstream", "callback" ]

[ "'static", "int", "callback_wait_gotdata", "(", "void", "*", "cookie", ",", "int", "status", ")", "{", "struct", "wait_cookie", "*", "W", "=", "cookie", ";", "int", "rc", ";", "int", "st", ";", "/*", "Did", "we", "fail", "or", "prematurely", "EOF?", "*/", "if", "(", "(", "status", "==", "-", "1", ")", "||", "(", "status", "==", "1", ")", ")", "st", "=", "1", ";", "else", "st", "=", "0", ";", "/*", "Invoke", "the", "upstream", "callback.", "*/", "rc", "=", "(", "W", "->", "callback", ")", "(", "W", "->", "cookie", ",", "st", ")", ";", "/*", "Free", "the", "cookie.", "*/", "mpool_wait_cookie_free", "(", "W", ")", ";", "/*", "Return", "status", "from", "callback.", "*/", "return", "(", "rc", ")", ";", "}'" ]

[ "Randomizes", "a", "number", "(nonblocking)" ]

[ "'bool", "rng_get_random", "(", "uint32_t", "*", "rand_nr", ")", "{", "/*", "Check", "for", "errors", "*/", "if", "(", "RNG_SR", "&", "(", "RNG_SR_CECS", "|", "RNG_SR_SECS", ")", ")", "{", "return", "false", ";", "}", "/*", "data", "ready", "*/", "if", "(", "!", "(", "RNG_SR", "&", "RNG_SR_DRDY", ")", ")", "{", "return", "false", ";", "}", "*", "rand_nr", "=", "RNG_DR", ";", "return", "true", ";", "}'" ]

[ "This", "function", "handles", "System", "service", "call", "via", "SWI", "instruction" ]

[ "'void", "SVC_Handler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "SVCall_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "SVCall_IRQn", "0", "*/", "/*", "USER", "CODE", "BEGIN", "SVCall_IRQn", "1", "*/", "/*", "USER", "CODE", "END", "SVCall_IRQn", "1", "*/", "}'" ]

[ "This", "function", "handles", "DMA1", "channel1", "global", "interrupt" ]

[ "'void", "DMA1_Channel1_IRQHandler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "DMA1_Channel1_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "DMA1_Channel1_IRQn", "0", "*/", "HAL_DMA_IRQHandler", "(", "&", "hdma_adc1", ")", ";", "/*", "USER", "CODE", "BEGIN", "DMA1_Channel1_IRQn", "1", "*/", "/*", "USER", "CODE", "END", "DMA1_Channel1_IRQn", "1", "*/", "}'" ]

[ "This", "function", "handles", "Hard", "fault", "interrupt" ]

[ "'void", "HardFault_Handler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "HardFault_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "HardFault_IRQn", "0", "*/", "while", "(", "1", ")", "{", "/*", "USER", "CODE", "BEGIN", "W1_HardFault_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "W1_HardFault_IRQn", "0", "*/", "}", "}'" ]

[ "This", "function", "handles", "Debug", "monitor" ]

[ "'void", "DebugMon_Handler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "DebugMonitor_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "DebugMonitor_IRQn", "0", "*/", "/*", "USER", "CODE", "BEGIN", "DebugMonitor_IRQn", "1", "*/", "/*", "USER", "CODE", "END", "DebugMonitor_IRQn", "1", "*/", "}'" ]

[ "This", "function", "handles", "Non", "maskable", "interrupt" ]

[ "'void", "NMI_Handler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "NonMaskableInt_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "NonMaskableInt_IRQn", "0", "*/", "/*", "USER", "CODE", "BEGIN", "NonMaskableInt_IRQn", "1", "*/", "/*", "USER", "CODE", "END", "NonMaskableInt_IRQn", "1", "*/", "}'" ]

[ "This", "function", "handles", "ADC1", "and", "ADC2", "global", "interrupts" ]

[ "'void", "ADC1_2_IRQHandler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "ADC1_2_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "ADC1_2_IRQn", "0", "*/", "HAL_ADC_IRQHandler", "(", "&", "hadc1", ")", ";", "/*", "USER", "CODE", "BEGIN", "ADC1_2_IRQn", "1", "*/", "/*", "USER", "CODE", "END", "ADC1_2_IRQn", "1", "*/", "}'" ]

[ "This", "function", "handles", "System", "tick", "timer" ]

[ "'void", "SysTick_Handler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "SysTick_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "SysTick_IRQn", "0", "*/", "HAL_IncTick", "()", ";", "/*", "USER", "CODE", "BEGIN", "SysTick_IRQn", "1", "*/", "/*", "USER", "CODE", "END", "SysTick_IRQn", "1", "*/", "}'" ]

[ "This", "function", "handles", "Pendable", "request", "for", "system", "service" ]

[ "'void", "PendSV_Handler", "(", "void", ")", "{", "/*", "USER", "CODE", "BEGIN", "PendSV_IRQn", "0", "*/", "/*", "USER", "CODE", "END", "PendSV_IRQn", "0", "*/", "/*", "USER", "CODE", "BEGIN", "PendSV_IRQn", "1", "*/", "/*", "USER", "CODE", "END", "PendSV_IRQn", "1", "*/", "}'" ]

[ "send", "SVINFO", "message", "(regardless", "of", "state)" ]

[ "'static", "void", "send_svinfo", "(", "struct", "transport_tx", "*", "trans", ",", "struct", "link_device", "*", "dev", ")", "{", "static", "uint8_t", "i", "=", "0", ";", "if", "(", "i", ">=", "gps", ".", "nb_channels", ")", "{", "i", "=", "0", ";", "}", "send_svinfo_id", "(", "trans", ",", "dev", ",", "i", ")", ";", "i", "++", ";", "}'" ]

[ "end", "running", "stuff", "synchronously,", "initially", "started", "with", "r_core_task_sync_begin()" ]

[ "'R_API", "void", "r_core_task_sync_end", "(", "RCoreTaskScheduler", "*", "scheduler", ")", "{", "task_end", "(", "scheduler", "->", "main_task", ")", ";", "}'" ]

[ "begin", "running", "stuff", "synchronously", "on", "the", "main", "task" ]

[ "'R_API", "void", "r_core_task_sync_begin", "(", "RCoreTaskScheduler", "*", "scheduler", ")", "{", "RCoreTask", "*", "task", "=", "scheduler", "->", "main_task", ";", "TASK_SIGSET_T", "old_sigset", ";", "tasks_lock_enter", "(", "scheduler", ",", "&", "old_sigset", ")", ";", "task", "->", "thread", "=", "NULL", ";", "task", "->", "cmd", "=", "NULL", ";", "task", "->", "cmd_log", "=", "false", ";", "task", "->", "state", "=", "R_CORE_TASK_STATE_BEFORE_START", ";", "tasks_lock_leave", "(", "scheduler", ",", "&", "old_sigset", ")", ";", "task_wakeup", "(", "task", ")", ";", "}'" ]

[ "Recordcomparison", "callback", "from", "ptrheap" ]

[ "'static", "int", "compar", "(", "void", "*", "cookie", ",", "const", "void", "*", "x", ",", "const", "void", "*", "y", ")", "{", "const", "struct", "request", "*", "_x", "=", "x", ";", "const", "struct", "request", "*", "_y", "=", "y", ";", "(", "void", ")", "cookie", ";", "/*", "UNUSED", "*/", "/*", "Is", "one", "of", "the", "requests", "in", "progress?", "*/", "if", "(", "(", "_x", "->", "timeout_cookie", "!=", "NULL", ")", "&&", "(", "_y", "->", "timeout_cookie", "==", "NULL", ")", ")", "return", "(", "1", ")", ";", "if", "(", "(", "_x", "->", "timeout_cookie", "==", "NULL", ")", "&&", "(", "_y", "->", "timeout_cookie", "!=", "NULL", ")", ")", "return", "(", "-", "1", ")", ";", "/*", "Is", "one", "a", "higher", "priority?", "*/", "if", "(", "_x", "->", "prio", ">", "_y", "->", "prio", ")", "return", "(", "1", ")", ";", "if", "(", "_x", "->", "prio", "<", "_y", "->", "prio", ")", "return", "(", "-", "1", ")", ";", "/*", "Sort", "in", "order", "of", "arrival.", "*/", "if", "(", "_x", "->", "reqnum", ">", "_y", "->", "reqnum", ")", "return", "(", "1", ")", ";", "else", "return", "(", "-", "1", ")", ";", "}'" ]

[ "Callback", "from", "dynamodb_request", "(aka" ]

[ "'static", "int", "callback_reqdone", "(", "void", "*", "cookie", ",", "struct", "http_response", "*", "res", ")", "{", "struct", "request", "*", "R", "=", "cookie", ";", "struct", "dynamodb_request_queue", "*", "Q", "=", "R", "->", "Q", ";", "struct", "timeval", "t_end", ";", "double", "treq", ";", "int", "rc", "=", "0", ";", "double", "capacity", "=", "0.0", ";", "/*", "*", "If", "we", "have", "a", "response", "body,", "extract", "the", "number", "of", "capacity", "units", "*", "used,", "and", "update", "our", "rolling", "average", "and", "current", "capacity.", "*/", "if", "(", "(", "res", "!=", "NULL", ")", "&&", "(", "res", "->", "bodylen", ">", "0", ")", ")", "{", "if", "(", "extractcapacity", "(", "res", ",", "&", "capacity", ")", ")", "rc", "=", "-", "1", ";", "if", "(", "capacity", "!=", "0.0", ")", "{", "Q", "->", "mu_capperreq", "+=", "(", "capacity", "-", "Q", "->", "mu_capperreq", ")", "*", "0.01", ";", "Q", "->", "bucket_cap", "-=", "capacity", ";", "if", "(", "Q", "->", "bucket_cap", "<", "0.0", ")", "Q", "->", "bucket_cap", "=", "0.0", ";", "}", "}", "/*", "Figure", "out", "how", "long", "this", "request", "took.", "*/", "if", "(", "monoclock_get", "(", "&", "t_end", ")", ")", "{", "warnp", "(", "\"monoclock_get\"", ")", ";", "t_end", "=", "R", "->", "t_start", ";", "rc", "=", "-", "1", ";", "}", "/*", "Optionally", "log", "this", "request.", "*/", "if", "(", "Q", "->", "logfile", ")", "{", "if", "(", "logreq", "(", "Q", "->", "logfile", ",", "R", ",", "res", ",", "capacity", ",", "t_end", ")", ")", "rc", "=", "-", "1", ";", "}", "/*", "*", "This", "HTTP", "request", "has", "completed;", "we", "call", "done_http", "here", "rather", "*", "than", "earlier", "because", "it", "frees", "the", "target", "address,", "which", "is", "printed", "*", "to", "the", "request", "log.", "*/", "if", "(", "done_http", "(", "R", ",", "0", ")", ")", "rc", "=", "-", "1", ";", "/*", "What", "should", "we", "do", "with", "this", "response?", "*/", "if", "(", "(", "res", "!=", "NULL", ")", "&&", "(", "res", "->", "status", "==", "400", ")", "&&", "isthrottle", "(", "res", ")", ")", "{", "/*", "*", "We", "hit", "the", "throughput", "limits.", "Zero", "out", "our", "estimate", "of", "*", "the", "number", "of", "tokens", "in", "the", "bucket;", "we", "won\\'t", "send", "any", "*", "more", "requests", "until", "timer", "ticks", "add", "more", "tokens", "to", "the", "*", "modelled", "bucket.", "*/", "Q", "->", "bucket_cap", "=", "0.0", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "res", "!=", "NULL", ")", "&&", "(", "res", "->", "status", "<", "500", ")", ")", "{", "/*", "*", "Anything", "which", "isn\\'t", "an", "internal", "DynamoDB", "error", "or", "a", "*", "rate", "limiting", "response", "is", "something", "we", "should", "pass", "back", "*", "to", "the", "upstream", "code.", "*/", "/*", "Dequeue", "the", "request.", "*/", "ptrheap_delete", "(", "Q", "->", "reqs", ",", "R", "->", "rc", ")", ";", "/*", "Cancel", "the", "request", "timeout.", "*/", "events_timer_cancel", "(", "R", "->", "timeout_cookie", ")", ";", "/*", "*", "Update", "request", "timeout", "statistics.", "Following", "the", "strategy", "*", "used", "in", "TCP,", "we", "compute", "exponential", "rolling", "averages", "for", "*", "the", "mean", "and", "mean", "deviation;", "unlike", "TCP,", "we", "update", "our", "*", "statistics", "even", "on", "retries,", "since", "we", "know", "which", "attempt", "*", "succeeded.", "*/", "treq", "=", "(", "t_end", ".", "tv_sec", "-", "R", "->", "t_start", ".", "tv_sec", ")", "+", "(", "t_end", ".", "tv_usec", "-", "R", "->", "t_start", ".", "tv_usec", ")", "*", "0.000001", ";", "Q", "->", "tmu", "+=", "(", "treq", "-", "Q", "->", "tmu", ")", "*", "0.125", ";", "if", "(", "treq", ">", "Q", "->", "tmu", ")", "Q", "->", "tmud", "+=", "(", "(", "treq", "-", "Q", "->", "tmu", ")", "-", "Q", "->", "tmud", ")", "*", "0.25", ";", "else", "Q", "->", "tmud", "+=", "(", "(", "Q", "->", "tmu", "-", "treq", ")", "-", "Q", "->", "tmud", ")", "*", "0.25", ";", "/*", "Invoke", "the", "upstream", "callback.", "*/", "if", "(", "rc", ")", "{", "(", "void", ")", "(", "R", "->", "callback", ")", "(", "R", "->", "cookie", ",", "res", ")", ";", "}", "else", "{", "rc", "=", "(", "R", "->", "callback", ")", "(", "R", "->", "cookie", ",", "res", ")", ";", "}", "/*", "Free", "the", "request;", "we\\'re", "done", "with", "it", "now.", "*/", "free", "(", "R", "->", "logstr", ")", ";", "free", "(", "R", ")", ";", "}", "/*", "*", "If", "we", "didn\\'t", "send", "the", "response", "upstream,", "the", "request", "is", "still", "on", "*", "our", "queue", "with", "a", "timeout", "callback", "pending.", "We\\'re", "going", "to", "leave", "*", "it", "that", "way", "--", "we", "don\\'t", "want", "to", "retry", "the", "failed", "request", "until", "*", "the", "callback", "fires.", "*/", "/*", "*", "Poke", "the", "queue.", "If", "the", "request", "failed,", "it", "may", "be", "possible", "to", "*", "re-issue", "it;", "if", "the", "request", "succeeded,", "we", "may", "have", "ceased", "to", "be", "*", "at", "our", "in-flight", "limit", "and", "might", "be", "able", "to", "issue", "a", "new", "request;", "*", "if", "we", "just", "hit", "our", "first", "congestion,", "we", "need", "to", "start", "a", "timer", "to", "*", "add", "more", "tokens", "to", "our", "modelled", "bucket.", "*/", "if", "(", "poke", "(", "Q", ")", ")", "rc", "=", "-", "1", ";", "/*", "Return", "status", "from", "callback,", "or", "our", "own", "success/failure.", "*/", "return", "(", "rc", ")", ";", "}'" ]

[ "Check", "if", "we", "need", "to", "do", "anything", "with", "the", "queue" ]

[ "'static", "int", "runqueue", "(", "struct", "dynamodb_request_queue", "*", "Q", ")", "{", "struct", "request", "*", "R", ";", "struct", "timeval", "tnow", ";", "/*", "Increase", "burst", "capacity.", "*/", "if", "(", "monoclock_get", "(", "&", "tnow", ")", ")", "goto", "err0", ";", "Q", "->", "bucket_cap", "+=", "timeval_diff", "(", "Q", "->", "bucket_cap_lastbump", ",", "tnow", ")", "*", "Q", "->", "cappers", ";", "Q", "->", "bucket_cap_lastbump", "=", "tnow", ";", "/*", "Send", "requests", "as", "long", "as", "we", "have", "enough", "capacity.", "*/", "while", "(", "(", "(", "Q", "->", "inflight", "+", "1", ")", "*", "Q", "->", "mu_capperreq", "<=", "Q", "->", "maxburst_cap", ")", "&&", "(", "(", "Q", "->", "inflight", "+", "1", ")", "*", "Q", "->", "mu_capperreq", "<=", "Q", "->", "bucket_cap", ")", ")", "{", "/*", "Find", "the", "highest-priority", "request", "in", "the", "queue.", "*/", "R", "=", "ptrheap_getmin", "(", "Q", "->", "reqs", ")", ";", "/*", "Nothing", "left", "to", "send?", "*/", "if", "(", "(", "R", "==", "NULL", ")", "||", "(", "R", "->", "timeout_cookie", "!=", "NULL", ")", ")", "break;", "/*", "Send", "the", "highest-priority", "request.", "*/", "if", "(", "sendreq", "(", "Q", ",", "R", ")", ")", "goto", "err0", ";", "}", "/*", "Do", "we", "need", "to", "(re)start", "the", "capacity-accumulation", "timer?", "*/", "if", "(", "(", "Q", "->", "timer_cookie", "==", "NULL", ")", "&&", "(", "(", "Q", "->", "inflight", "+", "1", ")", "*", "Q", "->", "mu_capperreq", ">", "Q", "->", "bucket_cap", ")", ")", "{", "if", "(", "(", "Q", "->", "timer_cookie", "=", "events_timer_register_double", "(", "poke_timer", ",", "Q", ",", "Q", "->", "spercap", ")", ")", "==", "NULL", ")", "goto", "err0", ";", "}", "/*", "Success!", "*/", "return", "(", "0", ")", ";", "err0", ":", "/*", "Failure!", "*/", "return", "(", "-", "1", ")", ";", "}'" ]

[ "Log", "the", "(attempted)", "request" ]

[ "'static", "int", "logreq", "(", "struct", "logging_file", "*", "F", ",", "struct", "request", "*", "R", ",", "struct", "http_response", "*", "res", ",", "double", "capacity", ",", "struct", "timeval", "t_end", ")", "{", "long", "t_micros", ";", "char", "*", "addr", ";", "int", "status", ";", "size_t", "bodylen", ";", "/*", "Compute", "how", "long", "the", "request", "took.", "*/", "t_micros", "=", "(", "long", ")", "(", "t_end", ".", "tv_sec", "-", "R", "->", "t_start", ".", "tv_sec", ")", "*", "1000000", "+", "t_end", ".", "tv_usec", "-", "R", "->", "t_start", ".", "tv_usec", ";", "/*", "Prettyprint", "the", "address", "we", "selected.", "*/", "if", "(", "(", "addr", "=", "sock_addr_prettyprint", "(", "R", "->", "addrs", "[", "0", "]", ")", ")", "==", "NULL", ")", "goto", "err0", ";", "/*", "Extract", "parameters", "from", "HTTP", "response.", "*/", "if", "(", "res", "!=", "NULL", ")", "{", "status", "=", "res", "->", "status", ";", "bodylen", "=", "res", "->", "bodylen", ";", "}", "else", "{", "status", "=", "0", ";", "bodylen", "=", "0", ";", "}", "/*", "Write", "to", "the", "log", "file.", "*/", "if", "(", "logging_printf", "(", "F", ",", "\"|%s|%s|%d|%s|%ld|%zu|%f\"", ",", "R", "->", "op", ",", "R", "->", "logstr", "?", "R", "->", "logstr", ":", "\"\"", ",", "status", ",", "addr", ",", "t_micros", ",", "bodylen", ",", "capacity", ")", ")", "goto", "err1", ";", "/*", "Free", "string", "allocated", "by", "sock_addr_prettyprint.", "*/", "free", "(", "addr", ")", ";", "/*", "Success!", "*/", "return", "(", "0", ")", ";", "err1", ":", "free", "(", "addr", ")", ";", "err0", ":", "/*", "Failure!", "*/", "return", "(", "-", "1", ")", ";", "}'" ]

[ "Cookierecording", "callback", "from", "ptrheap" ]

[ "'static", "void", "setreccookie", "(", "void", "*", "cookie", ",", "void", "*", "ptr", ",", "size_t", "rc", ")", "{", "struct", "request", "*", "R", "=", "ptr", ";", "(", "void", ")", "cookie", ";", "/*", "UNUSED", "*/", "R", "->", "rc", "=", "rc", ";", "}'" ]

[ "Flushes", "a", "dirty", "free", "space", "header", "to", "disk" ]

[ "'static", "herr_t", "H5FS_cache_hdr_flush", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "hbool_t", "destroy", ",", "haddr_t", "addr", ",", "H5FS_t", "*", "fspace", ",", "unsigned", "H5_ATTR_UNUSED", "*", "flags_ptr", ")", "{", "H5WB_t", "*", "wb", "=", "NULL", ";", "/*", "Wrapped", "buffer", "for", "header", "data", "*/", "uint8_t", "hdr_buf", "[", "H5FS_HDR_BUF_SIZE", "]", ";", "/*", "Buffer", "for", "header", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "H5F_addr_defined", "(", "addr", ")", ")", ";", "HDassert", "(", "fspace", ")", ";", "HDassert", "(", "H5F_addr_defined", "(", "fspace", "->", "addr", ")", ")", ";", "/*", "Check", "if", "the", "header", "\"owns\"", "the", "section", "info", "*/", "if", "(", "fspace", "->", "sinfo", ")", "{", "/*", "Sanity", "check", "-", "should", "not", "be", "trying", "to", "destroy", "header", "if", "it", "still", "*", "\"owns\"", "section", "info", "*/", "HDassert", "(", "!", "destroy", ")", ";", "/*", "Check", "if", "the", "section", "info", "is", "dirty", "*/", "if", "(", "fspace", "->", "sinfo", "->", "dirty", ")", "{", "if", "(", "fspace", "->", "serial_sect_count", ">", "0", ")", "{", "/*", "Check", "if", "we", "need", "to", "allocate", "space", "for", "section", "info", "*/", "if", "(", "!", "H5F_addr_defined", "(", "fspace", "->", "sect_addr", ")", ")", "{", "/*", "Sanity", "check", "*/", "HDassert", "(", "fspace", "->", "sect_size", ">", "0", ")", ";", "/*", "Allocate", "space", "for", "the", "section", "info", "in", "file", "*/", "if", "(", "HADDR_UNDEF", "==", "(", "fspace", "->", "sect_addr", "=", "H5MF_alloc", "(", "f", ",", "H5FD_MEM_FSPACE_SINFO", ",", "dxpl_id", ",", "fspace", "->", "sect_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_NOSPACE", ",", "FAIL", ",", "\"file", "allocation", "failed", "for", "free", "space", "sections\"", ")", "fspace", "->", "alloc_sect_size", "=", "(", "size_t", ")", "fspace", "->", "sect_size", ";", "/*", "Mark", "header", "dirty", "*/", "/*", "(don\\'t", "use", "cache", "API,", "since", "we\\'re", "in", "a", "callback)", "*/", "fspace", "->", "cache_info", ".", "is_dirty", "=", "TRUE", ";", "}", "/*", "end", "if", "*/", "/*", "Write", "section", "info", "to", "file", "*/", "if", "(", "H5FS_cache_sinfo_flush", "(", "f", ",", "dxpl_id", ",", "FALSE", ",", "fspace", "->", "sect_addr", ",", "fspace", "->", "sinfo", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFLUSH", ",", "FAIL", ",", "\"unable", "to", "save", "free", "space", "section", "info", "to", "disk\"", ")", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Sanity", "check", "that", "section", "info", "doesn\\'t", "have", "address", "*/", "HDassert", "(", "!", "H5F_addr_defined", "(", "fspace", "->", "sect_addr", ")", ")", ";", "}", "/*", "end", "else", "*/", "/*", "Mark", "section", "info", "clean", "*/", "fspace", "->", "sinfo", "->", "dirty", "=", "FALSE", ";", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Just", "sanity", "checks...", "*/", "if", "(", "fspace", "->", "serial_sect_count", ">", "0", ")", "/*", "Sanity", "check", "that", "section", "info", "has", "address", "*/", "HDassert", "(", "H5F_addr_defined", "(", "fspace", "->", "sect_addr", ")", ")", ";", "else", "/*", "Sanity", "check", "that", "section", "info", "doesn\\'t", "have", "address", "*/", "HDassert", "(", "!", "H5F_addr_defined", "(", "fspace", "->", "sect_addr", ")", ")", ";", "}", "/*", "end", "else", "*/", "if", "(", "fspace", "->", "cache_info", ".", "is_dirty", ")", "{", "uint8_t", "*", "hdr", ";", "/*", "Pointer", "to", "header", "buffer", "*/", "uint8_t", "*", "p", ";", "/*", "Pointer", "into", "raw", "data", "buffer", "*/", "uint32_t", "metadata_chksum", ";", "/*", "Computed", "metadata", "checksum", "value", "*/", "/*", "Wrap", "the", "local", "buffer", "for", "serialized", "header", "info", "*/", "if", "(", "NULL", "==", "(", "wb", "=", "H5WB_wrap", "(", "hdr_buf", ",", "sizeof", "(", "hdr_buf", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"can\\'t", "wrap", "buffer\"", ")", "/*", "Get", "a", "pointer", "to", "a", "buffer", "that\\'s", "large", "enough", "for", "header", "*/", "if", "(", "NULL", "==", "(", "hdr", "=", "(", "uint8_t", "*", ")", "H5WB_actual", "(", "wb", ",", "fspace", "->", "hdr_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_NOSPACE", ",", "FAIL", ",", "\"can\\'t", "get", "actual", "buffer\"", ")", "/*", "Get", "temporary", "pointer", "to", "header", "*/", "p", "=", "hdr", ";", "/*", "Magic", "number", "*/", "HDmemcpy", "(", "p", ",", "H5FS_HDR_MAGIC", ",", "(", "size_t", ")", "H5_SIZEOF_MAGIC", ")", ";", "p", "+=", "H5_SIZEOF_MAGIC", ";", "/*", "Version", "#", "*/", "*", "p", "++", "=", "H5FS_HDR_VERSION", ";", "/*", "Client", "ID", "*/", "*", "p", "++", "=", "fspace", "->", "client", ";", "/*", "Total", "space", "tracked", "*/", "H5F_ENCODE_LENGTH", "(", "f", ",", "p", ",", "fspace", "->", "tot_space", ")", ";", "/*", "Total", "#", "of", "free", "space", "sections", "tracked", "*/", "H5F_ENCODE_LENGTH", "(", "f", ",", "p", ",", "fspace", "->", "tot_sect_count", ")", ";", "/*", "#", "of", "serializable", "free", "space", "sections", "tracked", "*/", "H5F_ENCODE_LENGTH", "(", "f", ",", "p", ",", "fspace", "->", "serial_sect_count", ")", ";", "/*", "#", "of", "ghost", "free", "space", "sections", "tracked", "*/", "H5F_ENCODE_LENGTH", "(", "f", ",", "p", ",", "fspace", "->", "ghost_sect_count", ")", ";", "/*", "#", "of", "section", "classes", "*/", "UINT16ENCODE", "(", "p", ",", "fspace", "->", "nclasses", ")", ";", "/*", "Shrink", "percent", "*/", "UINT16ENCODE", "(", "p", ",", "fspace", "->", "shrink_percent", ")", ";", "/*", "Expand", "percent", "*/", "UINT16ENCODE", "(", "p", ",", "fspace", "->", "expand_percent", ")", ";", "/*", "Size", "of", "address", "space", "free", "space", "sections", "are", "within", "(log2", "of", "actual", "value)", "*/", "UINT16ENCODE", "(", "p", ",", "fspace", "->", "max_sect_addr", ")", ";", "/*", "Max.", "size", "of", "section", "to", "track", "*/", "H5F_ENCODE_LENGTH", "(", "f", ",", "p", ",", "fspace", "->", "max_sect_size", ")", ";", "/*", "Address", "of", "serialized", "free", "space", "sections", "*/", "H5F_addr_encode", "(", "f", ",", "&", "p", ",", "fspace", "->", "sect_addr", ")", ";", "/*", "Size", "of", "serialized", "free", "space", "sections", "*/", "H5F_ENCODE_LENGTH", "(", "f", ",", "p", ",", "fspace", "->", "sect_size", ")", ";", "/*", "Allocated", "size", "of", "serialized", "free", "space", "sections", "*/", "H5F_ENCODE_LENGTH", "(", "f", ",", "p", ",", "fspace", "->", "alloc_sect_size", ")", ";", "/*", "Compute", "checksum", "*/", "metadata_chksum", "=", "H5_checksum_metadata", "(", "hdr", ",", "(", "size_t", ")", "(", "p", "-", "(", "uint8_t", "*", ")", "hdr", ")", ",", "0", ")", ";", "/*", "Metadata", "checksum", "*/", "UINT32ENCODE", "(", "p", ",", "metadata_chksum", ")", ";", "/*", "Write", "the", "free", "space", "header.", "*/", "HDassert", "(", "(", "size_t", ")", "(", "p", "-", "hdr", ")", "==", "fspace", "->", "hdr_size", ")", ";", "if", "(", "H5F_block_write", "(", "f", ",", "H5FD_MEM_FSPACE_HDR", ",", "addr", ",", "fspace", "->", "hdr_size", ",", "dxpl_id", ",", "hdr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFLUSH", ",", "FAIL", ",", "\"unable", "to", "save", "free", "space", "header", "to", "disk\"", ")", "fspace", "->", "cache_info", ".", "is_dirty", "=", "FALSE", ";", "}", "/*", "end", "if", "*/", "if", "(", "destroy", ")", "if", "(", "H5FS_cache_hdr_dest", "(", "f", ",", "fspace", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "destroy", "free", "space", "header\"", ")", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "wb", "&&", "H5WB_unwrap", "(", "wb", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_FSPACE", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "wrapped", "buffer\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Destroys", "a", "free", "space", "header", "in", "memory" ]

[ "'static", "herr_t", "H5FS_cache_hdr_dest", "(", "H5F_t", "*", "f", ",", "H5FS_t", "*", "fspace", ")", "{", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "Check", "arguments", "*/", "HDassert", "(", "fspace", ")", ";", "/*", "We", "should", "not", "still", "be", "holding", "on", "to", "the", "free", "space", "section", "info", "*/", "HDassert", "(", "!", "fspace", "->", "sinfo", ")", ";", "/*", "If", "we\\'re", "going", "to", "free", "the", "space", "on", "disk,", "the", "address", "must", "be", "valid", "*/", "HDassert", "(", "!", "fspace", "->", "cache_info", ".", "free_file_space_on_destroy", "||", "H5F_addr_defined", "(", "fspace", "->", "cache_info", ".", "addr", ")", ")", ";", "/*", "Check", "for", "freeing", "file", "space", "for", "free", "space", "header", "*/", "if", "(", "fspace", "->", "cache_info", ".", "free_file_space_on_destroy", ")", "{", "/*", "Sanity", "check", "*/", "HDassert", "(", "H5F_addr_defined", "(", "fspace", "->", "addr", ")", ")", ";", "/*", "Release", "the", "space", "on", "disk", "*/", "/*", "(XXX:", "Nasty", "usage", "of", "internal", "DXPL", "value!", "-QAK)", "*/", "if", "(", "H5MF_xfree", "(", "f", ",", "H5FD_MEM_FSPACE_HDR", ",", "H5AC_dxpl_id", ",", "fspace", "->", "cache_info", ".", "addr", ",", "(", "hsize_t", ")", "fspace", "->", "hdr_size", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "free", "free", "space", "header\"", ")", "}", "/*", "end", "if", "*/", "/*", "Destroy", "free", "space", "header", "*/", "if", "(", "H5FS_hdr_dest", "(", "fspace", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "destroy", "free", "space", "header\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Compute", "the", "size", "in", "bytes", "of", "a", "free", "space", "header", "on", "disk,", "and", "return", "it", "in", "size_ptr" ]

[ "'static", "herr_t", "H5FS_cache_hdr_size", "(", "const", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "const", "H5FS_t", "*", "fspace", ",", "size_t", "*", "size_ptr", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "/*", "check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "fspace", ")", ";", "HDassert", "(", "size_ptr", ")", ";", "/*", "Set", "size", "value", "*/", "*", "size_ptr", "=", "fspace", "->", "hdr_size", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Compute", "the", "size", "in", "bytes", "of", "a", "free", "space", "section", "info", "on", "disk,", "and", "return", "it", "in", "size_ptr" ]

[ "'static", "herr_t", "H5FS_cache_sinfo_size", "(", "const", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "const", "H5FS_sinfo_t", "*", "sinfo", ",", "size_t", "*", "size_ptr", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "/*", "check", "arguments", "*/", "HDassert", "(", "sinfo", ")", ";", "HDassert", "(", "size_ptr", ")", ";", "/*", "Set", "size", "value", "*/", "H5_CHECKED_ASSIGN", "(", "*", "size_ptr", ",", "size_t", ",", "sinfo", "->", "fspace", "->", "alloc_sect_size", ",", "hsize_t", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Flushes", "a", "dirty", "free", "space", "section", "info", "to", "disk" ]

[ "'static", "herr_t", "H5FS_cache_sinfo_flush", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "hbool_t", "destroy", ",", "haddr_t", "addr", ",", "H5FS_sinfo_t", "*", "sinfo", ",", "unsigned", "H5_ATTR_UNUSED", "*", "flags_ptr", ")", "{", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "H5F_addr_defined", "(", "addr", ")", ")", ";", "HDassert", "(", "sinfo", ")", ";", "HDassert", "(", "sinfo", "->", "fspace", ")", ";", "HDassert", "(", "sinfo", "->", "fspace", "->", "sect_cls", ")", ";", "if", "(", "sinfo", "->", "cache_info", ".", "is_dirty", "||", "sinfo", "->", "dirty", ")", "{", "H5FS_iter_ud_t", "udata", ";", "/*", "User", "data", "for", "callbacks", "*/", "uint8_t", "*", "buf", "=", "NULL", ";", "/*", "Temporary", "raw", "data", "buffer", "*/", "uint8_t", "*", "p", ";", "/*", "Pointer", "into", "raw", "data", "buffer", "*/", "uint32_t", "metadata_chksum", ";", "/*", "Computed", "metadata", "checksum", "value", "*/", "unsigned", "bin", ";", "/*", "Current", "bin", "we", "are", "on", "*/", "/*", "Sanity", "check", "address", "*/", "if", "(", "H5F_addr_ne", "(", "addr", ",", "sinfo", "->", "fspace", "->", "sect_addr", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "FAIL", ",", "\"incorrect", "address", "for", "free", "space", "sections\"", ")", "/*", "Allocate", "temporary", "buffer", "*/", "if", "(", "(", "buf", "=", "H5FL_BLK_MALLOC", "(", "sect_block", ",", "(", "size_t", ")", "sinfo", "->", "fspace", "->", "sect_size", ")", ")", "==", "NULL", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "FAIL", ",", "\"memory", "allocation", "failed\"", ")", "p", "=", "buf", ";", "/*", "Magic", "number", "*/", "HDmemcpy", "(", "p", ",", "H5FS_SINFO_MAGIC", ",", "(", "size_t", ")", "H5_SIZEOF_MAGIC", ")", ";", "p", "+=", "H5_SIZEOF_MAGIC", ";", "/*", "Version", "#", "*/", "*", "p", "++", "=", "H5FS_SINFO_VERSION", ";", "/*", "Address", "of", "free", "space", "header", "for", "these", "sections", "*/", "H5F_addr_encode", "(", "f", ",", "&", "p", ",", "sinfo", "->", "fspace", "->", "addr", ")", ";", "/*", "Set", "up", "user", "data", "for", "iterator", "*/", "udata", ".", "sinfo", "=", "sinfo", ";", "udata", ".", "p", "=", "&", "p", ";", "udata", ".", "sect_cnt_size", "=", "H5VM_limit_enc_size", "(", "(", "uint64_t", ")", "sinfo", "->", "fspace", "->", "serial_sect_count", ")", ";", "/*", "Iterate", "over", "all", "the", "bins", "*/", "for", "(", "bin", "=", "0", ";", "bin", "<", "sinfo", "->", "nbins", ";", "bin", "++", ")", "{", "/*", "Check", "if", "there", "are", "any", "sections", "in", "this", "bin", "*/", "if", "(", "sinfo", "->", "bins", "[", "bin", "]", ".", "bin_list", ")", "{", "/*", "Iterate", "over", "list", "of", "section", "size", "nodes", "for", "bin", "*/", "if", "(", "H5SL_iterate", "(", "sinfo", "->", "bins", "[", "bin", "]", ".", "bin_list", ",", "H5FS_sinfo_serialize_node_cb", ",", "&", "udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_BADITER", ",", "FAIL", ",", "\"can\\'t", "iterate", "over", "section", "size", "nodes\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "for", "*/", "/*", "Compute", "checksum", "*/", "metadata_chksum", "=", "H5_checksum_metadata", "(", "buf", ",", "(", "size_t", ")", "(", "p", "-", "buf", ")", ",", "0", ")", ";", "/*", "Metadata", "checksum", "*/", "UINT32ENCODE", "(", "p", ",", "metadata_chksum", ")", ";", "/*", "Sanity", "check", "*/", "HDassert", "(", "(", "size_t", ")", "(", "p", "-", "buf", ")", "==", "sinfo", "->", "fspace", "->", "sect_size", ")", ";", "HDassert", "(", "sinfo", "->", "fspace", "->", "sect_size", "<=", "sinfo", "->", "fspace", "->", "alloc_sect_size", ")", ";", "/*", "Write", "buffer", "to", "disk", "*/", "if", "(", "H5F_block_write", "(", "f", ",", "H5FD_MEM_FSPACE_SINFO", ",", "sinfo", "->", "fspace", "->", "sect_addr", ",", "(", "size_t", ")", "sinfo", "->", "fspace", "->", "sect_size", ",", "dxpl_id", ",", "buf", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFLUSH", ",", "FAIL", ",", "\"unable", "to", "save", "free", "space", "sections", "to", "disk\"", ")", "buf", "=", "H5FL_BLK_FREE", "(", "sect_block", ",", "buf", ")", ";", "sinfo", "->", "cache_info", ".", "is_dirty", "=", "FALSE", ";", "sinfo", "->", "dirty", "=", "FALSE", ";", "}", "/*", "end", "if", "*/", "if", "(", "destroy", ")", "if", "(", "H5FS_cache_sinfo_dest", "(", "f", ",", "sinfo", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "destroy", "free", "space", "section", "info\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Loads", "free", "space", "sections", "from", "the", "disk" ]

[ "'static", "H5FS_sinfo_t", "*", "H5FS_cache_sinfo_load", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "haddr_t", "H5_ATTR_UNUSED", "addr", ",", "void", "*", "_udata", ")", "{", "H5FS_sinfo_t", "*", "sinfo", "=", "NULL", ";", "/*", "Free", "space", "section", "info", "*/", "H5FS_sinfo_cache_ud_t", "*", "udata", "=", "(", "H5FS_sinfo_cache_ud_t", "*", ")", "_udata", ";", "/*", "user", "data", "for", "callback", "*/", "haddr_t", "fs_addr", ";", "/*", "Free", "space", "header", "address", "*/", "size_t", "old_sect_size", ";", "/*", "Old", "section", "size", "*/", "uint8_t", "*", "buf", "=", "NULL", ";", "/*", "Temporary", "buffer", "*/", "const", "uint8_t", "*", "p", ";", "/*", "Pointer", "into", "raw", "data", "buffer", "*/", "uint32_t", "stored_chksum", ";", "/*", "Stored", "metadata", "checksum", "value", "*/", "uint32_t", "computed_chksum", ";", "/*", "Computed", "metadata", "checksum", "value", "*/", "H5FS_sinfo_t", "*", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "udata", ")", ";", "/*", "Allocate", "a", "new", "free", "space", "section", "info", "*/", "if", "(", "NULL", "==", "(", "sinfo", "=", "H5FS_sinfo_new", "(", "udata", "->", "f", ",", "udata", "->", "fspace", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "NULL", ",", "\"memory", "allocation", "failed\"", ")", "/*", "Allocate", "space", "for", "the", "buffer", "to", "serialize", "the", "sections", "into", "*/", "H5_CHECKED_ASSIGN", "(", "old_sect_size", ",", "size_t", ",", "udata", "->", "fspace", "->", "sect_size", ",", "hsize_t", ")", ";", "if", "(", "NULL", "==", "(", "buf", "=", "H5FL_BLK_MALLOC", "(", "sect_block", ",", "(", "size_t", ")", "udata", "->", "fspace", "->", "sect_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "NULL", ",", "\"memory", "allocation", "failed\"", ")", "/*", "Read", "buffer", "from", "disk", "*/", "if", "(", "H5F_block_read", "(", "f", ",", "H5FD_MEM_FSPACE_SINFO", ",", "udata", "->", "fspace", "->", "sect_addr", ",", "(", "size_t", ")", "udata", "->", "fspace", "->", "sect_size", ",", "dxpl_id", ",", "buf", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_READERROR", ",", "NULL", ",", "\"can\\'t", "read", "free", "space", "sections\"", ")", "/*", "Deserialize", "free", "sections", "from", "buffer", "available", "*/", "p", "=", "buf", ";", "/*", "Magic", "number", "*/", "if", "(", "HDmemcmp", "(", "p", ",", "H5FS_SINFO_MAGIC", ",", "(", "size_t", ")", "H5_SIZEOF_MAGIC", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"wrong", "free", "space", "sections", "signature\"", ")", "p", "+=", "H5_SIZEOF_MAGIC", ";", "/*", "Version", "*/", "if", "(", "*", "p", "++", "!=", "H5FS_SINFO_VERSION", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"wrong", "free", "space", "sections", "version\"", ")", "/*", "Address", "of", "free", "space", "header", "for", "these", "sections", "*/", "H5F_addr_decode", "(", "udata", "->", "f", ",", "&", "p", ",", "&", "fs_addr", ")", ";", "if", "(", "H5F_addr_ne", "(", "fs_addr", ",", "udata", "->", "fspace", "->", "addr", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"incorrect", "header", "address", "for", "free", "space", "sections\"", ")", "/*", "Check", "for", "any", "serialized", "sections", "*/", "if", "(", "udata", "->", "fspace", "->", "serial_sect_count", ">", "0", ")", "{", "hsize_t", "old_tot_sect_count", ";", "/*", "Total", "section", "count", "from", "header", "*/", "hsize_t", "old_serial_sect_count", ";", "/*", "Total", "serializable", "section", "count", "from", "header", "*/", "hsize_t", "old_ghost_sect_count", ";", "/*", "Total", "ghost", "section", "count", "from", "header", "*/", "hsize_t", "old_tot_space", ";", "/*", "Total", "space", "managed", "from", "header", "*/", "unsigned", "sect_cnt_size", ";", "/*", "The", "size", "of", "the", "section", "size", "counts", "*/", "/*", "Compute", "the", "size", "of", "the", "section", "counts", "*/", "sect_cnt_size", "=", "H5VM_limit_enc_size", "(", "(", "uint64_t", ")", "udata", "->", "fspace", "->", "serial_sect_count", ")", ";", "/*", "Reset", "the", "section", "count,", "the", "\"add\"", "routine", "will", "update", "it", "*/", "old_tot_sect_count", "=", "udata", "->", "fspace", "->", "tot_sect_count", ";", "old_serial_sect_count", "=", "udata", "->", "fspace", "->", "serial_sect_count", ";", "old_ghost_sect_count", "=", "udata", "->", "fspace", "->", "ghost_sect_count", ";", "old_tot_space", "=", "udata", "->", "fspace", "->", "tot_space", ";", "udata", "->", "fspace", "->", "tot_sect_count", "=", "0", ";", "udata", "->", "fspace", "->", "serial_sect_count", "=", "0", ";", "udata", "->", "fspace", "->", "ghost_sect_count", "=", "0", ";", "udata", "->", "fspace", "->", "tot_space", "=", "0", ";", "/*", "Walk", "through", "the", "buffer,", "deserializing", "sections", "*/", "do", "{", "hsize_t", "sect_size", "=", "0", ";", "/*", "Current", "section", "size", "*/", "size_t", "node_count", "=", "0", ";", "/*", "#", "of", "sections", "of", "this", "size", "*/", "size_t", "u", ";", "/*", "Local", "index", "variable", "*/", "/*", "The", "number", "of", "sections", "of", "this", "node\\'s", "size", "*/", "UINT64DECODE_VAR", "(", "p", ",", "node_count", ",", "sect_cnt_size", ")", ";", "HDassert", "(", "node_count", ")", ";", "/*", "The", "size", "of", "the", "sections", "for", "this", "node", "*/", "UINT64DECODE_VAR", "(", "p", ",", "sect_size", ",", "sinfo", "->", "sect_len_size", ")", ";", "HDassert", "(", "sect_size", ")", ";", "/*", "Loop", "over", "nodes", "of", "this", "size", "*/", "for", "(", "u", "=", "0", ";", "u", "<", "node_count", ";", "u", "++", ")", "{", "H5FS_section_info_t", "*", "new_sect", ";", "/*", "Section", "that", "was", "deserialized", "*/", "haddr_t", "sect_addr", "=", "0", ";", "/*", "Address", "of", "free", "space", "section", "in", "the", "address", "space", "*/", "unsigned", "sect_type", ";", "/*", "Type", "of", "free", "space", "section", "*/", "unsigned", "des_flags", ";", "/*", "Flags", "from", "deserialize", "callback", "*/", "/*", "The", "address", "of", "the", "section", "*/", "UINT64DECODE_VAR", "(", "p", ",", "sect_addr", ",", "sinfo", "->", "sect_off_size", ")", ";", "/*", "The", "type", "of", "this", "section", "*/", "sect_type", "=", "*", "p", "++", ";", "/*", "Call", "\\'deserialize\\'", "callback", "for", "this", "section", "*/", "des_flags", "=", "0", ";", "HDassert", "(", "udata", "->", "fspace", "->", "sect_cls", "[", "sect_type", "]", ".", "deserialize", ")", ";", "if", "(", "NULL", "==", "(", "new_sect", "=", "(", "*", "udata", "->", "fspace", "->", "sect_cls", "[", "sect_type", "]", ".", "deserialize", ")", "(", "&", "udata", "->", "fspace", "->", "sect_cls", "[", "sect_type", "]", ",", "udata", "->", "dxpl_id", ",", "p", ",", "sect_addr", ",", "sect_size", ",", "&", "des_flags", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTDECODE", ",", "NULL", ",", "\"can\\'t", "deserialize", "section\"", ")", "/*", "Update", "offset", "in", "serialization", "buffer", "*/", "p", "+=", "udata", "->", "fspace", "->", "sect_cls", "[", "sect_type", "]", ".", "serial_size", ";", "/*", "Insert", "section", "in", "free", "space", "manager,", "unless", "requested", "not", "to", "*/", "if", "(", "!", "(", "des_flags", "&", "H5FS_DESERIALIZE_NO_ADD", ")", ")", "if", "(", "H5FS_sect_add", "(", "udata", "->", "f", ",", "udata", "->", "dxpl_id", ",", "udata", "->", "fspace", ",", "new_sect", ",", "H5FS_ADD_DESERIALIZING", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTINSERT", ",", "NULL", ",", "\"can\\'t", "add", "section", "to", "free", "space", "manager\"", ")", "}", "/*", "end", "for", "*/", "}", "while", "(", "p", "<", "(", "(", "buf", "+", "old_sect_size", ")", "-", "H5FS_SIZEOF_CHKSUM", ")", ")", ";", "/*", "Sanity", "check", "*/", "HDassert", "(", "(", "size_t", ")", "(", "p", "-", "buf", ")", "==", "(", "old_sect_size", "-", "H5FS_SIZEOF_CHKSUM", ")", ")", ";", "HDassert", "(", "old_sect_size", "==", "udata", "->", "fspace", "->", "sect_size", ")", ";", "HDassert", "(", "old_tot_sect_count", "==", "udata", "->", "fspace", "->", "tot_sect_count", ")", ";", "HDassert", "(", "old_serial_sect_count", "==", "udata", "->", "fspace", "->", "serial_sect_count", ")", ";", "HDassert", "(", "old_ghost_sect_count", "==", "udata", "->", "fspace", "->", "ghost_sect_count", ")", ";", "HDassert", "(", "old_tot_space", "==", "udata", "->", "fspace", "->", "tot_space", ")", ";", "}", "/*", "end", "if", "*/", "/*", "Compute", "checksum", "on", "indirect", "block", "*/", "computed_chksum", "=", "H5_checksum_metadata", "(", "buf", ",", "(", "size_t", ")", "(", "p", "-", "(", "const", "uint8_t", "*", ")", "buf", ")", ",", "0", ")", ";", "/*", "Metadata", "checksum", "*/", "UINT32DECODE", "(", "p", ",", "stored_chksum", ")", ";", "/*", "Verify", "checksum", "*/", "if", "(", "stored_chksum", "!=", "computed_chksum", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_BADVALUE", ",", "NULL", ",", "\"incorrect", "metadata", "checksum", "for", "fractal", "heap", "indirect", "block\"", ")", "/*", "Sanity", "check", "*/", "HDassert", "(", "(", "size_t", ")", "(", "p", "-", "(", "const", "uint8_t", "*", ")", "buf", ")", "==", "old_sect_size", ")", ";", "/*", "Set", "return", "value", "*/", "ret_value", "=", "sinfo", ";", "done", ":", "if", "(", "buf", ")", "buf", "=", "H5FL_BLK_FREE", "(", "sect_block", ",", "buf", ")", ";", "if", "(", "!", "ret_value", "&&", "sinfo", ")", "if", "(", "H5FS_sinfo_dest", "(", "sinfo", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "NULL", ",", "\"unable", "to", "destroy", "free", "space", "info\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Loads", "a", "free", "space", "manager", "header", "from", "the", "disk" ]

[ "'static", "H5FS_t", "*", "H5FS_cache_hdr_load", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "haddr_t", "addr", ",", "void", "*", "_udata", ")", "{", "H5FS_t", "*", "fspace", "=", "NULL", ";", "/*", "Free", "space", "header", "info", "*/", "H5FS_hdr_cache_ud_t", "*", "udata", "=", "(", "H5FS_hdr_cache_ud_t", "*", ")", "_udata", ";", "/*", "user", "data", "for", "callback", "*/", "H5WB_t", "*", "wb", "=", "NULL", ";", "/*", "Wrapped", "buffer", "for", "header", "data", "*/", "uint8_t", "hdr_buf", "[", "H5FS_HDR_BUF_SIZE", "]", ";", "/*", "Buffer", "for", "header", "*/", "uint8_t", "*", "hdr", ";", "/*", "Pointer", "to", "header", "buffer", "*/", "const", "uint8_t", "*", "p", ";", "/*", "Pointer", "into", "raw", "data", "buffer", "*/", "uint32_t", "stored_chksum", ";", "/*", "Stored", "metadata", "checksum", "value", "*/", "uint32_t", "computed_chksum", ";", "/*", "Computed", "metadata", "checksum", "value", "*/", "unsigned", "nclasses", ";", "/*", "Number", "of", "section", "classes", "*/", "H5FS_t", "*", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "udata", ")", ";", "/*", "Allocate", "a", "new", "free", "space", "manager", "*/", "if", "(", "NULL", "==", "(", "fspace", "=", "H5FS_new", "(", "udata", "->", "f", ",", "udata", "->", "nclasses", ",", "udata", "->", "classes", ",", "udata", "->", "cls_init_udata", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "NULL", ",", "\"memory", "allocation", "failed\"", ")", "/*", "Set", "free", "space", "manager\\'s", "internal", "information", "*/", "fspace", "->", "addr", "=", "udata", "->", "addr", ";", "/*", "Wrap", "the", "local", "buffer", "for", "serialized", "header", "info", "*/", "if", "(", "NULL", "==", "(", "wb", "=", "H5WB_wrap", "(", "hdr_buf", ",", "sizeof", "(", "hdr_buf", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTINIT", ",", "NULL", ",", "\"can\\'t", "wrap", "buffer\"", ")", "/*", "Get", "a", "pointer", "to", "a", "buffer", "that\\'s", "large", "enough", "for", "header", "*/", "if", "(", "NULL", "==", "(", "hdr", "=", "(", "uint8_t", "*", ")", "H5WB_actual", "(", "wb", ",", "fspace", "->", "hdr_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_NOSPACE", ",", "NULL", ",", "\"can\\'t", "get", "actual", "buffer\"", ")", "/*", "Read", "header", "from", "disk", "*/", "if", "(", "H5F_block_read", "(", "f", ",", "H5FD_MEM_FSPACE_HDR", ",", "addr", ",", "fspace", "->", "hdr_size", ",", "dxpl_id", ",", "hdr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_READERROR", ",", "NULL", ",", "\"can\\'t", "read", "free", "space", "header\"", ")", "p", "=", "hdr", ";", "/*", "Magic", "number", "*/", "if", "(", "HDmemcmp", "(", "p", ",", "H5FS_HDR_MAGIC", ",", "(", "size_t", ")", "H5_SIZEOF_MAGIC", ")", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"wrong", "free", "space", "header", "signature\"", ")", "p", "+=", "H5_SIZEOF_MAGIC", ";", "/*", "Version", "*/", "if", "(", "*", "p", "++", "!=", "H5FS_HDR_VERSION", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"wrong", "free", "space", "header", "version\"", ")", "/*", "Client", "ID", "*/", "fspace", "->", "client", "=", "(", "H5FS_client_t", ")", "*", "p", "++", ";", "if", "(", "fspace", "->", "client", ">=", "H5FS_NUM_CLIENT_ID", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"unknown", "client", "ID", "in", "free", "space", "header\"", ")", "/*", "Total", "space", "tracked", "*/", "H5F_DECODE_LENGTH", "(", "udata", "->", "f", ",", "p", ",", "fspace", "->", "tot_space", ")", ";", "/*", "Total", "#", "of", "free", "space", "sections", "tracked", "*/", "H5F_DECODE_LENGTH", "(", "udata", "->", "f", ",", "p", ",", "fspace", "->", "tot_sect_count", ")", ";", "/*", "#", "of", "serializable", "free", "space", "sections", "tracked", "*/", "H5F_DECODE_LENGTH", "(", "udata", "->", "f", ",", "p", ",", "fspace", "->", "serial_sect_count", ")", ";", "/*", "#", "of", "ghost", "free", "space", "sections", "tracked", "*/", "H5F_DECODE_LENGTH", "(", "udata", "->", "f", ",", "p", ",", "fspace", "->", "ghost_sect_count", ")", ";", "/*", "#", "of", "section", "classes", "*/", "/*", "(only", "check", "if", "we", "actually", "have", "some", "classes)", "*/", "UINT16DECODE", "(", "p", ",", "nclasses", ")", ";", "if", "(", "fspace", "->", "nclasses", ">", "0", "&&", "fspace", "->", "nclasses", "!=", "nclasses", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"section", "class", "count", "mismatch\"", ")", "/*", "Shrink", "percent", "*/", "UINT16DECODE", "(", "p", ",", "fspace", "->", "shrink_percent", ")", ";", "/*", "Expand", "percent", "*/", "UINT16DECODE", "(", "p", ",", "fspace", "->", "expand_percent", ")", ";", "/*", "Size", "of", "address", "space", "free", "space", "sections", "are", "within", "(log2", "of", "actual", "value)", "*/", "UINT16DECODE", "(", "p", ",", "fspace", "->", "max_sect_addr", ")", ";", "/*", "Max.", "size", "of", "section", "to", "track", "*/", "H5F_DECODE_LENGTH", "(", "udata", "->", "f", ",", "p", ",", "fspace", "->", "max_sect_size", ")", ";", "/*", "Address", "of", "serialized", "free", "space", "sections", "*/", "H5F_addr_decode", "(", "udata", "->", "f", ",", "&", "p", ",", "&", "fspace", "->", "sect_addr", ")", ";", "/*", "Size", "of", "serialized", "free", "space", "sections", "*/", "H5F_DECODE_LENGTH", "(", "udata", "->", "f", ",", "p", ",", "fspace", "->", "sect_size", ")", ";", "/*", "Allocated", "size", "of", "serialized", "free", "space", "sections", "*/", "H5F_DECODE_LENGTH", "(", "udata", "->", "f", ",", "p", ",", "fspace", "->", "alloc_sect_size", ")", ";", "/*", "Compute", "checksum", "on", "indirect", "block", "*/", "computed_chksum", "=", "H5_checksum_metadata", "(", "hdr", ",", "(", "size_t", ")", "(", "p", "-", "(", "const", "uint8_t", "*", ")", "hdr", ")", ",", "0", ")", ";", "/*", "Metadata", "checksum", "*/", "UINT32DECODE", "(", "p", ",", "stored_chksum", ")", ";", "HDassert", "(", "(", "size_t", ")", "(", "p", "-", "(", "const", "uint8_t", "*", ")", "hdr", ")", "==", "fspace", "->", "hdr_size", ")", ";", "/*", "Verify", "checksum", "*/", "if", "(", "stored_chksum", "!=", "computed_chksum", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_BADVALUE", ",", "NULL", ",", "\"incorrect", "metadata", "checksum", "for", "fractal", "heap", "indirect", "block\"", ")", "/*", "Set", "return", "value", "*/", "ret_value", "=", "fspace", ";", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "wb", "&&", "H5WB_unwrap", "(", "wb", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_FSPACE", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"can\\'t", "close", "wrapped", "buffer\"", ")", "if", "(", "!", "ret_value", "&&", "fspace", ")", "if", "(", "H5FS_hdr_dest", "(", "fspace", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "NULL", ",", "\"unable", "to", "destroy", "free", "space", "header\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Skip", "list", "iterator", "callback", "to", "serialize", "free", "space", "sections", "in", "a", "bin" ]

[ "'static", "herr_t", "H5FS_sinfo_serialize_node_cb", "(", "void", "*", "_item", ",", "void", "H5_ATTR_UNUSED", "*", "key", ",", "void", "*", "_udata", ")", "{", "H5FS_node_t", "*", "fspace_node", "=", "(", "H5FS_node_t", "*", ")", "_item", ";", "/*", "Free", "space", "size", "node", "to", "work", "on", "*/", "H5FS_iter_ud_t", "*", "udata", "=", "(", "H5FS_iter_ud_t", "*", ")", "_udata", ";", "/*", "Callback", "info", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "Check", "arguments.", "*/", "HDassert", "(", "fspace_node", ")", ";", "HDassert", "(", "udata", "->", "sinfo", ")", ";", "HDassert", "(", "udata", "->", "p", ")", ";", "/*", "Check", "if", "this", "node", "has", "any", "serializable", "sections", "*/", "if", "(", "fspace_node", "->", "serial_count", ">", "0", ")", "{", "/*", "The", "number", "of", "serializable", "sections", "of", "this", "node\\'s", "size", "*/", "UINT64ENCODE_VAR", "(", "*", "udata", "->", "p", ",", "fspace_node", "->", "serial_count", ",", "udata", "->", "sect_cnt_size", ")", ";", "/*", "The", "size", "of", "the", "sections", "for", "this", "node", "*/", "UINT64ENCODE_VAR", "(", "*", "udata", "->", "p", ",", "fspace_node", "->", "sect_size", ",", "udata", "->", "sinfo", "->", "sect_len_size", ")", ";", "/*", "Iterate", "through", "all", "the", "sections", "of", "this", "size", "*/", "HDassert", "(", "fspace_node", "->", "sect_list", ")", ";", "if", "(", "H5SL_iterate", "(", "fspace_node", "->", "sect_list", ",", "H5FS_sinfo_serialize_sect_cb", ",", "udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_BADITER", ",", "FAIL", ",", "\"can\\'t", "iterate", "over", "section", "nodes\"", ")", "}", "/*", "end", "if", "*/", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Destroys", "a", "free", "space", "section", "info", "in", "memory" ]

[ "'static", "herr_t", "H5FS_cache_sinfo_dest", "(", "H5F_t", "*", "f", ",", "H5FS_sinfo_t", "*", "sinfo", ")", "{", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "Check", "arguments", "*/", "HDassert", "(", "sinfo", ")", ";", "/*", "If", "we\\'re", "going", "to", "free", "the", "space", "on", "disk,", "the", "address", "must", "be", "valid", "*/", "HDassert", "(", "!", "sinfo", "->", "cache_info", ".", "free_file_space_on_destroy", "||", "H5F_addr_defined", "(", "sinfo", "->", "cache_info", ".", "addr", ")", ")", ";", "/*", "Check", "for", "freeing", "file", "space", "for", "free", "space", "section", "info", "*/", "if", "(", "sinfo", "->", "cache_info", ".", "free_file_space_on_destroy", ")", "{", "/*", "Sanity", "check", "*/", "HDassert", "(", "sinfo", "->", "fspace", "->", "alloc_sect_size", ">", "0", ")", ";", "/*", "Release", "the", "space", "on", "disk", "*/", "/*", "(XXX:", "Nasty", "usage", "of", "internal", "DXPL", "value!", "-QAK)", "*/", "if", "(", "H5MF_xfree", "(", "f", ",", "H5FD_MEM_FSPACE_SINFO", ",", "H5AC_dxpl_id", ",", "sinfo", "->", "cache_info", ".", "addr", ",", "(", "hsize_t", ")", "sinfo", "->", "fspace", "->", "alloc_sect_size", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "free", "free", "space", "section", "info\"", ")", "}", "/*", "end", "if", "*/", "/*", "Destroy", "free", "space", "info", "*/", "if", "(", "H5FS_sinfo_dest", "(", "sinfo", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "destroy", "free", "space", "info\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Mark", "a", "free", "space", "header", "in", "memory", "as", "nondirty" ]

[ "'static", "herr_t", "H5FS_cache_hdr_clear", "(", "H5F_t", "*", "f", ",", "H5FS_t", "*", "fspace", ",", "hbool_t", "destroy", ")", "{", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "*", "Check", "arguments.", "*/", "HDassert", "(", "fspace", ")", ";", "/*", "Reset", "the", "dirty", "flag.", "*/", "fspace", "->", "cache_info", ".", "is_dirty", "=", "FALSE", ";", "if", "(", "destroy", ")", "if", "(", "H5FS_cache_hdr_dest", "(", "f", ",", "fspace", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "destroy", "free", "space", "header\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Skip", "list", "iterator", "callback", "to", "serialize", "free", "space", "sections", "of", "a", "particular", "size" ]

[ "'static", "herr_t", "H5FS_sinfo_serialize_sect_cb", "(", "void", "*", "_item", ",", "void", "H5_ATTR_UNUSED", "*", "key", ",", "void", "*", "_udata", ")", "{", "H5FS_section_class_t", "*", "sect_cls", ";", "/*", "Class", "of", "section", "*/", "H5FS_section_info_t", "*", "sect", "=", "(", "H5FS_section_info_t", "*", ")", "_item", ";", "/*", "Free", "space", "section", "to", "work", "on", "*/", "H5FS_iter_ud_t", "*", "udata", "=", "(", "H5FS_iter_ud_t", "*", ")", "_udata", ";", "/*", "Callback", "info", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "Check", "arguments.", "*/", "HDassert", "(", "sect", ")", ";", "HDassert", "(", "udata", "->", "sinfo", ")", ";", "HDassert", "(", "udata", "->", "p", ")", ";", "/*", "Get", "section\\'s", "class", "*/", "sect_cls", "=", "&", "udata", "->", "sinfo", "->", "fspace", "->", "sect_cls", "[", "sect", "->", "type", "]", ";", "/*", "Check", "if", "this", "section", "should", "be", "serialized", "(i.e.", "is", "not", "a", "ghost", "section)", "*/", "if", "(", "!", "(", "sect_cls", "->", "flags", "&", "H5FS_CLS_GHOST_OBJ", ")", ")", "{", "/*", "The", "address", "of", "the", "section", "*/", "UINT64ENCODE_VAR", "(", "*", "udata", "->", "p", ",", "sect", "->", "addr", ",", "udata", "->", "sinfo", "->", "sect_off_size", ")", ";", "/*", "The", "type", "of", "this", "section", "*/", "*", "(", "*", "udata", "->", "p", ")", "++", "=", "(", "uint8_t", ")", "sect", "->", "type", ";", "/*", "Call", "\\'serialize\\'", "callback", "for", "this", "section", "*/", "if", "(", "sect_cls", "->", "serialize", ")", "{", "if", "(", "(", "*", "sect_cls", "->", "serialize", ")", "(", "sect_cls", ",", "sect", ",", "*", "udata", "->", "p", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_FSPACE", ",", "H5E_CANTSERIALIZE", ",", "FAIL", ",", "\"can\\'t", "synchronize", "section\"", ")", "/*", "Update", "offset", "in", "serialization", "buffer", "*/", "(", "*", "udata", "->", "p", ")", "+=", "sect_cls", "->", "serial_size", ";", "}", "/*", "end", "if", "*/", "else", "HDassert", "(", "sect_cls", "->", "serial_size", "==", "0", ")", ";", "}", "/*", "end", "if", "*/", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "used", "by", "hermitian", "transpose" ]

[ "'PETSC_INTERN", "PetscErrorCode", "MatProductSetFromOptions_Transpose", "(", "Mat", "D", ")", "{", "Mat", "A", ",", "<type", "ref=\"prev\"/>", "B", ",", "<type", "ref=\"prev\"/>", "C", ",", "<type", "ref=\"prev\"/>", "Ain", ",", "<type", "ref=\"prev\"/>", "Bin", ",", "<type", "ref=\"prev\"/>", "Cin", ";", "PetscBool", "Aistrans", ",", "<type", "ref=\"prev\"/>", "Bistrans", ",", "<type", "ref=\"prev\"/>", "Cistrans", ";", "PetscInt", "Atrans", ",", "<type", "ref=\"prev\"/>", "Btrans", ",", "<type", "ref=\"prev\"/>", "Ctrans", ";", "MatProductType", "ptype", ";", "PetscErrorCode", "ierr", ";", "PetscFunctionBegin", ";", "MatCheckProduct", "(", "D", ",", "1", ")", ";", "A", "=", "D", "->", "product", "->", "A", ";", "B", "=", "D", "->", "product", "->", "B", ";", "C", "=", "D", "->", "product", "->", "C", ";", "ierr", "=", "PetscObjectTypeCompare", "(", "(", "PetscObject", ")", "A", ",", "MATTRANSPOSEMAT", ",", "&", "Aistrans", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "ierr", "=", "PetscObjectTypeCompare", "(", "(", "PetscObject", ")", "B", ",", "MATTRANSPOSEMAT", ",", "&", "Bistrans", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "ierr", "=", "PetscObjectTypeCompare", "(", "(", "PetscObject", ")", "C", ",", "MATTRANSPOSEMAT", ",", "&", "Cistrans", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "if", "(", "!", "Aistrans", "&&", "!", "Bistrans", "&&", "!", "Cistrans", ")", "SETERRQ", "(", "PetscObjectComm", "(", "(", "PetscObject", ")", "D", ")", ",", "PETSC_ERR_PLIB", ",", "\"This", "should", "not", "happen\"", ")", ";", "Atrans", "=", "0", ";", "Ain", "=", "A", ";", "while", "(", "Aistrans", ")", "{", "Atrans", "++", ";", "ierr", "=", "MatTransposeGetMat", "(", "Ain", ",", "&", "Ain", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "ierr", "=", "PetscObjectTypeCompare", "(", "(", "PetscObject", ")", "Ain", ",", "MATTRANSPOSEMAT", ",", "&", "Aistrans", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "}", "Btrans", "=", "0", ";", "Bin", "=", "B", ";", "while", "(", "Bistrans", ")", "{", "Btrans", "++", ";", "ierr", "=", "MatTransposeGetMat", "(", "Bin", ",", "&", "Bin", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "ierr", "=", "PetscObjectTypeCompare", "(", "(", "PetscObject", ")", "Bin", ",", "MATTRANSPOSEMAT", ",", "&", "Bistrans", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "}", "Ctrans", "=", "0", ";", "Cin", "=", "C", ";", "while", "(", "Cistrans", ")", "{", "Ctrans", "++", ";", "ierr", "=", "MatTransposeGetMat", "(", "Cin", ",", "&", "Cin", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "ierr", "=", "PetscObjectTypeCompare", "(", "(", "PetscObject", ")", "Cin", ",", "MATTRANSPOSEMAT", ",", "&", "Cistrans", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "}", "Atrans", "=", "Atrans", "%", "2", ";", "Btrans", "=", "Btrans", "%", "2", ";", "Ctrans", "=", "Ctrans", "%", "2", ";", "ptype", "=", "D", "->", "product", "->", "type", ";", "/*", "same", "product", "type", "by", "default", "*/", "if", "(", "Ain", "->", "symmetric", ")", "Atrans", "=", "0", ";", "if", "(", "Bin", "->", "symmetric", ")", "Btrans", "=", "0", ";", "if", "(", "Cin", "&&", "Cin", "->", "symmetric", ")", "Ctrans", "=", "0", ";", "if", "(", "Atrans", "||", "Btrans", "||", "Ctrans", ")", "{", "ptype", "=", "MATPRODUCT_UNSPECIFIED", ";", "switch", "(", "D", "->", "product", "->", "type", ")", "{", "case", "MATPRODUCT_AB", ":", "if", "(", "Atrans", "&&", "Btrans", ")", "{", "/*", "At", "*", "Bt", "we", "do", "not", "have", "support", "for", "this", "*/", "/*", "TODO", "custom", "implementation", "?", "*/", "}", "<if", "type=\"elseif\">", "else", "if", "(", "Atrans", ")", "{", "/*", "At", "*", "B", "*/", "ptype", "=", "MATPRODUCT_AtB", ";", "}", "else", "{", "/*", "A", "*", "Bt", "*/", "ptype", "=", "MATPRODUCT_ABt", ";", "}", "break;", "case", "MATPRODUCT_AtB", ":", "if", "(", "Atrans", "&&", "Btrans", ")", "{", "/*", "A", "*", "Bt", "*/", "ptype", "=", "MATPRODUCT_ABt", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "Atrans", ")", "{", "/*", "A", "*", "B", "*/", "ptype", "=", "MATPRODUCT_AB", ";", "}", "else", "{", "/*", "At", "*", "Bt", "we", "do", "not", "have", "support", "for", "this", "*/", "/*", "TODO", "custom", "implementation", "?", "*/", "}", "break;", "case", "MATPRODUCT_ABt", ":", "if", "(", "Atrans", "&&", "Btrans", ")", "{", "/*", "At", "*", "B", "*/", "ptype", "=", "MATPRODUCT_AtB", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "Atrans", ")", "{", "/*", "At", "*", "Bt", "we", "do", "not", "have", "support", "for", "this", "*/", "/*", "TODO", "custom", "implementation", "?", "*/", "}", "else", "{", "/*", "A", "*", "B", "*/", "ptype", "=", "MATPRODUCT_AB", ";", "}", "break;", "case", "MATPRODUCT_PtAP", ":", "if", "(", "Atrans", ")", "{", "/*", "PtAtP", "*/", "/*", "TODO", "custom", "implementation", "?", "*/", "}", "else", "{", "/*", "RARt", "*/", "ptype", "=", "MATPRODUCT_RARt", ";", "}", "break;", "case", "MATPRODUCT_RARt", ":", "if", "(", "Atrans", ")", "{", "/*", "RAtRt", "*/", "/*", "TODO", "custom", "implementation", "?", "*/", "}", "else", "{", "/*", "PtAP", "*/", "ptype", "=", "MATPRODUCT_PtAP", ";", "}", "break;", "case", "MATPRODUCT_ABC", ":", "/*", "TODO", "custom", "implementation", "?", "*/", "break;", "default:", "SETERRQ1", "(", "PetscObjectComm", "(", "(", "PetscObject", ")", "D", ")", ",", "PETSC_ERR_SUP", ",", "\"ProductType", "%s", "is", "not", "supported\"", ",", "MatProductTypes", "[", "D", "->", "product", "->", "type", "]", ")", ";", "}", "}", "ierr", "=", "MatProductReplaceMats", "(", "Ain", ",", "Bin", ",", "Cin", ",", "D", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "ierr", "=", "MatProductSetType", "(", "D", ",", "ptype", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "ierr", "=", "MatProductSetFromOptions", "(", "D", ")", ";", "CHKERRQ", "(", "ierr", ")", ";", "PetscFunctionReturn", "(", "0", ")", ";", "}'" ]

[ "set", "up", "to", "process", "the", "scan", "label" ]

[ "'void", "InitScanLabelInfo", "(", "ScanState", "*", "node", ")", "{", "Oid", "relid", ";", "HeapTuple", "labtup", ";", "AssertArg", "(", "node", "!=", "NULL", ")", ";", "if", "(", "node", "->", "ss_currentRelation", "==", "NULL", ")", "return", ";", "relid", "=", "node", "->", "ss_currentRelation", "->", "rd_id", ";", "labtup", "=", "SearchSysCache1", "(", "LABELRELID", ",", "ObjectIdGetDatum", "(", "relid", ")", ")", ";", "if", "(", "HeapTupleIsValid", "(", "labtup", ")", ")", "{", "Form_ag_label", "label", "=", "(", "Form_ag_label", ")", "GETSTRUCT", "(", "labtup", ")", ";", "if", "(", "label", "->", "labkind", "==", "LABEL_KIND_VERTEX", ")", "{", "node", "->", "ss_isLabel", "=", "true", ";", "node", "->", "ss_labid", "=", "(", "uint16", ")", "label", "->", "labid", ";", "}", "ReleaseSysCache", "(", "labtup", ")", ";", "}", "}'" ]

[ "Implement", "a", "simple", "move", "system" ]

[ "'void", "Move", "(", "ecs_rows_t", "*", "rows", ")", "{", "/*", "Get", "the", "two", "columns", "from", "the", "system", "signature", "*/", "ECS_COLUMN", "(", "rows", ",", "Position", ",", "p", ",", "1", ")", ";", "ECS_COLUMN", "(", "rows", ",", "Force", ",", "v", ",", "2", ")", ";", "ECS_COLUMN", "(", "rows", ",", "Mass", ",", "m", ",", "3", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "rows", "->", "count", ";", "i", "++", ")", "{", "if", "(", "ecs_is_shared", "(", "rows", ",", "3", ")", ")", "{", "p", "[", "i", "]", ".", "x", "+=", "v", "[", "i", "]", ".", "x", "/", "m", "[", "0", "]", ";", "p", "[", "i", "]", ".", "y", "+=", "v", "[", "i", "]", ".", "y", "/", "m", "[", "0", "]", ";", "}", "else", "{", "p", "[", "i", "]", ".", "x", "+=", "v", "[", "i", "]", ".", "x", "/", "m", "[", "i", "]", ";", "p", "[", "i", "]", ".", "y", "+=", "v", "[", "i", "]", ".", "y", "/", "m", "[", "i", "]", ";", "}", "/*", "Print", "something", "to", "the", "console", "so", "we", "can", "see", "the", "system", "is", "being", "*", "invoked", "*/", "printf", "(", "\"%s", "moved", "to", "{.x", "=", "%f,", ".y", "=", "%f}\\\"", ",", "ecs_get_id", "(", "rows", "->", "world", ",", "rows", "->", "entities", "[", "i", "]", ")", ",", "p", "[", "i", "]", ".", "x", ",", "p", "[", "i", "]", ".", "y", ")", ";", "}", "}'" ]

[ "Returns", "the", "native", "floatt", "type", "of", "a", "datatype" ]

[ "'static", "H5T_t", "*", "H5T__get_native_float", "(", "size_t", "size", ",", "H5T_direction_t", "direction", ",", "size_t", "*", "struct_align", ",", "size_t", "*", "offset", ",", "size_t", "*", "comp_size", ")", "{", "H5T_t", "*", "dt", "=", "NULL", ";", "/*", "Appropriate", "native", "datatype", "to", "copy", "*/", "hid_t", "tid", "=", "(", "-", "1", ")", ";", "/*", "Datatype", "ID", "of", "appropriate", "native", "datatype", "*/", "size_t", "align", "=", "0", ";", "/*", "Alignment", "necessary", "for", "native", "datatype", "*/", "size_t", "native_size", "=", "0", ";", "/*", "Datatype", "size", "of", "the", "native", "type", "*/", "enum", "match_type", "{", "/*", "The", "different", "kinds", "of", "floating", "point", "types", "we", "can", "match", "*/", "H5T_NATIVE_FLOAT_MATCH_FLOAT", ",", "H5T_NATIVE_FLOAT_MATCH_DOUBLE", ",", "#", "if", "H5_SIZEOF_LONG_DOUBLE", "!=", "0", "H5T_NATIVE_FLOAT_MATCH_LDOUBLE", ",", "#", "endif", "H5T_NATIVE_FLOAT_MATCH_UNKNOWN", "}", "match", "=", "H5T_NATIVE_FLOAT_MATCH_UNKNOWN", ";", "H5T_t", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "HDassert", "(", "size", ">", "0", ")", ";", "if", "(", "direction", "==", "H5T_DIR_DEFAULT", "||", "direction", "==", "H5T_DIR_ASCEND", ")", "{", "if", "(", "size", "<=", "sizeof", "(", "float", ")", ")", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_FLOAT", ";", "native_size", "=", "sizeof", "(", "float", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "size", "<=", "sizeof", "(", "double", ")", ")", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_DOUBLE", ";", "native_size", "=", "sizeof", "(", "double", ")", ";", "}", "#", "if", "H5_SIZEOF_LONG_DOUBLE", "!=", "0", "<if", "type=\"elseif\">", "else", "if", "(", "size", "<=", "sizeof", "(", "long", "double", ")", ")", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_LDOUBLE", ";", "native_size", "=", "sizeof", "(", "long", "double", ")", ";", "}", "#", "endif", "else", "{", "/*", "If", "not", "match,", "return", "the", "biggest", "datatype", "*/", "#", "if", "H5_SIZEOF_LONG_DOUBLE", "!=", "0", "match", "=", "H5T_NATIVE_FLOAT_MATCH_LDOUBLE", ";", "native_size", "=", "sizeof", "(", "long", "double", ")", ";", "#", "else", "match", "=", "H5T_NATIVE_FLOAT_MATCH_DOUBLE", ";", "native_size", "=", "sizeof", "(", "double", ")", ";", "#", "endif", "}", "}", "else", "{", "#", "if", "H5_SIZEOF_LONG_DOUBLE", "!=", "0", "if", "(", "size", ">", "sizeof", "(", "double", ")", ")", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_LDOUBLE", ";", "native_size", "=", "sizeof", "(", "long", "double", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "size", ">", "sizeof", "(", "float", ")", ")", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_DOUBLE", ";", "native_size", "=", "sizeof", "(", "double", ")", ";", "}", "else", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_FLOAT", ";", "native_size", "=", "sizeof", "(", "float", ")", ";", "}", "#", "else", "if", "(", "size", ">", "sizeof", "(", "float", ")", ")", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_DOUBLE", ";", "native_size", "=", "sizeof", "(", "double", ")", ";", "}", "else", "{", "match", "=", "H5T_NATIVE_FLOAT_MATCH_FLOAT", ";", "native_size", "=", "sizeof", "(", "float", ")", ";", "}", "#", "endif", "}", "/*", "Set", "the", "appropriate", "native", "floating", "point", "information", "*/", "switch", "(", "match", ")", "{", "case", "H5T_NATIVE_FLOAT_MATCH_FLOAT", ":", "tid", "=", "H5T_NATIVE_FLOAT", ";", "align", "=", "H5T_NATIVE_FLOAT_COMP_ALIGN_g", ";", "break;", "case", "H5T_NATIVE_FLOAT_MATCH_DOUBLE", ":", "tid", "=", "H5T_NATIVE_DOUBLE", ";", "align", "=", "H5T_NATIVE_DOUBLE_COMP_ALIGN_g", ";", "break;", "#", "if", "H5_SIZEOF_LONG_DOUBLE", "!=", "0", "case", "H5T_NATIVE_FLOAT_MATCH_LDOUBLE", ":", "tid", "=", "H5T_NATIVE_LDOUBLE", ";", "align", "=", "H5T_NATIVE_LDOUBLE_COMP_ALIGN_g", ";", "break;", "#", "endif", "case", "H5T_NATIVE_FLOAT_MATCH_UNKNOWN", ":", "default:", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"Unknown", "native", "floating-point", "match\"", ")", "}", "/*", "end", "switch", "*/", "/*", "Create", "new", "native", "type", "*/", "HDassert", "(", "tid", ">=", "0", ")", ";", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object", "(", "tid", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "data", "type\"", ")", "if", "(", "(", "ret_value", "=", "H5T_copy", "(", "dt", ",", "H5T_COPY_TRANSIENT", ")", ")", "==", "NULL", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "retrieve", "float", "type\"", ")", "/*", "compute", "offset", "of", "compound", "type", "member.", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "native_size", ",", "(", "size_t", ")", "1", ",", "align", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Returns", "the", "native", "type", "of", "a", "datatype" ]

[ "'static", "H5T_t", "*", "H5T__get_native_type", "(", "H5T_t", "*", "dtype", ",", "H5T_direction_t", "direction", ",", "size_t", "*", "struct_align", ",", "size_t", "*", "offset", ",", "size_t", "*", "comp_size", ")", "{", "H5T_t", "*", "super_type", ";", "/*", "Super", "type", "of", "VL,", "array", "and", "enum", "datatypes", "*/", "H5T_t", "*", "nat_super_type", ";", "/*", "Native", "form", "of", "VL,", "array", "&", "enum", "super", "datatype", "*/", "H5T_t", "*", "new_type", "=", "NULL", ";", "/*", "New", "native", "datatype", "*/", "H5T_t", "*", "memb_type", "=", "NULL", ";", "/*", "Datatype", "of", "member", "*/", "H5T_t", "*", "*", "memb_list", "=", "NULL", ";", "/*", "List", "of", "compound", "member", "IDs", "*/", "size_t", "*", "memb_offset", "=", "NULL", ";", "/*", "List", "of", "member", "offsets", "in", "compound", "type,", "including", "member", "size", "and", "alignment", "*/", "char", "*", "*", "comp_mname", "=", "NULL", ";", "/*", "List", "of", "member", "names", "in", "compound", "type", "*/", "char", "*", "memb_name", "=", "NULL", ";", "/*", "Enum\\'s", "member", "name", "*/", "void", "*", "memb_value", "=", "NULL", ";", "/*", "Enum\\'s", "member", "value", "*/", "void", "*", "tmp_memb_value", "=", "NULL", ";", "/*", "Enum\\'s", "member", "value", "*/", "hsize_t", "*", "dims", "=", "NULL", ";", "/*", "Dimension", "sizes", "for", "array", "*/", "H5T_class_t", "h5_class", ";", "/*", "Class", "of", "datatype", "to", "make", "native", "*/", "size_t", "size", ";", "/*", "Size", "of", "datatype", "to", "make", "native", "*/", "size_t", "prec", ";", "/*", "Precision", "of", "datatype", "to", "make", "native", "*/", "int", "snmemb", ";", "/*", "Number", "of", "members", "in", "compound", "&", "enum", "types", "*/", "unsigned", "nmemb", "=", "0", ";", "/*", "Number", "of", "members", "in", "compound", "&", "enum", "types", "*/", "unsigned", "u", ";", "/*", "Local", "index", "variable", "*/", "H5T_t", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "HDassert", "(", "dtype", ")", ";", "if", "(", "H5T_NO_CLASS", "==", "(", "h5_class", "=", "H5T_get_class", "(", "dtype", ",", "FALSE", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "valid", "class\"", ")", "if", "(", "0", "==", "(", "size", "=", "H5T_get_size", "(", "dtype", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "valid", "size\"", ")", "switch", "(", "h5_class", ")", "{", "case", "H5T_INTEGER", ":", "{", "H5T_sign_t", "sign", ";", "/*", "Signedness", "of", "integer", "type", "*/", "if", "(", "H5T_SGN_ERROR", "==", "(", "sign", "=", "H5T_get_sign", "(", "dtype", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "valid", "signess\"", ")", "prec", "=", "dtype", "->", "shared", "->", "u", ".", "atomic", ".", "prec", ";", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T__get_native_integer", "(", "prec", ",", "sign", ",", "direction", ",", "struct_align", ",", "offset", ",", "comp_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "retrieve", "integer", "type\"", ")", "}", "/*", "end", "case", "*/", "break;", "case", "H5T_FLOAT", ":", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T__get_native_float", "(", "size", ",", "direction", ",", "struct_align", ",", "offset", ",", "comp_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "retrieve", "float", "type\"", ")", "break;", "case", "H5T_STRING", ":", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T_copy", "(", "dtype", ",", "H5T_COPY_TRANSIENT", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "retrieve", "float", "type\"", ")", "if", "(", "H5T_IS_VL_STRING", "(", "dtype", "->", "shared", ")", ")", "{", "/*", "Update", "size,", "offset", "and", "compound", "alignment", "for", "parent.", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "sizeof", "(", "char", "*", ")", ",", "(", "size_t", ")", "1", ",", "H5T_POINTER_COMP_ALIGN_g", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Update", "size,", "offset", "and", "compound", "alignment", "for", "parent.", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "sizeof", "(", "char", ")", ",", "size", ",", "H5T_NATIVE_SCHAR_COMP_ALIGN_g", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "}", "/*", "end", "else", "*/", "break;", "/*", "The", "time", "type", "will", "be", "supported", "in", "the", "future.", "Simply", "return", "\"not", "supported\"", "*", "message", "for", "now.*/", "case", "H5T_TIME", ":", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"time", "type", "is", "not", "supported", "yet\"", ")", "case", "H5T_BITFIELD", ":", "{", "prec", "=", "dtype", "->", "shared", "->", "u", ".", "atomic", ".", "prec", ";", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T__get_native_bitfield", "(", "prec", ",", "direction", ",", "struct_align", ",", "offset", ",", "comp_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "retrieve", "integer", "for", "bitfield", "type\"", ")", "}", "/*", "end", "case", "*/", "break;", "case", "H5T_OPAQUE", ":", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T_copy", "(", "dtype", ",", "H5T_COPY_TRANSIENT", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "retrieve", "float", "type\"", ")", "/*", "Update", "size,", "offset", "and", "compound", "alignment", "for", "parent.", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "sizeof", "(", "char", ")", ",", "size", ",", "H5T_NATIVE_SCHAR_COMP_ALIGN_g", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "break;", "case", "H5T_REFERENCE", ":", "{", "H5T_t", "*", "dt", ";", "/*", "Datatype", "to", "make", "native", "*/", "size_t", "align", ";", "size_t", "ref_size", ";", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T_copy", "(", "dtype", ",", "H5T_COPY_TRANSIENT", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "copy", "reference", "type\"", ")", "/*", "Decide", "if", "the", "data", "type", "is", "object", "reference.", "*/", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_STD_REF_OBJ_g", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "data", "type\"", ")", "/*", "Update", "size,", "offset", "and", "compound", "alignment", "for", "parent.", "*/", "if", "(", "0", "==", "H5T_cmp", "(", "ret_value", ",", "dt", ",", "FALSE", ")", ")", "{", "align", "=", "H5T_HOBJREF_COMP_ALIGN_g", ";", "ref_size", "=", "sizeof", "(", "hobj_ref_t", ")", ";", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Decide", "if", "the", "data", "type", "is", "dataset", "region", "reference.", "*/", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_STD_REF_DSETREG_g", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "data", "type\"", ")", "if", "(", "0", "==", "H5T_cmp", "(", "ret_value", ",", "dt", ",", "FALSE", ")", ")", "{", "align", "=", "H5T_HDSETREGREF_COMP_ALIGN_g", ";", "ref_size", "=", "sizeof", "(", "hdset_reg_ref_t", ")", ";", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Only", "pointers", "to", "underlying", "opaque", "reference", "types", "*/", "align", "=", "H5T_REF_COMP_ALIGN_g", ";", "ref_size", "=", "sizeof", "(", "H5R_ref_t", ")", ";", "}", "/*", "end", "else", "*/", "}", "/*", "end", "else", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "ref_size", ",", "(", "size_t", ")", "1", ",", "align", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "}", "/*", "end", "case", "*/", "break;", "case", "H5T_COMPOUND", ":", "{", "size_t", "children_size", "=", "0", ";", "/*", "Total", "size", "of", "compound", "members", "*/", "size_t", "children_st_align", "=", "0", ";", "/*", "The", "max", "alignment", "among", "compound", "members.", "This\\'ll", "be", "the", "compound", "alignment", "*/", "if", "(", "(", "snmemb", "=", "H5T_get_nmembers", "(", "dtype", ")", ")", "<=", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"compound", "data", "type", "doesn\\'t", "have", "any", "member\"", ")", "H5_CHECKED_ASSIGN", "(", "nmemb", ",", "unsigned", ",", "snmemb", ",", "int", ")", ";", "if", "(", "NULL", "==", "(", "memb_list", "=", "(", "H5T_t", "*", "*", ")", "H5MM_calloc", "(", "nmemb", "*", "sizeof", "(", "H5T_t", "*", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "allocate", "memory\"", ")", "if", "(", "NULL", "==", "(", "memb_offset", "=", "(", "size_t", "*", ")", "H5MM_calloc", "(", "nmemb", "*", "sizeof", "(", "size_t", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "allocate", "memory\"", ")", "if", "(", "NULL", "==", "(", "comp_mname", "=", "(", "char", "*", "*", ")", "H5MM_calloc", "(", "nmemb", "*", "sizeof", "(", "char", "*", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "allocate", "memory\"", ")", "/*", "Construct", "child", "compound", "type", "and", "retrieve", "a", "list", "of", "their", "IDs,", "offsets,", "total", "size,", "and", "alignment", "for", "compound", "type.", "*/", "for", "(", "u", "=", "0", ";", "u", "<", "nmemb", ";", "u", "++", ")", "{", "if", "(", "NULL", "==", "(", "memb_type", "=", "H5T_get_member_type", "(", "dtype", ",", "u", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"member", "type", "retrieval", "failed\"", ")", "if", "(", "NULL", "==", "(", "comp_mname", "[", "u", "]", "=", "H5T__get_member_name", "(", "dtype", ",", "u", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"member", "type", "retrieval", "failed\"", ")", "if", "(", "NULL", "==", "(", "memb_list", "[", "u", "]", "=", "H5T__get_native_type", "(", "memb_type", ",", "direction", ",", "&", "children_st_align", ",", "&", "(", "memb_offset", "[", "u", "]", ")", ",", "&", "children_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"member", "identifier", "retrieval", "failed\"", ")", "if", "(", "H5T_close_real", "(", "memb_type", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "}", "/*", "end", "for", "*/", "/*", "The", "alignment", "for", "whole", "compound", "type", "*/", "if", "(", "children_st_align", "&&", "children_size", "%", "children_st_align", ")", "children_size", "+=", "children_st_align", "-", "(", "children_size", "%", "children_st_align", ")", ";", "/*", "Construct", "new", "compound", "type", "based", "on", "native", "type", "*/", "if", "(", "NULL", "==", "(", "new_type", "=", "H5T__create", "(", "H5T_COMPOUND", ",", "children_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "create", "a", "compound", "type\"", ")", "/*", "Insert", "members", "for", "the", "new", "compound", "type", "*/", "for", "(", "u", "=", "0", ";", "u", "<", "nmemb", ";", "u", "++", ")", "if", "(", "H5T__insert", "(", "new_type", ",", "comp_mname", "[", "u", "]", ",", "memb_offset", "[", "u", "]", ",", "memb_list", "[", "u", "]", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "insert", "member", "to", "compound", "datatype\"", ")", "/*", "Update", "size,", "offset", "and", "compound", "alignment", "for", "parent", "in", "the", "case", "of", "*", "nested", "compound", "type.", "The", "alignment", "for", "a", "compound", "type", "as", "one", "field", "in", "*", "a", "compound", "type", "is", "the", "biggest", "compound", "alignment", "among", "all", "its", "members.", "*", "e.g.", "in", "the", "structure", "*", "typedef", "struct", "s1", "{", "*", "char", "c;", "*", "int", "i;", "*", "s2", "st;", "*", "unsigned", "long", "long", "l;", "*", "}", "s1;", "*", "typedef", "struct", "s2", "{", "*", "short", "c2;", "*", "long", "l2;", "*", "long", "long", "ll2;", "*", "}", "s2;", "*", "The", "alignment", "for", "ST", "in", "S1", "is", "the", "biggest", "structure", "alignment", "of", "all", "the", "*", "members", "of", "S2,", "which", "is", "probably", "the", "LL2", "of", "\\'long", "long\\'.", "-SLU", "2010/4/28", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "children_size", ",", "(", "size_t", ")", "1", ",", "children_st_align", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "/*", "Close", "member", "data", "type", "*/", "for", "(", "u", "=", "0", ";", "u", "<", "nmemb", ";", "u", "++", ")", "{", "if", "(", "H5T_close_real", "(", "memb_list", "[", "u", "]", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "/*", "Free", "member", "names", "in", "list", "*/", "comp_mname", "[", "u", "]", "=", "(", "char", "*", ")", "H5MM_xfree", "(", "comp_mname", "[", "u", "]", ")", ";", "}", "/*", "end", "for", "*/", "/*", "Free", "lists", "for", "members", "*/", "memb_list", "=", "(", "H5T_t", "*", "*", ")", "H5MM_xfree", "(", "memb_list", ")", ";", "memb_offset", "=", "(", "size_t", "*", ")", "H5MM_xfree", "(", "memb_offset", ")", ";", "comp_mname", "=", "(", "char", "*", "*", ")", "H5MM_xfree", "(", "comp_mname", ")", ";", "ret_value", "=", "new_type", ";", "}", "/*", "end", "case", "*/", "break;", "case", "H5T_ENUM", ":", "{", "H5T_path_t", "*", "tpath", ";", "/*", "Type", "conversion", "info", "*/", "hid_t", "super_type_id", ",", "<type", "ref=\"prev\"/>", "nat_super_type_id", ";", "/*", "Don\\'t", "need", "to", "do", "anything", "special", "for", "alignment,", "offset", "since", "the", "ENUM", "type", "usually", "is", "integer.", "*/", "/*", "Retrieve", "base", "type", "for", "enumerated", "type", "*/", "if", "(", "NULL", "==", "(", "super_type", "=", "H5T_get_super", "(", "dtype", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"unable", "to", "get", "base", "type", "for", "enumerate", "type\"", ")", "if", "(", "NULL", "==", "(", "nat_super_type", "=", "H5T__get_native_type", "(", "super_type", ",", "direction", ",", "struct_align", ",", "offset", ",", "comp_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"base", "native", "type", "retrieval", "failed\"", ")", "if", "(", "(", "super_type_id", "=", "H5I_register", "(", "H5I_DATATYPE", ",", "super_type", ",", "FALSE", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "register", "datatype\"", ")", "if", "(", "(", "nat_super_type_id", "=", "H5I_register", "(", "H5I_DATATYPE", ",", "nat_super_type", ",", "FALSE", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "register", "datatype\"", ")", "/*", "Allocate", "room", "for", "the", "enum", "values", "*/", "if", "(", "NULL", "==", "(", "tmp_memb_value", "=", "H5MM_calloc", "(", "H5T_get_size", "(", "super_type", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "allocate", "memory\"", ")", "if", "(", "NULL", "==", "(", "memb_value", "=", "H5MM_calloc", "(", "H5T_get_size", "(", "nat_super_type", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "allocate", "memory\"", ")", "/*", "Construct", "new", "enum", "type", "based", "on", "native", "type", "*/", "if", "(", "NULL", "==", "(", "new_type", "=", "H5T__enum_create", "(", "nat_super_type", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"unable", "to", "create", "enum", "type\"", ")", "/*", "Find", "the", "conversion", "function", "*/", "if", "(", "NULL", "==", "(", "tpath", "=", "H5T_path_find", "(", "super_type", ",", "nat_super_type", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_DATATYPE", ",", "H5E_CANTINIT", ",", "NULL", ",", "\"unable", "to", "convert", "between", "src", "and", "dst", "data", "types\"", ")", "/*", "Retrieve", "member", "info", "and", "insert", "members", "into", "new", "enum", "type", "*/", "if", "(", "(", "snmemb", "=", "H5T_get_nmembers", "(", "dtype", ")", ")", "<=", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"enumerate", "data", "type", "doesn\\'t", "have", "any", "member\"", ")", "H5_CHECKED_ASSIGN", "(", "nmemb", ",", "unsigned", ",", "snmemb", ",", "int", ")", ";", "for", "(", "u", "=", "0", ";", "u", "<", "nmemb", ";", "u", "++", ")", "{", "if", "(", "NULL", "==", "(", "memb_name", "=", "H5T__get_member_name", "(", "dtype", ",", "u", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "get", "member", "name\"", ")", "if", "(", "H5T__get_member_value", "(", "dtype", ",", "u", ",", "tmp_memb_value", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "get", "member", "value\"", ")", "H5MM_memcpy", "(", "memb_value", ",", "tmp_memb_value", ",", "H5T_get_size", "(", "super_type", ")", ")", ";", "if", "(", "H5T_convert", "(", "tpath", ",", "super_type_id", ",", "nat_super_type_id", ",", "(", "size_t", ")", "1", ",", "(", "size_t", ")", "0", ",", "(", "size_t", ")", "0", ",", "memb_value", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "get", "member", "value\"", ")", "if", "(", "H5T__enum_insert", "(", "new_type", ",", "memb_name", ",", "memb_value", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "insert", "member\"", ")", "memb_name", "=", "(", "char", "*", ")", "H5MM_xfree", "(", "memb_name", ")", ";", "}", "memb_value", "=", "H5MM_xfree", "(", "memb_value", ")", ";", "tmp_memb_value", "=", "H5MM_xfree", "(", "tmp_memb_value", ")", ";", "/*", "Close", "base", "type", "*/", "if", "(", "H5I_dec_app_ref", "(", "nat_super_type_id", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "/*", "Close", "super", "type", "*/", "if", "(", "H5I_dec_app_ref", "(", "super_type_id", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "ret_value", "=", "new_type", ";", "}", "/*", "end", "case", "*/", "break;", "case", "H5T_ARRAY", ":", "{", "int", "sarray_rank", ";", "/*", "Array\\'s", "rank", "*/", "unsigned", "array_rank", ";", "/*", "Array\\'s", "rank", "*/", "hsize_t", "nelems", "=", "1", ";", "size_t", "super_offset", "=", "0", ";", "size_t", "super_size", "=", "0", ";", "size_t", "super_align", "=", "0", ";", "/*", "Retrieve", "dimension", "information", "for", "array", "data", "type", "*/", "if", "(", "(", "sarray_rank", "=", "H5T__get_array_ndims", "(", "dtype", ")", ")", "<=", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "get", "dimension", "rank\"", ")", "H5_CHECKED_ASSIGN", "(", "array_rank", ",", "unsigned", ",", "sarray_rank", ",", "int", ")", ";", "if", "(", "NULL", "==", "(", "dims", "=", "(", "hsize_t", "*", ")", "H5MM_malloc", "(", "array_rank", "*", "sizeof", "(", "hsize_t", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "allocate", "memory\"", ")", "if", "(", "H5T__get_array_dims", "(", "dtype", ",", "dims", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "get", "dimension", "size\"", ")", "/*", "Retrieve", "base", "type", "for", "array", "type", "*/", "if", "(", "NULL", "==", "(", "super_type", "=", "H5T_get_super", "(", "dtype", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"unable", "to", "get", "parent", "type", "for", "array", "type\"", ")", "if", "(", "NULL", "==", "(", "nat_super_type", "=", "H5T__get_native_type", "(", "super_type", ",", "direction", ",", "&", "super_align", ",", "&", "super_offset", ",", "&", "super_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"parent", "native", "type", "retrieval", "failed\"", ")", "/*", "Close", "super", "type", "*/", "if", "(", "H5T_close_real", "(", "super_type", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "/*", "Create", "a", "new", "array", "type", "based", "on", "native", "type", "*/", "if", "(", "NULL", "==", "(", "new_type", "=", "H5T__array_create", "(", "nat_super_type", ",", "array_rank", ",", "dims", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"unable", "to", "create", "array", "type\"", ")", "/*", "Close", "base", "type", "*/", "if", "(", "H5T_close_real", "(", "nat_super_type", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "for", "(", "u", "=", "0", ";", "u", "<", "array_rank", ";", "u", "++", ")", "nelems", "*=", "dims", "[", "u", "]", ";", "H5_CHECK_OVERFLOW", "(", "nelems", ",", "hsize_t", ",", "size_t", ")", ";", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "super_size", ",", "(", "size_t", ")", "nelems", ",", "super_align", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "dims", "=", "(", "hsize_t", "*", ")", "H5MM_xfree", "(", "dims", ")", ";", "ret_value", "=", "new_type", ";", "}", "/*", "end", "case", "*/", "break;", "case", "H5T_VLEN", ":", "{", "size_t", "vl_align", "=", "0", ";", "size_t", "vl_size", "=", "0", ";", "size_t", "super_size", "=", "0", ";", "/*", "Retrieve", "base", "type", "for", "array", "type", "*/", "if", "(", "NULL", "==", "(", "super_type", "=", "H5T_get_super", "(", "dtype", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"unable", "to", "get", "parent", "type", "for", "VL", "type\"", ")", "/*", "Don\\'t", "need", "alignment,", "offset", "information", "if", "this", "VL", "isn\\'t", "a", "field", "of", "compound", "type.", "If", "it", "*", "is,", "go", "to", "a", "few", "steps", "below", "to", "compute", "the", "information", "directly.", "*/", "if", "(", "NULL", "==", "(", "nat_super_type", "=", "H5T__get_native_type", "(", "super_type", ",", "direction", ",", "NULL", ",", "NULL", ",", "&", "super_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"parent", "native", "type", "retrieval", "failed\"", ")", "/*", "Close", "super", "type", "*/", "if", "(", "H5T_close_real", "(", "super_type", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "/*", "Create", "a", "new", "array", "type", "based", "on", "native", "type", "*/", "if", "(", "NULL", "==", "(", "new_type", "=", "H5T__vlen_create", "(", "nat_super_type", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"unable", "to", "create", "VL", "type\"", ")", "/*", "Close", "base", "type", "*/", "if", "(", "H5T_close_real", "(", "nat_super_type", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "/*", "Update", "size,", "offset", "and", "compound", "alignment", "for", "parent", "compound", "type", "directly.", "*/", "vl_align", "=", "H5T_HVL_COMP_ALIGN_g", ";", "vl_size", "=", "sizeof", "(", "hvl_t", ")", ";", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "vl_size", ",", "(", "size_t", ")", "1", ",", "vl_align", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "ret_value", "=", "new_type", ";", "}", "/*", "end", "case", "*/", "break;", "case", "H5T_NO_CLASS", ":", "case", "H5T_NCLASSES", ":", "default:", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"data", "type", "doesn\\'t", "match", "any", "native", "type\"", ")", "}", "/*", "end", "switch", "*/", "done", ":", "/*", "Error", "cleanup", "*/", "if", "(", "NULL", "==", "ret_value", ")", "{", "if", "(", "new_type", ")", "if", "(", "H5T_close_real", "(", "new_type", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_DATATYPE", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"unable", "to", "release", "datatype\"", ")", "/*", "Free", "lists", "for", "members", "*/", "if", "(", "memb_list", ")", "{", "for", "(", "u", "=", "0", ";", "u", "<", "nmemb", ";", "u", "++", ")", "if", "(", "memb_list", "[", "u", "]", "&&", "H5T_close_real", "(", "memb_list", "[", "u", "]", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "close", "datatype\"", ")", "memb_list", "=", "(", "H5T_t", "*", "*", ")", "H5MM_xfree", "(", "memb_list", ")", ";", "}", "/*", "end", "if", "*/", "memb_offset", "=", "(", "size_t", "*", ")", "H5MM_xfree", "(", "memb_offset", ")", ";", "if", "(", "comp_mname", ")", "{", "for", "(", "u", "=", "0", ";", "u", "<", "nmemb", ";", "u", "++", ")", "if", "(", "comp_mname", "[", "u", "]", ")", "H5MM_xfree", "(", "comp_mname", "[", "u", "]", ")", ";", "comp_mname", "=", "(", "char", "*", "*", ")", "H5MM_xfree", "(", "comp_mname", ")", ";", "}", "/*", "end", "if", "*/", "memb_name", "=", "(", "char", "*", ")", "H5MM_xfree", "(", "memb_name", ")", ";", "memb_value", "=", "H5MM_xfree", "(", "memb_value", ")", ";", "tmp_memb_value", "=", "H5MM_xfree", "(", "tmp_memb_value", ")", ";", "dims", "=", "(", "hsize_t", "*", ")", "H5MM_xfree", "(", "dims", ")", ";", "}", "/*", "end", "if", "*/", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "This", "function", "is", "only", "for", "convenience" ]

[ "'static", "herr_t", "H5T__cmp_offset", "(", "size_t", "*", "comp_size", ",", "size_t", "*", "offset", ",", "size_t", "elem_size", ",", "size_t", "nelems", ",", "size_t", "align", ",", "size_t", "*", "struct_align", ")", "{", "FUNC_ENTER_STATIC_NOERR", "if", "(", "offset", "&&", "comp_size", ")", "{", "if", "(", "align", ">", "1", "&&", "*", "comp_size", "%", "align", ")", "{", "/*", "Add", "alignment", "value", "*/", "*", "offset", "=", "*", "comp_size", "+", "(", "align", "-", "*", "comp_size", "%", "align", ")", ";", "*", "comp_size", "+=", "(", "align", "-", "*", "comp_size", "%", "align", ")", ";", "}", "/*", "end", "if", "*/", "else", "*", "offset", "=", "*", "comp_size", ";", "/*", "compute", "size", "of", "compound", "type", "member.", "*/", "*", "comp_size", "+=", "nelems", "*", "elem_size", ";", "}", "/*", "end", "if", "*/", "if", "(", "struct_align", "&&", "*", "struct_align", "<", "align", ")", "*", "struct_align", "=", "align", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Highlevel", "API", "to", "return", "the", "native", "type", "of", "a", "datatype" ]

[ "'hid_t", "H5Tget_native_type", "(", "hid_t", "type_id", ",", "H5T_direction_t", "direction", ")", "{", "H5T_t", "*", "dt", ";", "/*", "Datatype", "to", "create", "native", "datatype", "from", "*/", "H5T_t", "*", "new_dt", "=", "NULL", ";", "/*", "Datatype", "for", "native", "datatype", "created", "*/", "size_t", "comp_size", "=", "0", ";", "/*", "Compound", "datatype\\'s", "size", "*/", "hid_t", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "H5I_INVALID_HID", ")", "H5TRACE2", "(", "\"i\"", ",", "\"iTd\"", ",", "type_id", ",", "direction", ")", ";", "/*", "Check", "arguments", "*/", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object_verify", "(", "type_id", ",", "H5I_DATATYPE", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "H5I_INVALID_HID", ",", "\"not", "a", "data", "type\"", ")", "if", "(", "direction", "!=", "H5T_DIR_DEFAULT", "&&", "direction", "!=", "H5T_DIR_ASCEND", "&&", "direction", "!=", "H5T_DIR_DESCEND", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "H5I_INVALID_HID", ",", "\"not", "valid", "direction", "value\"", ")", "/*", "Get", "the", "native", "type", "*/", "if", "(", "NULL", "==", "(", "new_dt", "=", "H5T__get_native_type", "(", "dt", ",", "direction", ",", "NULL", ",", "NULL", ",", "&", "comp_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "H5I_INVALID_HID", ",", "\"cannot", "retrieve", "native", "type\"", ")", "/*", "Get", "an", "ID", "for", "the", "new", "type", "*/", "if", "(", "(", "ret_value", "=", "H5I_register", "(", "H5I_DATATYPE", ",", "new_dt", ",", "TRUE", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_DATATYPE", ",", "H5E_CANTREGISTER", ",", "H5I_INVALID_HID", ",", "\"unable", "to", "register", "data", "type\"", ")", "done", ":", "/*", "Error", "cleanup", "*/", "if", "(", "ret_value", "<", "0", ")", "if", "(", "new_dt", "&&", "H5T_close_real", "(", "new_dt", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_DATATYPE", ",", "H5E_CLOSEERROR", ",", "H5I_INVALID_HID", ",", "\"unable", "to", "release", "datatype\"", ")", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Returns", "the", "native", "bitfield", "type", "of", "a", "datatype" ]

[ "'static", "H5T_t", "*", "H5T__get_native_bitfield", "(", "size_t", "prec", ",", "H5T_direction_t", "direction", ",", "size_t", "*", "struct_align", ",", "size_t", "*", "offset", ",", "size_t", "*", "comp_size", ")", "{", "H5T_t", "*", "dt", ";", "/*", "Appropriate", "native", "datatype", "to", "copy", "*/", "hid_t", "tid", "=", "(", "-", "1", ")", ";", "/*", "Datatype", "ID", "of", "appropriate", "native", "datatype", "*/", "size_t", "align", "=", "0", ";", "/*", "Alignment", "necessary", "for", "native", "datatype", "*/", "size_t", "native_size", "=", "0", ";", "/*", "Datatype", "size", "of", "the", "native", "type", "*/", "H5T_t", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "if", "(", "direction", "==", "H5T_DIR_DEFAULT", "||", "direction", "==", "H5T_DIR_ASCEND", ")", "{", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_B8_g", ")", ")", ")", "{", "tid", "=", "H5T_NATIVE_B8", ";", "native_size", "=", "1", ";", "align", "=", "H5T_NATIVE_UINT8_ALIGN_g", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_B16_g", ")", ")", ")", "{", "tid", "=", "H5T_NATIVE_B16", ";", "native_size", "=", "2", ";", "align", "=", "H5T_NATIVE_UINT16_ALIGN_g", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_B32_g", ")", ")", ")", "{", "tid", "=", "H5T_NATIVE_B32", ";", "native_size", "=", "4", ";", "align", "=", "H5T_NATIVE_UINT32_ALIGN_g", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_B64_g", ")", ")", ")", "{", "tid", "=", "H5T_NATIVE_B64", ";", "native_size", "=", "8", ";", "align", "=", "H5T_NATIVE_UINT64_ALIGN_g", ";", "}", "else", "{", "/*", "If", "no", "native", "type", "matches", "the", "querried", "datatype,", "simply", "choose", "the", "type", "of", "biggest", "size.", "*/", "tid", "=", "H5T_NATIVE_B64", ";", "native_size", "=", "8", ";", "align", "=", "H5T_NATIVE_UINT64_ALIGN_g", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "direction", "==", "H5T_DIR_DESCEND", ")", "{", "if", "(", "prec", ">", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_B32_g", ")", ")", ")", "{", "tid", "=", "H5T_NATIVE_B64", ";", "native_size", "=", "8", ";", "align", "=", "H5T_NATIVE_UINT64_ALIGN_g", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", ">", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_B16_g", ")", ")", ")", "{", "tid", "=", "H5T_NATIVE_B32", ";", "native_size", "=", "4", ";", "align", "=", "H5T_NATIVE_UINT32_ALIGN_g", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", ">", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_B8_g", ")", ")", ")", "{", "tid", "=", "H5T_NATIVE_B16", ";", "native_size", "=", "2", ";", "align", "=", "H5T_NATIVE_UINT16_ALIGN_g", ";", "}", "else", "{", "tid", "=", "H5T_NATIVE_B8", ";", "native_size", "=", "1", ";", "align", "=", "H5T_NATIVE_UINT8_ALIGN_g", ";", "}", "}", "/*", "Create", "new", "native", "type", "*/", "HDassert", "(", "tid", ">=", "0", ")", ";", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object", "(", "tid", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "data", "type\"", ")", "if", "(", "(", "ret_value", "=", "H5T_copy", "(", "dt", ",", "H5T_COPY_TRANSIENT", ")", ")", "==", "NULL", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "copy", "type\"", ")", "/*", "compute", "size", "and", "offset", "of", "compound", "type", "member.", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "native_size", ",", "(", "size_t", ")", "1", ",", "align", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Returns", "the", "native", "integer", "type", "of", "a", "datatype" ]

[ "'static", "H5T_t", "*", "H5T__get_native_integer", "(", "size_t", "prec", ",", "H5T_sign_t", "sign", ",", "H5T_direction_t", "direction", ",", "size_t", "*", "struct_align", ",", "size_t", "*", "offset", ",", "size_t", "*", "comp_size", ")", "{", "H5T_t", "*", "dt", ";", "/*", "Appropriate", "native", "datatype", "to", "copy", "*/", "hid_t", "tid", "=", "(", "-", "1", ")", ";", "/*", "Datatype", "ID", "of", "appropriate", "native", "datatype", "*/", "size_t", "align", "=", "0", ";", "/*", "Alignment", "necessary", "for", "native", "datatype", "*/", "size_t", "native_size", "=", "0", ";", "/*", "Datatype", "size", "of", "the", "native", "type", "*/", "enum", "match_type", "{", "/*", "The", "different", "kinds", "of", "integers", "we", "can", "match", "*/", "H5T_NATIVE_INT_MATCH_CHAR", ",", "H5T_NATIVE_INT_MATCH_SHORT", ",", "H5T_NATIVE_INT_MATCH_INT", ",", "H5T_NATIVE_INT_MATCH_LONG", ",", "H5T_NATIVE_INT_MATCH_LLONG", ",", "H5T_NATIVE_INT_MATCH_UNKNOWN", "}", "match", "=", "H5T_NATIVE_INT_MATCH_UNKNOWN", ";", "H5T_t", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "if", "(", "direction", "==", "H5T_DIR_DEFAULT", "||", "direction", "==", "H5T_DIR_ASCEND", ")", "{", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_SCHAR_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_CHAR", ";", "native_size", "=", "sizeof", "(", "char", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_SHORT_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_SHORT", ";", "native_size", "=", "sizeof", "(", "short", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_INT_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_INT", ";", "native_size", "=", "sizeof", "(", "int", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_LONG_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_LONG", ";", "native_size", "=", "sizeof", "(", "long", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", "<=", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_LLONG_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_LLONG", ";", "native_size", "=", "sizeof", "(", "long", "long", ")", ";", "}", "else", "{", "/*", "If", "no", "native", "type", "matches", "the", "querried", "datatype,", "simply", "choose", "the", "type", "of", "biggest", "size.", "*/", "match", "=", "H5T_NATIVE_INT_MATCH_LLONG", ";", "native_size", "=", "sizeof", "(", "long", "long", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "direction", "==", "H5T_DIR_DESCEND", ")", "{", "if", "(", "prec", ">", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_LONG_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_LLONG", ";", "native_size", "=", "sizeof", "(", "long", "long", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", ">", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_INT_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_LONG", ";", "native_size", "=", "sizeof", "(", "long", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", ">", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_SHORT_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_INT", ";", "native_size", "=", "sizeof", "(", "int", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "prec", ">", "H5T_get_precision", "(", "(", "H5T_t", "*", ")", "H5I_object", "(", "H5T_NATIVE_SCHAR_g", ")", ")", ")", "{", "match", "=", "H5T_NATIVE_INT_MATCH_SHORT", ";", "native_size", "=", "sizeof", "(", "short", ")", ";", "}", "else", "{", "match", "=", "H5T_NATIVE_INT_MATCH_CHAR", ";", "native_size", "=", "sizeof", "(", "char", ")", ";", "}", "}", "/*", "Set", "the", "appropriate", "native", "datatype", "information", "*/", "switch", "(", "match", ")", "{", "case", "H5T_NATIVE_INT_MATCH_CHAR", ":", "if", "(", "sign", "==", "H5T_SGN_2", ")", "tid", "=", "H5T_NATIVE_SCHAR", ";", "else", "tid", "=", "H5T_NATIVE_UCHAR", ";", "align", "=", "H5T_NATIVE_SCHAR_COMP_ALIGN_g", ";", "break;", "case", "H5T_NATIVE_INT_MATCH_SHORT", ":", "if", "(", "sign", "==", "H5T_SGN_2", ")", "tid", "=", "H5T_NATIVE_SHORT", ";", "else", "tid", "=", "H5T_NATIVE_USHORT", ";", "align", "=", "H5T_NATIVE_SHORT_COMP_ALIGN_g", ";", "break;", "case", "H5T_NATIVE_INT_MATCH_INT", ":", "if", "(", "sign", "==", "H5T_SGN_2", ")", "tid", "=", "H5T_NATIVE_INT", ";", "else", "tid", "=", "H5T_NATIVE_UINT", ";", "align", "=", "H5T_NATIVE_INT_COMP_ALIGN_g", ";", "break;", "case", "H5T_NATIVE_INT_MATCH_LONG", ":", "if", "(", "sign", "==", "H5T_SGN_2", ")", "tid", "=", "H5T_NATIVE_LONG", ";", "else", "tid", "=", "H5T_NATIVE_ULONG", ";", "align", "=", "H5T_NATIVE_LONG_COMP_ALIGN_g", ";", "break;", "case", "H5T_NATIVE_INT_MATCH_LLONG", ":", "if", "(", "sign", "==", "H5T_SGN_2", ")", "tid", "=", "H5T_NATIVE_LLONG", ";", "else", "tid", "=", "H5T_NATIVE_ULLONG", ";", "align", "=", "H5T_NATIVE_LLONG_COMP_ALIGN_g", ";", "break;", "case", "H5T_NATIVE_INT_MATCH_UNKNOWN", ":", "default:", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"Unknown", "native", "integer", "match\"", ")", "}", "/*", "end", "switch", "*/", "/*", "Create", "new", "native", "type", "*/", "HDassert", "(", "tid", ">=", "0", ")", ";", "if", "(", "NULL", "==", "(", "dt", "=", "(", "H5T_t", "*", ")", "H5I_object", "(", "tid", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"not", "a", "data", "type\"", ")", "if", "(", "NULL", "==", "(", "ret_value", "=", "H5T_copy", "(", "dt", ",", "H5T_COPY_TRANSIENT", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "copy", "type\"", ")", "/*", "compute", "size", "and", "offset", "of", "compound", "type", "member.", "*/", "if", "(", "H5T__cmp_offset", "(", "comp_size", ",", "offset", ",", "native_size", ",", "(", "size_t", ")", "1", ",", "align", ",", "struct_align", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "NULL", ",", "\"cannot", "compute", "compound", "offset\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Set", "a", "Group", "of", "Pins", "Atomic" ]

[ "'void", "gpio_set", "(", "uint32_t", "gpioport", ",", "uint16_t", "gpios", ")", "{", "GPIO_BSRR", "(", "gpioport", ")", "=", "gpios", ";", "}'" ]

[ "Read", "from", "a", "Port" ]

[ "'uint16_t", "gpio_port_read", "(", "uint32_t", "gpioport", ")", "{", "return", "(", "uint16_t", ")", "GPIO_IDR", "(", "gpioport", ")", ";", "}'" ]

[ "Lock", "the", "Configuration", "of", "a", "Group", "of", "Pins" ]

[ "'void", "gpio_port_config_lock", "(", "uint32_t", "gpioport", ",", "uint16_t", "gpios", ")", "{", "uint32_t", "reg32", ";", "/*", "Special", "\"Lock", "Key", "Writing", "Sequence\",", "see", "datasheet.", "*/", "GPIO_LCKR", "(", "gpioport", ")", "=", "GPIO_LCKK", "|", "gpios", ";", "/*", "Set", "LCKK.", "*/", "GPIO_LCKR", "(", "gpioport", ")", "=", "~", "GPIO_LCKK", "&", "gpios", ";", "/*", "Clear", "LCKK.", "*/", "GPIO_LCKR", "(", "gpioport", ")", "=", "GPIO_LCKK", "|", "gpios", ";", "/*", "Set", "LCKK.", "*/", "reg32", "=", "GPIO_LCKR", "(", "gpioport", ")", ";", "/*", "Read", "LCKK.", "*/", "reg32", "=", "GPIO_LCKR", "(", "gpioport", ")", ";", "/*", "Read", "LCKK", "again.", "*/", "/*", "Tell", "the", "compiler", "the", "variable", "is", "actually", "used.", "It", "will", "get", "*", "optimized", "out", "anyways.", "*/", "reg32", "=", "reg32", ";", "/*", "If", "(reg32", "&", "GPIO_LCKK)", "is", "true,", "the", "lock", "is", "now", "active.", "*/", "}'" ]

[ "Read", "a", "Group", "of", "Pins" ]

[ "'uint16_t", "gpio_get", "(", "uint32_t", "gpioport", ",", "uint16_t", "gpios", ")", "{", "return", "gpio_port_read", "(", "gpioport", ")", "&", "gpios", ";", "}'" ]

[ "Toggle", "a", "Group", "of", "Pins" ]

[ "'void", "gpio_toggle", "(", "uint32_t", "gpioport", ",", "uint16_t", "gpios", ")", "{", "uint32_t", "port", "=", "GPIO_ODR", "(", "gpioport", ")", ";", "GPIO_BSRR", "(", "gpioport", ")", "=", "(", "(", "port", "&", "gpios", ")", "<<", "16", ")", "|", "(", "~", "port", "&", "gpios", ")", ";", "}'" ]

[ "Write", "to", "a", "Port" ]

[ "'void", "gpio_port_write", "(", "uint32_t", "gpioport", ",", "uint16_t", "data", ")", "{", "GPIO_ODR", "(", "gpioport", ")", "=", "data", ";", "}'" ]

[ "Function", "that", "is", "called", "if", "no", "event", "handler", "is", "provided" ]

[ "'static", "void", "dummy_evt_handler", "(", "ble_dfu_buttonless_evt_type_t", "evt", ")", "{", "NRF_LOG_DEBUG", "(", "\"Dummy", "event", "handler", "received", "event", "0x%x\"", ",", "evt", ")", ";", "}'" ]

[ "Recordcomparison", "callback", "from", "ptrheap" ]

[ "'static", "int", "compar", "(", "void", "*", "cookie", ",", "const", "void", "*", "x", ",", "const", "void", "*", "y", ")", "{", "const", "struct", "timerrec", "*", "_x", "=", "x", ";", "const", "struct", "timerrec", "*", "_y", "=", "y", ";", "(", "void", ")", "cookie", ";", "/*", "UNUSED", "*/", "return", "(", "tvcmp", "(", "&", "_x", "->", "tv", ",", "&", "_y", "->", "tv", ")", ")", ";", "}'" ]

[ "Cookierecording", "callback", "from", "ptrheap" ]

[ "'static", "void", "setreccookie", "(", "void", "*", "cookie", ",", "void", "*", "ptr", ",", "size_t", "rc", ")", "{", "struct", "timerrec", "*", "rec", "=", "ptr", ";", "(", "void", ")", "cookie", ";", "/*", "UNUSED", "*/", "rec", "->", "rc", "=", "rc", ";", "}'" ]

[ "Returns", "the", "current", "CRC", "value" ]

[ "'uint32_t", "CRC_GetCRC", "(", "void", ")", "{", "return", "(", "CRC", "->", "DR", ")", ";", "}'" ]

[ "Recalculate", "voice", "parameters", "for", "a", "given", "control" ]

[ "'int", "fluid_voice_modulate", "(", "fluid_voice_t", "*", "voice", ",", "int", "cc", ",", "int", "ctrl", ")", "{", "int", "i", ",", "<type", "ref=\"prev\"/>", "k", ";", "fluid_mod_t", "*", "mod", ";", "int", "gen", ";", "fluid_real_t", "modval", ";", "/*", "printf(\"Chan=%d,", "CC=%d,", "Src=%d,", "Val=%d\\\",", "voice->channel->channum,", "cc,", "ctrl,", "val);", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "voice", "->", "mod_count", ";", "i", "++", ")", "{", "mod", "=", "&", "voice", "->", "mod", "[", "i", "]", ";", "/*", "step", "1:", "find", "all", "the", "modulators", "that", "have", "the", "changed", "controller", "*", "as", "input", "source.", "*/", "if", "(", "fluid_mod_has_source", "(", "mod", ",", "cc", ",", "ctrl", ")", ")", "{", "gen", "=", "fluid_mod_get_dest", "(", "mod", ")", ";", "modval", "=", "0.0", ";", "/*", "step", "2:", "for", "every", "changed", "modulator,", "calculate", "the", "modulation", "*", "value", "of", "its", "associated", "generator", "*/", "for", "(", "k", "=", "0", ";", "k", "<", "voice", "->", "mod_count", ";", "k", "++", ")", "{", "if", "(", "fluid_mod_has_dest", "(", "&", "voice", "->", "mod", "[", "k", "]", ",", "gen", ")", ")", "{", "modval", "+=", "fluid_mod_get_value", "(", "&", "voice", "->", "mod", "[", "k", "]", ",", "voice", "->", "channel", ",", "voice", ")", ";", "}", "}", "fluid_gen_set_mod", "(", "&", "voice", "->", "gen", "[", "gen", "]", ",", "modval", ")", ";", "/*", "step", "3:", "now", "that", "we", "have", "the", "new", "value", "of", "the", "generator,", "*", "recalculate", "the", "parameter", "values", "that", "are", "derived", "from", "the", "*", "generator", "*/", "fluid_voice_update_param", "(", "voice", ",", "gen", ")", ";", "}", "}", "return", "FLUID_OK", ";", "}'" ]

[ "Get", "the", "value", "of", "a", "generator" ]

[ "'float", "fluid_voice_gen_get", "(", "fluid_voice_t", "*", "voice", ",", "int", "gen", ")", "{", "return", "voice", "->", "gen", "[", "gen", "]", ".", "val", ";", "}'" ]

[ "The", "value", "of", "a", "generator", "(gen)", "has", "changed" ]

[ "'void", "fluid_voice_update_param", "(", "fluid_voice_t", "*", "voice", ",", "int", "gen", ")", "{", "double", "q_dB", ";", "fluid_real_t", "x", ";", "fluid_real_t", "y", ";", "unsigned", "int", "count", ",", "<type", "ref=\"prev\"/>", "z", ";", "//", "Alternate", "attenuation", "scale", "used", "by", "EMU10K1", "cards", "when", "setting", "the", "attenuation", "at", "the", "preset", "or", "instrument", "level", "within", "the", "SoundFont", "bank.", "static", "const", "float", "ALT_ATTENUATION_SCALE", "=", "0.4", ";", "switch", "(", "gen", ")", "{", "case", "GEN_PAN", ":", "/*", "range", "checking", "is", "done", "in", "the", "fluid_pan", "function", "*/", "voice", "->", "pan", "=", "_GEN", "(", "voice", ",", "GEN_PAN", ")", ";", "voice", "->", "amp_left", "=", "fluid_pan", "(", "voice", "->", "pan", ",", "1", ")", "*", "voice", "->", "synth_gain", "/", "32768.0f", ";", "voice", "->", "amp_right", "=", "fluid_pan", "(", "voice", "->", "pan", ",", "0", ")", "*", "voice", "->", "synth_gain", "/", "32768.0f", ";", "UPDATE_RVOICE_BUFFERS2", "(", "fluid_rvoice_buffers_set_amp", ",", "0", ",", "voice", "->", "amp_left", ")", ";", "UPDATE_RVOICE_BUFFERS2", "(", "fluid_rvoice_buffers_set_amp", ",", "1", ",", "voice", "->", "amp_right", ")", ";", "break;", "case", "GEN_ATTENUATION", ":", "voice", "->", "attenuation", "=", "(", "(", "fluid_real_t", ")", "(", "voice", ")", "->", "gen", "[", "GEN_ATTENUATION", "]", ".", "val", "*", "ALT_ATTENUATION_SCALE", ")", "+", "(", "fluid_real_t", ")", "(", "voice", ")", "->", "gen", "[", "GEN_ATTENUATION", "]", ".", "mod", "+", "(", "fluid_real_t", ")", "(", "voice", ")", "->", "gen", "[", "GEN_ATTENUATION", "]", ".", "nrpn", ";", "/*", "Range:", "SF2.01", "section", "8.1.3", "#", "48", "*", "Motivation", "for", "range", "checking:", "*", "OHPiano.SF2", "sets", "initial", "attenuation", "to", "a", "whooping", "-96", "dB", "*/", "fluid_clip", "(", "voice", "->", "attenuation", ",", "0.0", ",", "1440.0", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_attenuation", ",", "voice", "->", "attenuation", ")", ";", "break;", "/*", "The", "pitch", "is", "calculated", "from", "three", "different", "generators.", "*", "Read", "comment", "in", "fluidsynth.h", "about", "GEN_PITCH.", "*/", "case", "GEN_PITCH", ":", "case", "GEN_COARSETUNE", ":", "case", "GEN_FINETUNE", ":", "/*", "The", "testing", "for", "allowed", "range", "is", "done", "in", "\\'fluid_ct2hz\\'", "*/", "voice", "->", "pitch", "=", "(", "_GEN", "(", "voice", ",", "GEN_PITCH", ")", "+", "100.0f", "*", "_GEN", "(", "voice", ",", "GEN_COARSETUNE", ")", "+", "_GEN", "(", "voice", ",", "GEN_FINETUNE", ")", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_pitch", ",", "voice", "->", "pitch", ")", ";", "break;", "case", "GEN_REVERBSEND", ":", "/*", "The", "generator", "unit", "is", "\\'tenths", "of", "a", "percent\\'.", "*/", "voice", "->", "reverb_send", "=", "_GEN", "(", "voice", ",", "GEN_REVERBSEND", ")", "/", "1000.0f", ";", "fluid_clip", "(", "voice", "->", "reverb_send", ",", "0.0", ",", "1.0", ")", ";", "voice", "->", "amp_reverb", "=", "voice", "->", "reverb_send", "*", "voice", "->", "synth_gain", "/", "32768.0f", ";", "UPDATE_RVOICE_BUFFERS2", "(", "fluid_rvoice_buffers_set_amp", ",", "2", ",", "voice", "->", "amp_reverb", ")", ";", "break;", "case", "GEN_CHORUSSEND", ":", "/*", "The", "generator", "unit", "is", "\\'tenths", "of", "a", "percent\\'.", "*/", "voice", "->", "chorus_send", "=", "_GEN", "(", "voice", ",", "GEN_CHORUSSEND", ")", "/", "1000.0f", ";", "fluid_clip", "(", "voice", "->", "chorus_send", ",", "0.0", ",", "1.0", ")", ";", "voice", "->", "amp_chorus", "=", "voice", "->", "chorus_send", "*", "voice", "->", "synth_gain", "/", "32768.0f", ";", "UPDATE_RVOICE_BUFFERS2", "(", "fluid_rvoice_buffers_set_amp", ",", "3", ",", "voice", "->", "amp_chorus", ")", ";", "break;", "case", "GEN_OVERRIDEROOTKEY", ":", "/*", "This", "is", "a", "non-realtime", "parameter.", "Therefore", "the", ".mod", "part", "of", "the", "generator", "*", "can", "be", "neglected.", "*", "NOTE:", "origpitch", "sets", "MIDI", "root", "note", "while", "pitchadj", "is", "a", "fine", "tuning", "amount", "*", "which", "offsets", "the", "original", "rate.", "This", "means", "that", "the", "fine", "tuning", "is", "*", "inverted", "with", "respect", "to", "the", "root", "note", "(so", "subtract", "it,", "not", "add).", "*/", "if", "(", "voice", "->", "sample", "!=", "NULL", ")", "{", "if", "(", "voice", "->", "gen", "[", "GEN_OVERRIDEROOTKEY", "]", ".", "val", ">", "-", "1", ")", "//FIXME:", "use", "flag", "instead", "of", "-1", "voice", "->", "root_pitch", "=", "voice", "->", "gen", "[", "GEN_OVERRIDEROOTKEY", "]", ".", "val", "*", "100.0f", "-", "voice", "->", "sample", "->", "pitchadj", ";", "else", "voice", "->", "root_pitch", "=", "voice", "->", "sample", "->", "origpitch", "*", "100.0f", "-", "voice", "->", "sample", "->", "pitchadj", ";", "x", "=", "(", "fluid_ct2hz", "(", "voice", "->", "root_pitch", ")", "*", "(", "(", "fluid_real_t", ")", "voice", "->", "output_rate", "/", "voice", "->", "sample", "->", "samplerate", ")", ")", ";", "}", "else", "{", "if", "(", "voice", "->", "gen", "[", "GEN_OVERRIDEROOTKEY", "]", ".", "val", ">", "-", "1", ")", "//FIXME:", "use", "flag", "instead", "of", "-1", "voice", "->", "root_pitch", "=", "voice", "->", "gen", "[", "GEN_OVERRIDEROOTKEY", "]", ".", "val", "*", "100.0f", ";", "else", "voice", "->", "root_pitch", "=", "0", ";", "x", "=", "fluid_ct2hz", "(", "voice", "->", "root_pitch", ")", ";", "}", "/*", "voice->pitch", "depends", "on", "voice->root_pitch,", "so", "calculate", "voice->pitch", "now", "*/", "fluid_voice_calculate_gen_pitch", "(", "voice", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_root_pitch_hz", ",", "x", ")", ";", "break;", "case", "GEN_FILTERFC", ":", "/*", "The", "resonance", "frequency", "is", "converted", "from", "absolute", "cents", "to", "*", "midicents", ".val", "and", ".mod", "are", "both", "used,", "this", "permits", "real-time", "*", "modulation.", "The", "allowed", "range", "is", "tested", "in", "the", "\\'fluid_ct2hz\\'", "*", "function", "[PH,20021214]", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_FILTERFC", ")", ";", "UPDATE_RVOICE_FILTER1", "(", "fluid_iir_filter_set_fres", ",", "x", ")", ";", "break;", "case", "GEN_FILTERQ", ":", "/*", "The", "generator", "contains", "\\'centibels\\'", "(1/10", "dB)", "=>", "divide", "by", "10", "to", "*", "obtain", "dB", "*/", "q_dB", "=", "_GEN", "(", "voice", ",", "GEN_FILTERQ", ")", "/", "10.0f", ";", "/*", "Range:", "SF2.01", "section", "8.1.3", "#", "8", "(convert", "from", "cB", "to", "dB", "=>", "/10)", "*/", "fluid_clip", "(", "q_dB", ",", "0.0f", ",", "96.0f", ")", ";", "/*", "Short", "version:", "Modify", "the", "Q", "definition", "in", "a", "way,", "that", "a", "Q", "of", "0", "*", "dB", "leads", "to", "no", "resonance", "hump", "in", "the", "freq.", "response.", "*", "*", "Long", "version:", "From", "SF2.01,", "page", "39,", "item", "9", "(initialFilterQ):", "*", "\"The", "gain", "at", "the", "cutoff", "frequency", "may", "be", "less", "than", "zero", "when", "*", "zero", "is", "specified\".", "Assume", "q_dB=0", "/", "q_lin=1:", "If", "we", "would", "leave", "*", "q", "as", "it", "is,", "then", "this", "results", "in", "a", "3", "dB", "hump", "slightly", "below", "*", "fc.", "At", "fc,", "the", "gain", "is", "exactly", "the", "DC", "gain", "(0", "dB).", "What", "is", "*", "(probably)", "meant", "here", "is", "that", "the", "filter", "does", "not", "show", "a", "*", "resonance", "hump", "for", "q_dB=0.", "In", "this", "case,", "the", "corresponding", "*", "q_lin", "is", "1/sqrt(2)=0.707.", "The", "filter", "should", "have", "3", "dB", "of", "*", "attenuation", "at", "fc", "now.", "In", "this", "case", "Q_dB", "is", "the", "height", "of", "the", "*", "resonance", "peak", "not", "over", "the", "DC", "gain,", "but", "over", "the", "frequency", "*", "response", "of", "a", "non-resonant", "filter.", "This", "idea", "is", "implemented", "as", "*", "follows:", "*/", "q_dB", "-=", "3.01f", ";", "UPDATE_RVOICE_FILTER1", "(", "fluid_iir_filter_set_q_dB", ",", "q_dB", ")", ";", "break;", "case", "GEN_MODLFOTOPITCH", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODLFOTOPITCH", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0", ",", "12000.0", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_modlfo_to_pitch", ",", "x", ")", ";", "break;", "case", "GEN_MODLFOTOVOL", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODLFOTOVOL", ")", ";", "fluid_clip", "(", "x", ",", "-", "960.0", ",", "960.0", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_modlfo_to_vol", ",", "x", ")", ";", "break;", "case", "GEN_MODLFOTOFILTERFC", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODLFOTOFILTERFC", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000", ",", "12000", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_modlfo_to_fc", ",", "x", ")", ";", "break;", "case", "GEN_MODLFODELAY", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODLFODELAY", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0f", ",", "5000.0f", ")", ";", "z", "=", "(", "unsigned", "int", ")", "(", "voice", "->", "output_rate", "*", "fluid_tc2sec_delay", "(", "x", ")", ")", ";", "UPDATE_RVOICE_ENVLFO_I1", "(", "fluid_lfo_set_delay", ",", "modlfo", ",", "z", ")", ";", "break;", "case", "GEN_MODLFOFREQ", ":", "/*", "-", "the", "frequency", "is", "converted", "into", "a", "delta", "value,", "per", "buffer", "of", "FLUID_BUFSIZE", "samples", "*", "-", "the", "delay", "into", "a", "sample", "delay", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODLFOFREQ", ")", ";", "fluid_clip", "(", "x", ",", "-", "16000.0f", ",", "4500.0f", ")", ";", "x", "=", "(", "4.0f", "*", "FLUID_BUFSIZE", "*", "fluid_act2hz", "(", "x", ")", "/", "voice", "->", "output_rate", ")", ";", "UPDATE_RVOICE_ENVLFO_R1", "(", "fluid_lfo_set_incr", ",", "modlfo", ",", "x", ")", ";", "break;", "case", "GEN_VIBLFOFREQ", ":", "/*", "vib", "lfo", "*", "*", "-", "the", "frequency", "is", "converted", "into", "a", "delta", "value,", "per", "buffer", "of", "FLUID_BUFSIZE", "samples", "*", "-", "the", "delay", "into", "a", "sample", "delay", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_VIBLFOFREQ", ")", ";", "fluid_clip", "(", "x", ",", "-", "16000.0f", ",", "4500.0f", ")", ";", "x", "=", "4.0f", "*", "FLUID_BUFSIZE", "*", "fluid_act2hz", "(", "x", ")", "/", "voice", "->", "output_rate", ";", "UPDATE_RVOICE_ENVLFO_R1", "(", "fluid_lfo_set_incr", ",", "viblfo", ",", "x", ")", ";", "break;", "case", "GEN_VIBLFODELAY", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_VIBLFODELAY", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0f", ",", "5000.0f", ")", ";", "z", "=", "(", "unsigned", "int", ")", "(", "voice", "->", "output_rate", "*", "fluid_tc2sec_delay", "(", "x", ")", ")", ";", "UPDATE_RVOICE_ENVLFO_I1", "(", "fluid_lfo_set_delay", ",", "viblfo", ",", "z", ")", ";", "break;", "case", "GEN_VIBLFOTOPITCH", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_VIBLFOTOPITCH", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0", ",", "12000.0", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_viblfo_to_pitch", ",", "x", ")", ";", "break;", "case", "GEN_KEYNUM", ":", "/*", "GEN_KEYNUM:", "SF2.01", "page", "46,", "item", "46", "*", "*", "If", "this", "generator", "is", "active,", "it", "forces", "the", "key", "number", "to", "its", "*", "value.", "Non-realtime", "controller.", "*", "*", "There", "is", "a", "flag,", "which", "should", "indicate,", "whether", "a", "generator", "is", "*", "enabled", "or", "not.", "But", "here", "we", "rely", "on", "the", "default", "value", "of", "-1.", "*", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_KEYNUM", ")", ";", "if", "(", "x", ">=", "0", ")", "{", "voice", "->", "key", "=", "x", ";", "}", "break;", "case", "GEN_VELOCITY", ":", "/*", "GEN_VELOCITY:", "SF2.01", "page", "46,", "item", "47", "*", "*", "If", "this", "generator", "is", "active,", "it", "forces", "the", "velocity", "to", "its", "*", "value.", "Non-realtime", "controller.", "*", "*", "There", "is", "a", "flag,", "which", "should", "indicate,", "whether", "a", "generator", "is", "*", "enabled", "or", "not.", "But", "here", "we", "rely", "on", "the", "default", "value", "of", "-1.", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_VELOCITY", ")", ";", "if", "(", "x", ">", "0", ")", "{", "voice", "->", "vel", "=", "x", ";", "}", "break;", "case", "GEN_MODENVTOPITCH", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODENVTOPITCH", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0", ",", "12000.0", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_modenv_to_pitch", ",", "x", ")", ";", "break;", "case", "GEN_MODENVTOFILTERFC", ":", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODENVTOFILTERFC", ")", ";", "/*", "Range:", "SF2.01", "section", "8.1.3", "#", "1", "*", "Motivation", "for", "range", "checking:", "*", "Filter", "is", "reported", "to", "make", "funny", "noises", "now", "and", "then", "*/", "fluid_clip", "(", "x", ",", "-", "12000.0", ",", "12000.0", ")", ";", "UPDATE_RVOICE_R1", "(", "fluid_rvoice_set_modenv_to_fc", ",", "x", ")", ";", "break;", "/*", "sample", "start", "and", "ends", "points", "*", "*", "Range", "checking", "is", "initiated", "via", "the", "*", "voice->check_sample_sanity", "flag,", "*", "because", "it", "is", "impossible", "to", "check", "here:", "*", "During", "the", "voice", "setup,", "all", "modulators", "are", "processed,", "while", "*", "the", "voice", "is", "inactive.", "Therefore,", "illegal", "settings", "may", "*", "occur", "during", "the", "setup", "(for", "example:", "First", "move", "the", "loop", "*", "end", "point", "ahead", "of", "the", "loop", "start", "point", "=>", "invalid,", "then", "*", "move", "the", "loop", "start", "point", "forward", "=>", "valid", "again.", "*/", "case", "GEN_STARTADDROFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "0", "*/", "case", "GEN_STARTADDRCOARSEOFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "4", "*/", "if", "(", "voice", "->", "sample", "!=", "NULL", ")", "{", "z", "=", "(", "voice", "->", "sample", "->", "start", "+", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_STARTADDROFS", ")", "+", "32768", "*", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_STARTADDRCOARSEOFS", ")", ")", ";", "UPDATE_RVOICE_I1", "(", "fluid_rvoice_set_start", ",", "z", ")", ";", "}", "break;", "case", "GEN_ENDADDROFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "1", "*/", "case", "GEN_ENDADDRCOARSEOFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "12", "*/", "if", "(", "voice", "->", "sample", "!=", "NULL", ")", "{", "z", "=", "(", "voice", "->", "sample", "->", "end", "+", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_ENDADDROFS", ")", "+", "32768", "*", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_ENDADDRCOARSEOFS", ")", ")", ";", "UPDATE_RVOICE_I1", "(", "fluid_rvoice_set_end", ",", "z", ")", ";", "}", "break;", "case", "GEN_STARTLOOPADDROFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "2", "*/", "case", "GEN_STARTLOOPADDRCOARSEOFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "45", "*/", "if", "(", "voice", "->", "sample", "!=", "NULL", ")", "{", "z", "=", "(", "voice", "->", "sample", "->", "loopstart", "+", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_STARTLOOPADDROFS", ")", "+", "32768", "*", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_STARTLOOPADDRCOARSEOFS", ")", ")", ";", "UPDATE_RVOICE_I1", "(", "fluid_rvoice_set_loopstart", ",", "z", ")", ";", "}", "break;", "case", "GEN_ENDLOOPADDROFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "3", "*/", "case", "GEN_ENDLOOPADDRCOARSEOFS", ":", "/*", "SF2.01", "section", "8.1.3", "#", "50", "*/", "if", "(", "voice", "->", "sample", "!=", "NULL", ")", "{", "z", "=", "(", "voice", "->", "sample", "->", "loopend", "+", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_ENDLOOPADDROFS", ")", "+", "32768", "*", "(", "int", ")", "_GEN", "(", "voice", ",", "GEN_ENDLOOPADDRCOARSEOFS", ")", ")", ";", "UPDATE_RVOICE_I1", "(", "fluid_rvoice_set_loopend", ",", "z", ")", ";", "}", "break;", "/*", "Conversion", "functions", "differ", "in", "range", "limit", "*/", "#", "define", "NUM_BUFFERS_DELAY", "(", "_v", ")", "(unsigned", "int)", "(voice->output_rate", "*", "fluid_tc2sec_delay(_v)", "/", "FLUID_BUFSIZE)", "#", "define", "NUM_BUFFERS_ATTACK", "(", "_v", ")", "(unsigned", "int)", "(voice->output_rate", "*", "fluid_tc2sec_attack(_v)", "/", "FLUID_BUFSIZE)", "#", "define", "NUM_BUFFERS_RELEASE", "(", "_v", ")", "(unsigned", "int)", "(voice->output_rate", "*", "fluid_tc2sec_release(_v)", "/", "FLUID_BUFSIZE)", "/*", "volume", "envelope", "*", "*", "-", "delay", "and", "hold", "times", "are", "converted", "to", "absolute", "number", "of", "samples", "*", "-", "sustain", "is", "converted", "to", "its", "absolute", "value", "*", "-", "attack,", "decay", "and", "release", "are", "converted", "to", "their", "increment", "per", "sample", "*/", "case", "GEN_VOLENVDELAY", ":", "/*", "SF2.01", "section", "8.1.3", "#", "33", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_VOLENVDELAY", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0f", ",", "5000.0f", ")", ";", "count", "=", "NUM_BUFFERS_DELAY", "(", "x", ")", ";", "fluid_voice_update_volenv", "(", "voice", ",", "FLUID_VOICE_ENVDELAY", ",", "count", ",", "0.0f", ",", "0.0f", ",", "-", "1.0f", ",", "1.0f", ")", ";", "break;", "case", "GEN_VOLENVATTACK", ":", "/*", "SF2.01", "section", "8.1.3", "#", "34", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_VOLENVATTACK", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0f", ",", "8000.0f", ")", ";", "count", "=", "1", "+", "NUM_BUFFERS_ATTACK", "(", "x", ")", ";", "fluid_voice_update_volenv", "(", "voice", ",", "FLUID_VOICE_ENVATTACK", ",", "count", ",", "1.0f", ",", "count", "?", "1.0f", "/", "count", ":", "0.0f", ",", "-", "1.0f", ",", "1.0f", ")", ";", "break;", "case", "GEN_VOLENVHOLD", ":", "/*", "SF2.01", "section", "8.1.3", "#", "35", "*/", "case", "GEN_KEYTOVOLENVHOLD", ":", "/*", "SF2.01", "section", "8.1.3", "#", "39", "*/", "count", "=", "calculate_hold_decay_buffers", "(", "voice", ",", "GEN_VOLENVHOLD", ",", "GEN_KEYTOVOLENVHOLD", ",", "0", ")", ";", "/*", "0", "means:", "hold", "*/", "fluid_voice_update_volenv", "(", "voice", ",", "FLUID_VOICE_ENVHOLD", ",", "count", ",", "1.0f", ",", "0.0f", ",", "-", "1.0f", ",", "2.0f", ")", ";", "break;", "case", "GEN_VOLENVDECAY", ":", "/*", "SF2.01", "section", "8.1.3", "#", "36", "*/", "case", "GEN_VOLENVSUSTAIN", ":", "/*", "SF2.01", "section", "8.1.3", "#", "37", "*/", "case", "GEN_KEYTOVOLENVDECAY", ":", "/*", "SF2.01", "section", "8.1.3", "#", "40", "*/", "y", "=", "1.0f", "-", "0.001f", "*", "_GEN", "(", "voice", ",", "GEN_VOLENVSUSTAIN", ")", ";", "fluid_clip", "(", "y", ",", "0.0f", ",", "1.0f", ")", ";", "count", "=", "calculate_hold_decay_buffers", "(", "voice", ",", "GEN_VOLENVDECAY", ",", "GEN_KEYTOVOLENVDECAY", ",", "1", ")", ";", "/*", "1", "for", "decay", "*/", "fluid_voice_update_volenv", "(", "voice", ",", "FLUID_VOICE_ENVDECAY", ",", "count", ",", "1.0f", ",", "count", "?", "-", "1.0f", "/", "count", ":", "0.0f", ",", "y", ",", "2.0f", ")", ";", "break;", "case", "GEN_VOLENVRELEASE", ":", "/*", "SF2.01", "section", "8.1.3", "#", "38", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_VOLENVRELEASE", ")", ";", "fluid_clip", "(", "x", ",", "FLUID_MIN_VOLENVRELEASE", ",", "8000.0f", ")", ";", "count", "=", "1", "+", "NUM_BUFFERS_RELEASE", "(", "x", ")", ";", "fluid_voice_update_volenv", "(", "voice", ",", "FLUID_VOICE_ENVRELEASE", ",", "count", ",", "1.0f", ",", "count", "?", "-", "1.0f", "/", "count", ":", "0.0f", ",", "0.0f", ",", "1.0f", ")", ";", "break;", "/*", "Modulation", "envelope", "*/", "case", "GEN_MODENVDELAY", ":", "/*", "SF2.01", "section", "8.1.3", "#", "25", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODENVDELAY", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0f", ",", "5000.0f", ")", ";", "fluid_voice_update_modenv", "(", "voice", ",", "FLUID_VOICE_ENVDELAY", ",", "NUM_BUFFERS_DELAY", "(", "x", ")", ",", "0.0f", ",", "0.0f", ",", "-", "1.0f", ",", "1.0f", ")", ";", "break;", "case", "GEN_MODENVATTACK", ":", "/*", "SF2.01", "section", "8.1.3", "#", "26", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODENVATTACK", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0f", ",", "8000.0f", ")", ";", "count", "=", "1", "+", "NUM_BUFFERS_ATTACK", "(", "x", ")", ";", "fluid_voice_update_modenv", "(", "voice", ",", "FLUID_VOICE_ENVATTACK", ",", "count", ",", "1.0f", ",", "count", "?", "1.0f", "/", "count", ":", "0.0f", ",", "-", "1.0f", ",", "1.0f", ")", ";", "break;", "case", "GEN_MODENVHOLD", ":", "/*", "SF2.01", "section", "8.1.3", "#", "27", "*/", "case", "GEN_KEYTOMODENVHOLD", ":", "/*", "SF2.01", "section", "8.1.3", "#", "31", "*/", "count", "=", "calculate_hold_decay_buffers", "(", "voice", ",", "GEN_MODENVHOLD", ",", "GEN_KEYTOMODENVHOLD", ",", "0", ")", ";", "/*", "1", "means:", "hold", "*/", "fluid_voice_update_modenv", "(", "voice", ",", "FLUID_VOICE_ENVHOLD", ",", "count", ",", "1.0f", ",", "0.0f", ",", "-", "1.0f", ",", "2.0f", ")", ";", "break;", "case", "GEN_MODENVDECAY", ":", "/*", "SF", "2.01", "section", "8.1.3", "#", "28", "*/", "case", "GEN_MODENVSUSTAIN", ":", "/*", "SF", "2.01", "section", "8.1.3", "#", "29", "*/", "case", "GEN_KEYTOMODENVDECAY", ":", "/*", "SF", "2.01", "section", "8.1.3", "#", "32", "*/", "count", "=", "calculate_hold_decay_buffers", "(", "voice", ",", "GEN_MODENVDECAY", ",", "GEN_KEYTOMODENVDECAY", ",", "1", ")", ";", "/*", "1", "for", "decay", "*/", "y", "=", "1.0f", "-", "0.001f", "*", "_GEN", "(", "voice", ",", "GEN_MODENVSUSTAIN", ")", ";", "fluid_clip", "(", "y", ",", "0.0f", ",", "1.0f", ")", ";", "fluid_voice_update_modenv", "(", "voice", ",", "FLUID_VOICE_ENVDECAY", ",", "count", ",", "1.0f", ",", "count", "?", "-", "1.0f", "/", "count", ":", "0.0f", ",", "y", ",", "2.0f", ")", ";", "break;", "case", "GEN_MODENVRELEASE", ":", "/*", "SF", "2.01", "section", "8.1.3", "#", "30", "*/", "x", "=", "_GEN", "(", "voice", ",", "GEN_MODENVRELEASE", ")", ";", "fluid_clip", "(", "x", ",", "-", "12000.0f", ",", "8000.0f", ")", ";", "count", "=", "1", "+", "NUM_BUFFERS_RELEASE", "(", "x", ")", ";", "fluid_voice_update_modenv", "(", "voice", ",", "FLUID_VOICE_ENVRELEASE", ",", "count", ",", "1.0f", ",", "count", "?", "-", "1.0f", "/", "count", ":", "0.0f", ",", "0.0f", ",", "2.0f", ")", ";", "break;", "}", "/*", "switch", "gen", "*/", "}'" ]

[ "Adds", "a", "modulator", "to", "the", "voice" ]

[ "'void", "fluid_voice_add_mod", "(", "fluid_voice_t", "*", "voice", ",", "fluid_mod_t", "*", "mod", ",", "int", "mode", ")", "{", "int", "i", ";", "/*", "*", "Some", "soundfonts", "come", "with", "a", "huge", "number", "of", "non-standard", "*", "controllers,", "because", "they", "have", "been", "designed", "for", "one", "particular", "*", "sound", "card.", "Discard", "them,", "maybe", "print", "a", "warning.", "*/", "if", "(", "(", "(", "mod", "->", "flags1", "&", "FLUID_MOD_CC", ")", "==", "0", ")", "&&", "(", "(", "mod", "->", "src1", "!=", "0", ")", "/*", "SF2.01", "section", "8.2.1:", "Constant", "value", "*/", "&&", "(", "mod", "->", "src1", "!=", "2", ")", "/*", "Note-on", "velocity", "*/", "&&", "(", "mod", "->", "src1", "!=", "3", ")", "/*", "Note-on", "key", "number", "*/", "&&", "(", "mod", "->", "src1", "!=", "10", ")", "/*", "Poly", "pressure", "*/", "&&", "(", "mod", "->", "src1", "!=", "13", ")", "/*", "Channel", "pressure", "*/", "&&", "(", "mod", "->", "src1", "!=", "14", ")", "/*", "Pitch", "wheel", "*/", "&&", "(", "mod", "->", "src1", "!=", "16", ")", ")", ")", "{", "/*", "Pitch", "wheel", "sensitivity", "*/", "FLUID_LOG", "(", "FLUID_WARN", ",", "\"Ignoring", "invalid", "controller,", "using", "non-CC", "source", "%i.\"", ",", "mod", "->", "src1", ")", ";", "return", ";", "}", "if", "(", "mode", "==", "FLUID_VOICE_ADD", ")", "{", "/*", "if", "identical", "modulator", "exists,", "add", "them", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "voice", "->", "mod_count", ";", "i", "++", ")", "{", "if", "(", "fluid_mod_test_identity", "(", "&", "voice", "->", "mod", "[", "i", "]", ",", "mod", ")", ")", "{", "//", "printf(\"Adding", "modulator...\\\");", "voice", "->", "mod", "[", "i", "]", ".", "amount", "+=", "mod", "->", "amount", ";", "return", ";", "}", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "mode", "==", "FLUID_VOICE_OVERWRITE", ")", "{", "/*", "if", "identical", "modulator", "exists,", "replace", "it", "(only", "the", "amount", "has", "to", "be", "changed)", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "voice", "->", "mod_count", ";", "i", "++", ")", "{", "if", "(", "fluid_mod_test_identity", "(", "&", "voice", "->", "mod", "[", "i", "]", ",", "mod", ")", ")", "{", "//", "printf(\"Replacing", "modulator...amount", "is", "%f\\\",mod->amount);", "voice", "->", "mod", "[", "i", "]", ".", "amount", "=", "mod", "->", "amount", ";", "return", ";", "}", "}", "}", "/*", "Add", "a", "new", "modulator", "(No", "existing", "modulator", "to", "add", "/", "overwrite).", "Also,", "default", "modulators", "(FLUID_VOICE_DEFAULT)", "are", "added", "without", "checking,", "if", "the", "same", "modulator", "already", "exists.", "*/", "if", "(", "voice", "->", "mod_count", "<", "FLUID_NUM_MOD", ")", "{", "fluid_mod_clone", "(", "&", "voice", "->", "mod", "[", "voice", "->", "mod_count", "++", "]", ",", "mod", ")", ";", "}", "}'" ]

[ "Set", "the", "value", "of", "a", "generator" ]

[ "'void", "fluid_voice_gen_set", "(", "fluid_voice_t", "*", "voice", ",", "int", "i", ",", "float", "val", ")", "{", "voice", "->", "gen", "[", "i", "]", ".", "val", "=", "val", ";", "voice", "->", "gen", "[", "i", "]", ".", "flags", "=", "GEN_SET", ";", "if", "(", "i", "==", "GEN_SAMPLEMODE", ")", "UPDATE_RVOICE_I1", "(", "fluid_rvoice_set_samplemode", ",", "(", "int", ")", "val", ")", ";", "}'" ]

[ "Mix", "voice", "data", "to", "left", "right", "(panning),", "reverb", "and", "chorus", "buffers" ]

[ "'void", "fluid_voice_mix", "(", "fluid_voice_t", "*", "voice", ",", "int", "count", ",", "fluid_real_t", "*", "dsp_buf", ",", "fluid_real_t", "*", "left_buf", ",", "fluid_real_t", "*", "right_buf", ",", "fluid_real_t", "*", "reverb_buf", ",", "fluid_real_t", "*", "chorus_buf", ")", "{", "fluid_rvoice_buffers_t", "buffers", ";", "fluid_real_t", "*", "dest_buf", "[", "4", "]", "=", "{", "left_buf", ",", "right_buf", ",", "reverb_buf", ",", "chorus_buf", "}", ";", "fluid_rvoice_buffers_set_amp", "(", "&", "buffers", ",", "0", ",", "voice", "->", "amp_left", ")", ";", "fluid_rvoice_buffers_set_amp", "(", "&", "buffers", ",", "1", ",", "voice", "->", "amp_right", ")", ";", "fluid_rvoice_buffers_set_amp", "(", "&", "buffers", ",", "2", ",", "voice", "->", "amp_reverb", ")", ";", "fluid_rvoice_buffers_set_amp", "(", "&", "buffers", ",", "3", ",", "voice", "->", "amp_chorus", ")", ";", "fluid_rvoice_buffers_mix", "(", "&", "buffers", ",", "dsp_buf", ",", "count", ",", "dest_buf", ",", "4", ")", ";", "fluid_check_fpe", "(", "\"voice_mix\"", ")", ";", "}'" ]

[ "Check", "if", "a", "voice", "is", "still", "playing" ]

[ "'int", "fluid_voice_is_playing", "(", "fluid_voice_t", "*", "voice", ")", "{", "return", "_PLAYING", "(", "voice", ")", ";", "}'" ]

[ "Synthesize", "a", "voice", "to", "a", "buffer" ]

[ "'int", "fluid_voice_write", "(", "fluid_voice_t", "*", "voice", ",", "fluid_real_t", "*", "dsp_buf", ")", "{", "int", "result", ";", "if", "(", "!", "voice", "->", "can_access_rvoice", ")", "return", "0", ";", "result", "=", "fluid_rvoice_write", "(", "voice", "->", "rvoice", ",", "dsp_buf", ")", ";", "if", "(", "result", "==", "-", "1", ")", "return", "0", ";", "if", "(", "(", "result", "<", "FLUID_BUFSIZE", ")", "&&", "_PLAYING", "(", "voice", ")", ")", "/*", "Voice", "finished", "by", "itself", "*/", "fluid_voice_off", "(", "voice", ")", ";", "return", "result", ";", "}'" ]

[ "Turns", "off", "a", "voice,", "meaning", "that", "it", "is", "not", "processed", "anymore", "by", "the", "DSP", "loop" ]

[ "'int", "fluid_voice_off", "(", "fluid_voice_t", "*", "voice", ")", "{", "fluid_profile", "(", "FLUID_PROF_VOICE_RELEASE", ",", "voice", "->", "ref", ")", ";", "voice", "->", "chan", "=", "NO_CHANNEL", ";", "UPDATE_RVOICE0", "(", "fluid_rvoice_voiceoff", ")", ";", "if", "(", "voice", "->", "can_access_rvoice", ")", "fluid_sample_null_ptr", "(", "&", "voice", "->", "rvoice", "->", "dsp", ".", "sample", ")", ";", "voice", "->", "status", "=", "FLUID_VOICE_OFF", ";", "voice", "->", "has_noteoff", "=", "1", ";", "/*", "Decrement", "the", "reference", "count", "of", "the", "sample.", "*/", "fluid_sample_null_ptr", "(", "&", "voice", "->", "sample", ")", ";", "/*", "Decrement", "voice", "count", "*/", "voice", "->", "channel", "->", "synth", "->", "active_voice_count", "--", ";", "return", "FLUID_OK", ";", "}'" ]

[ "Get", "the", "unique", "ID", "of", "the", "noteonevent" ]

[ "'unsigned", "int", "fluid_voice_get_id", "(", "fluid_voice_t", "*", "voice", ")", "{", "return", "voice", "->", "id", ";", "}'" ]

[ "Scan", "the", "loop", "determine", "the", "peak", "level", "Calculate,", "what", "factor", "will", "make", "the", "loop", "inaudible", "Store", "in", "sample", "Calculate", "the", "peak", "volume", "of", "a", "sample", "for", "voice", "off", "optimization" ]

[ "'int", "fluid_voice_optimize_sample", "(", "fluid_sample_t", "*", "s", ")", "{", "signed", "short", "peak_max", "=", "0", ";", "signed", "short", "peak_min", "=", "0", ";", "signed", "short", "peak", ";", "fluid_real_t", "normalized_amplitude_during_loop", ";", "double", "result", ";", "int", "i", ";", "/*", "ignore", "ROM", "and", "other(?)", "invalid", "samples", "*/", "if", "(", "!", "s", "->", "valid", ")", "return", "(", "FLUID_OK", ")", ";", "if", "(", "!", "s", "->", "amplitude_that_reaches_noise_floor_is_valid", ")", "{", "/*", "Only", "once", "*/", "/*", "Scan", "the", "loop", "*/", "for", "(", "i", "=", "(", "int", ")", "s", "->", "loopstart", ";", "i", "<", "(", "int", ")", "s", "->", "loopend", ";", "i", "++", ")", "{", "signed", "short", "val", "=", "s", "->", "data", "[", "i", "]", ";", "if", "(", "val", ">", "peak_max", ")", "{", "peak_max", "=", "val", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "val", "<", "peak_min", ")", "{", "peak_min", "=", "val", ";", "}", "}", "/*", "Determine", "the", "peak", "level", "*/", "if", "(", "peak_max", ">", "-", "peak_min", ")", "{", "peak", "=", "peak_max", ";", "}", "else", "{", "peak", "=", "-", "peak_min", ";", "}", ";", "if", "(", "peak", "==", "0", ")", "{", "/*", "Avoid", "division", "by", "zero", "*/", "peak", "=", "1", ";", "}", ";", "/*", "Calculate", "what", "factor", "will", "make", "the", "loop", "inaudible", "*", "For", "example:", "Take", "a", "peak", "of", "3277", "(10", "%", "of", "32768).", "The", "*", "normalized", "amplitude", "is", "0.1", "(10", "%", "of", "32768).", "An", "amplitude", "*", "factor", "of", "0.0001", "(as", "opposed", "to", "the", "default", "0.00001)", "will", "*", "drop", "this", "sample", "to", "the", "noise", "floor.", "*/", "/*", "16", "bits", "=>", "96+4=100", "dB", "dynamic", "range", "=>", "0.00001", "*/", "normalized_amplitude_during_loop", "=", "(", "(", "fluid_real_t", ")", "peak", ")", "/", "32768.", ";", "result", "=", "FLUID_NOISE_FLOOR", "/", "normalized_amplitude_during_loop", ";", "/*", "Store", "in", "sample", "*/", "s", "->", "amplitude_that_reaches_noise_floor", "=", "(", "double", ")", "result", ";", "s", "->", "amplitude_that_reaches_noise_floor_is_valid", "=", "1", ";", "#", "if", "0", "printf(\"Sample", "peak", "detection:", "factor", "%f\\\",", "(double)result);", "#", "endif", "}", ";", "return", "FLUID_OK", ";", "}'" ]

[ "Wrap", "the", "calls", "made", "by", "a", "loaded", "image" ]

[ "'void", "efi_wrap", "(", "EFI_HANDLE", "handle", ")", "{", "EFI_BOOT_SERVICES", "*", "bs", "=", "efi_systab", "->", "BootServices", ";", "union", "{", "EFI_LOADED_IMAGE_PROTOCOL", "*", "image", ";", "void", "*", "intf", ";", "}", "loaded", ";", "EFI_STATUS", "efirc", ";", "int", "rc", ";", "/*", "Do", "nothing", "unless", "debugging", "is", "enabled", "*/", "if", "(", "!", "DBG_LOG", ")", "return", ";", "/*", "Populate", "table", "wrappers", "*/", "memcpy", "(", "&", "efi_systab_wrapper", ",", "efi_systab", ",", "sizeof", "(", "efi_systab_wrapper", ")", ")", ";", "memcpy", "(", "&", "efi_bs_wrapper", ",", "bs", ",", "sizeof", "(", "efi_bs_wrapper", ")", ")", ";", "efi_systab_wrapper", ".", "BootServices", "=", "&", "efi_bs_wrapper", ";", "efi_bs_wrapper", ".", "InstallProtocolInterface", "=", "efi_install_protocol_interface_wrapper", ";", "efi_bs_wrapper", ".", "ReinstallProtocolInterface", "=", "efi_reinstall_protocol_interface_wrapper", ";", "efi_bs_wrapper", ".", "UninstallProtocolInterface", "=", "efi_uninstall_protocol_interface_wrapper", ";", "efi_bs_wrapper", ".", "HandleProtocol", "=", "efi_handle_protocol_wrapper", ";", "efi_bs_wrapper", ".", "LocateHandle", "=", "efi_locate_handle_wrapper", ";", "efi_bs_wrapper", ".", "LocateDevicePath", "=", "efi_locate_device_path_wrapper", ";", "efi_bs_wrapper", ".", "LoadImage", "=", "efi_load_image_wrapper", ";", "efi_bs_wrapper", ".", "StartImage", "=", "efi_start_image_wrapper", ";", "efi_bs_wrapper", ".", "Exit", "=", "efi_exit_wrapper", ";", "efi_bs_wrapper", ".", "UnloadImage", "=", "efi_unload_image_wrapper", ";", "efi_bs_wrapper", ".", "ExitBootServices", "=", "efi_exit_boot_services_wrapper", ";", "efi_bs_wrapper", ".", "ConnectController", "=", "efi_connect_controller_wrapper", ";", "efi_bs_wrapper", ".", "DisconnectController", "=", "efi_disconnect_controller_wrapper", ";", "efi_bs_wrapper", ".", "OpenProtocol", "=", "efi_open_protocol_wrapper", ";", "efi_bs_wrapper", ".", "CloseProtocol", "=", "efi_close_protocol_wrapper", ";", "efi_bs_wrapper", ".", "ProtocolsPerHandle", "=", "efi_protocols_per_handle_wrapper", ";", "efi_bs_wrapper", ".", "LocateHandleBuffer", "=", "efi_locate_handle_buffer_wrapper", ";", "efi_bs_wrapper", ".", "LocateProtocol", "=", "efi_locate_protocol_wrapper", ";", "/*", "Open", "loaded", "image", "protocol", "*/", "if", "(", "(", "efirc", "=", "bs", "->", "OpenProtocol", "(", "handle", ",", "&", "efi_loaded_image_protocol_guid", ",", "&", "loaded", ".", "intf", ",", "efi_image_handle", ",", "NULL", ",", "EFI_OPEN_PROTOCOL_GET_PROTOCOL", ")", ")", "!=", "0", ")", "{", "rc", "=", "-", "EEFI", "(", "efirc", ")", ";", "DBGC", "(", "colour", ",", "\"WRAP", "%s", "could", "not", "get", "loaded", "image", "protocol:", "\"", "\"%s\\\"", ",", "efi_handle_name", "(", "handle", ")", ",", "strerror", "(", "rc", ")", ")", ";", "return", ";", "}", "/*", "Provide", "system", "table", "wrapper", "to", "image", "*/", "loaded", ".", "image", "->", "SystemTable", "=", "&", "efi_systab_wrapper", ";", "DBGC", "(", "colour", ",", "\"WRAP", "%s", "at", "base", "%p", "has", "protocols:\\\"", ",", "efi_handle_name", "(", "handle", ")", ",", "loaded", ".", "image", "->", "ImageBase", ")", ";", "DBGC_EFI_PROTOCOLS", "(", "colour", ",", "handle", ")", ";", "DBGC", "(", "colour", ",", "\"WRAP", "%s", "parent\"", ",", "efi_handle_name", "(", "handle", ")", ")", ";", "DBGC", "(", "colour", ",", "\"", "%s\\\"", ",", "efi_handle_name", "(", "loaded", ".", "image", "->", "ParentHandle", ")", ")", ";", "DBGC", "(", "colour", ",", "\"WRAP", "%s", "device\"", ",", "efi_handle_name", "(", "handle", ")", ")", ";", "DBGC", "(", "colour", ",", "\"", "%s\\\"", ",", "efi_handle_name", "(", "loaded", ".", "image", "->", "DeviceHandle", ")", ")", ";", "DBGC", "(", "colour", ",", "\"WRAP", "%s", "file\"", ",", "efi_handle_name", "(", "handle", ")", ")", ";", "DBGC", "(", "colour", ",", "\"", "%s\\\"", ",", "efi_devpath_text", "(", "loaded", ".", "image", "->", "FilePath", ")", ")", ";", "/*", "Close", "loaded", "image", "protocol", "*/", "bs", "->", "CloseProtocol", "(", "handle", ",", "&", "efi_loaded_image_protocol_guid", ",", "efi_image_handle", ",", "NULL", ")", ";", "}'" ]

[ "Gets", "the", "TIMx", "Prescaler", "value" ]

[ "'uint16_t", "TIM_GetPrescaler", "(", "TIM_TypeDef", "*", "TIMx", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_ALL_PERIPH", "(", "TIMx", ")", ")", ";", "/*", "Get", "the", "Prescaler", "Register", "value", "*/", "return", "TIMx", "->", "PSC", ";", "}'" ]

[ "Sets", "the", "TIMx", "Capture", "Compare5", "Register", "value" ]

[ "'void", "TIM_SetCompare5", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint32_t", "Compare5", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST4_PERIPH", "(", "TIMx", ")", ")", ";", "/*", "Set", "the", "Capture", "Compare5", "Register", "value", "*/", "TIMx", "->", "CCR5", "=", "Compare5", ";", "}'" ]

[ "Configure", "the", "TI1", "as", "Input" ]

[ "'static", "void", "TI1_Config", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint16_t", "TIM_ICPolarity", ",", "uint16_t", "TIM_ICSelection", ",", "uint16_t", "TIM_ICFilter", ")", "{", "uint32_t", "tmpccmr1", "=", "0", ",", "<type", "ref=\"prev\"/>", "tmpccer", "=", "0", ";", "/*", "Disable", "the", "Channel", "1:", "Reset", "the", "CC1E", "Bit", "*/", "TIMx", "->", "CCER", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC1E", ";", "tmpccmr1", "=", "TIMx", "->", "CCMR1", ";", "tmpccer", "=", "TIMx", "->", "CCER", ";", "/*", "Select", "the", "Input", "and", "set", "the", "filter", "*/", "tmpccmr1", "&=", "(", "(", "uint32_t", ")", "~", "TIM_CCMR1_CC1S", ")", "&", "(", "(", "uint32_t", ")", "~", "TIM_CCMR1_IC1F", ")", ";", "tmpccmr1", "|=", "(", "uint32_t", ")", "(", "TIM_ICSelection", "|", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "TIM_ICFilter", "<<", "4", ")", ")", ";", "/*", "Select", "the", "Polarity", "and", "set", "the", "CC1E", "Bit", "*/", "tmpccer", "&=", "(", "uint32_t", ")", "~", "(", "TIM_CCER_CC1P", "|", "TIM_CCER_CC1NP", ")", ";", "tmpccer", "|=", "(", "uint32_t", ")", "(", "TIM_ICPolarity", "|", "(", "uint32_t", ")", "TIM_CCER_CC1E", ")", ";", "/*", "Write", "to", "TIMx", "CCMR1", "and", "CCER", "registers", "*/", "TIMx", "->", "CCMR1", "=", "tmpccmr1", ";", "TIMx", "->", "CCER", "=", "tmpccer", ";", "}'" ]

[ "Enables", "or", "disables", "the", "TIM", "peripheral", "Main", "Outputs" ]

[ "'void", "TIM_CtrlPWMOutputs", "(", "TIM_TypeDef", "*", "TIMx", ",", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST6_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "/*", "Enable", "the", "TIM", "Main", "Output", "*/", "TIMx", "->", "BDTR", "|=", "TIM_BDTR_MOE", ";", "}", "else", "{", "/*", "Disable", "the", "TIM", "Main", "Output", "*/", "TIMx", "->", "BDTR", "&=", "(", "uint16_t", ")", "~", "TIM_BDTR_MOE", ";", "}", "}'" ]

[ "Configures", "the", "Break2", "feature" ]

[ "'void", "TIM_Break2Config", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint32_t", "TIM_Break2Polarity", ",", "uint8_t", "TIM_Break2Filter", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST4_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_BREAK2_FILTER", "(", "TIM_Break2Filter", ")", ")", ";", "/*", "Reset", "the", "BKP", "and", "BKF", "Bits", "*/", "TIMx", "->", "BDTR", "&=", "(", "uint32_t", ")", "~", "(", "TIM_BDTR_BK2P", "|", "TIM_BDTR_BK2F", ")", ";", "/*", "Configure", "the", "Break1", "polarity", "and", "filter", "*/", "TIMx", "->", "BDTR", "|=", "TIM_Break2Polarity", "|", "(", "(", "uint32_t", ")", "TIM_Break2Filter", "<<", "20", ")", ";", "}'" ]

[ "Configures", "the", "TIMx", "channel", "6", "polarity" ]

[ "'void", "TIM_OC6PolarityConfig", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint16_t", "TIM_OCPolarity", ")", "{", "uint32_t", "tmpccer", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST4_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_OC_POLARITY", "(", "TIM_OCPolarity", ")", ")", ";", "tmpccer", "=", "TIMx", "->", "CCER", ";", "/*", "Set", "or", "Reset", "the", "CC6P", "Bit", "*/", "tmpccer", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC6P", ";", "tmpccer", "|=", "(", "(", "uint32_t", ")", "TIM_OCPolarity", "<<", "20", ")", ";", "/*", "Write", "to", "TIMx", "CCER", "register", "*/", "TIMx", "->", "CCER", "=", "tmpccer", ";", "}'" ]

[ "Selects", "the", "TIM", "Output", "Compare", "Mode" ]

[ "'void", "TIM_SelectOCxM", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint16_t", "TIM_Channel", ",", "uint32_t", "TIM_OCMode", ")", "{", "uint32_t", "tmp", "=", "0", ";", "uint16_t", "tmp1", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST1_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_CHANNEL", "(", "TIM_Channel", ")", ")", ";", "assert_param", "(", "IS_TIM_OCM", "(", "TIM_OCMode", ")", ")", ";", "tmp", "=", "(", "uint32_t", ")", "TIMx", ";", "tmp", "+=", "CCMR_OFFSET", ";", "tmp1", "=", "CCER_CCE_SET", "<<", "(", "uint16_t", ")", "TIM_Channel", ";", "/*", "Disable", "the", "Channel:", "Reset", "the", "CCxE", "Bit", "*/", "TIMx", "->", "CCER", "&=", "(", "uint16_t", ")", "~", "tmp1", ";", "if", "(", "(", "TIM_Channel", "==", "TIM_Channel_1", ")", "||", "(", "TIM_Channel", "==", "TIM_Channel_3", ")", ")", "{", "tmp", "+=", "(", "TIM_Channel", ">>", "1", ")", ";", "/*", "Reset", "the", "OCxM", "bits", "in", "the", "CCMRx", "register", "*/", "*", "(", "__IO", "uint32_t", "*", ")", "tmp", "&=", "CCMR_OC13M_MASK", ";", "/*", "Configure", "the", "OCxM", "bits", "in", "the", "CCMRx", "register", "*/", "*", "(", "__IO", "uint32_t", "*", ")", "tmp", "|=", "TIM_OCMode", ";", "}", "else", "{", "tmp", "+=", "(", "uint32_t", ")", "(", "TIM_Channel", "-", "(", "uint32_t", ")", "4", ")", ">>", "(", "uint32_t", ")", "1", ";", "/*", "Reset", "the", "OCxM", "bits", "in", "the", "CCMRx", "register", "*/", "*", "(", "__IO", "uint32_t", "*", ")", "tmp", "&=", "CCMR_OC24M_MASK", ";", "/*", "Configure", "the", "OCxM", "bits", "in", "the", "CCMRx", "register", "*/", "*", "(", "__IO", "uint32_t", "*", ")", "tmp", "|=", "(", "uint32_t", ")", "(", "TIM_OCMode", "<<", "8", ")", ";", "}", "}'" ]

[ "Output", "Compare", "management", "functions" ]

[ "'void", "TIM_OC1Init", "(", "TIM_TypeDef", "*", "TIMx", ",", "TIM_OCInitTypeDef", "*", "TIM_OCInitStruct", ")", "{", "uint32_t", "tmpccmrx", "=", "0", ",", "<type", "ref=\"prev\"/>", "tmpccer", "=", "0", ",", "<type", "ref=\"prev\"/>", "tmpcr2", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST1_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_OC_MODE", "(", "TIM_OCInitStruct", "->", "TIM_OCMode", ")", ")", ";", "assert_param", "(", "IS_TIM_OUTPUT_STATE", "(", "TIM_OCInitStruct", "->", "TIM_OutputState", ")", ")", ";", "assert_param", "(", "IS_TIM_OC_POLARITY", "(", "TIM_OCInitStruct", "->", "TIM_OCPolarity", ")", ")", ";", "/*", "Disable", "the", "Channel", "1:", "Reset", "the", "CC1E", "Bit", "*/", "TIMx", "->", "CCER", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC1E", ";", "/*", "Get", "the", "TIMx", "CCER", "register", "value", "*/", "tmpccer", "=", "TIMx", "->", "CCER", ";", "/*", "Get", "the", "TIMx", "CR2", "register", "value", "*/", "tmpcr2", "=", "TIMx", "->", "CR2", ";", "/*", "Get", "the", "TIMx", "CCMR1", "register", "value", "*/", "tmpccmrx", "=", "TIMx", "->", "CCMR1", ";", "/*", "Reset", "the", "Output", "Compare", "Mode", "Bits", "*/", "tmpccmrx", "&=", "(", "uint32_t", ")", "~", "TIM_CCMR1_OC1M", ";", "tmpccmrx", "&=", "(", "uint32_t", ")", "~", "TIM_CCMR1_CC1S", ";", "/*", "Select", "the", "Output", "Compare", "Mode", "*/", "tmpccmrx", "|=", "TIM_OCInitStruct", "->", "TIM_OCMode", ";", "/*", "Reset", "the", "Output", "Polarity", "level", "*/", "tmpccer", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC1P", ";", "/*", "Set", "the", "Output", "Compare", "Polarity", "*/", "tmpccer", "|=", "TIM_OCInitStruct", "->", "TIM_OCPolarity", ";", "/*", "Set", "the", "Output", "State", "*/", "tmpccer", "|=", "TIM_OCInitStruct", "->", "TIM_OutputState", ";", "if", "(", "(", "TIMx", "==", "TIM1", ")", "||", "(", "TIMx", "==", "TIM8", ")", "||", "(", "TIMx", "==", "TIM15", ")", "||", "(", "TIMx", "==", "TIM16", ")", "||", "(", "TIMx", "==", "TIM17", ")", ")", "{", "assert_param", "(", "IS_TIM_OUTPUTN_STATE", "(", "TIM_OCInitStruct", "->", "TIM_OutputNState", ")", ")", ";", "assert_param", "(", "IS_TIM_OCN_POLARITY", "(", "TIM_OCInitStruct", "->", "TIM_OCNPolarity", ")", ")", ";", "assert_param", "(", "IS_TIM_OCNIDLE_STATE", "(", "TIM_OCInitStruct", "->", "TIM_OCNIdleState", ")", ")", ";", "assert_param", "(", "IS_TIM_OCIDLE_STATE", "(", "TIM_OCInitStruct", "->", "TIM_OCIdleState", ")", ")", ";", "/*", "Reset", "the", "Output", "N", "Polarity", "level", "*/", "tmpccer", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC1NP", ";", "/*", "Set", "the", "Output", "N", "Polarity", "*/", "tmpccer", "|=", "TIM_OCInitStruct", "->", "TIM_OCNPolarity", ";", "/*", "Reset", "the", "Output", "N", "State", "*/", "tmpccer", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC1NE", ";", "/*", "Set", "the", "Output", "N", "State", "*/", "tmpccer", "|=", "TIM_OCInitStruct", "->", "TIM_OutputNState", ";", "/*", "Reset", "the", "Output", "Compare", "and", "Output", "Compare", "N", "IDLE", "State", "*/", "tmpcr2", "&=", "(", "uint32_t", ")", "~", "TIM_CR2_OIS1", ";", "tmpcr2", "&=", "(", "uint32_t", ")", "~", "TIM_CR2_OIS1N", ";", "/*", "Set", "the", "Output", "Idle", "state", "*/", "tmpcr2", "|=", "TIM_OCInitStruct", "->", "TIM_OCIdleState", ";", "/*", "Set", "the", "Output", "N", "Idle", "state", "*/", "tmpcr2", "|=", "TIM_OCInitStruct", "->", "TIM_OCNIdleState", ";", "}", "/*", "Write", "to", "TIMx", "CR2", "*/", "TIMx", "->", "CR2", "=", "tmpcr2", ";", "/*", "Write", "to", "TIMx", "CCMR1", "*/", "TIMx", "->", "CCMR1", "=", "tmpccmrx", ";", "/*", "Set", "the", "Capture", "Compare", "Register", "value", "*/", "TIMx", "->", "CCR1", "=", "TIM_OCInitStruct", "->", "TIM_Pulse", ";", "/*", "Write", "to", "TIMx", "CCER", "*/", "TIMx", "->", "CCER", "=", "tmpccer", ";", "}'" ]

[ "Sets", "or", "resets", "the", "update", "interrupt", "flag", "(UIF)status", "bit", "Remapping" ]

[ "'void", "TIM_UIFRemap", "(", "TIM_TypeDef", "*", "TIMx", ",", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_ALL_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "/*", "Enable", "the", "TIM", "Counter", "*/", "TIMx", "->", "CR1", "|=", "TIM_CR1_UIFREMAP", ";", "}", "else", "{", "/*", "Disable", "the", "TIM", "Counter", "*/", "TIMx", "->", "CR1", "&=", "(", "uint16_t", ")", "~", "TIM_CR1_UIFREMAP", ";", "}", "}'" ]

[ "Gets", "the", "TIMx", "Input", "Capture", "1", "value" ]

[ "'uint32_t", "TIM_GetCapture1", "(", "TIM_TypeDef", "*", "TIMx", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST1_PERIPH", "(", "TIMx", ")", ")", ";", "/*", "Get", "the", "Capture", "1", "Register", "value", "*/", "return", "TIMx", "->", "CCR1", ";", "}'" ]

[ "Clears", "or", "safeguards", "the", "OCREF3", "signal", "on", "an", "external", "event" ]

[ "'void", "TIM_ClearOC3Ref", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint16_t", "TIM_OCClear", ")", "{", "uint32_t", "tmpccmr2", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST3_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_OCCLEAR_STATE", "(", "TIM_OCClear", ")", ")", ";", "tmpccmr2", "=", "TIMx", "->", "CCMR2", ";", "/*", "Reset", "the", "OC3CE", "Bit", "*/", "tmpccmr2", "&=", "(", "uint32_t", ")", "~", "TIM_CCMR2_OC3CE", ";", "/*", "Enable", "or", "Disable", "the", "Output", "Compare", "Clear", "Bit", "*/", "tmpccmr2", "|=", "TIM_OCClear", ";", "/*", "Write", "to", "TIMx", "CCMR2", "register", "*/", "TIMx", "->", "CCMR2", "=", "tmpccmr2", ";", "}'" ]

[ "Enables", "or", "disables", "the", "TIMx's", "DMA", "Requests" ]

[ "'void", "TIM_DMACmd", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint16_t", "TIM_DMASource", ",", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_ALL_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_DMA_SOURCE", "(", "TIM_DMASource", ")", ")", ";", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "if", "(", "NewState", "!=", "DISABLE", ")", "{", "/*", "Enable", "the", "DMA", "sources", "*/", "TIMx", "->", "DIER", "|=", "TIM_DMASource", ";", "}", "else", "{", "/*", "Disable", "the", "DMA", "sources", "*/", "TIMx", "->", "DIER", "&=", "(", "uint16_t", ")", "~", "TIM_DMASource", ";", "}", "}'" ]

[ "Initializes", "the", "TIMx", "Channel5", "according", "to", "the", "specified", "parameters" ]

[ "'void", "TIM_OC5Init", "(", "TIM_TypeDef", "*", "TIMx", ",", "TIM_OCInitTypeDef", "*", "TIM_OCInitStruct", ")", "{", "uint32_t", "tmpccmrx", "=", "0", ",", "<type", "ref=\"prev\"/>", "tmpccer", "=", "0", ",", "<type", "ref=\"prev\"/>", "tmpcr2", "=", "0", ";", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST4_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_OC_MODE", "(", "TIM_OCInitStruct", "->", "TIM_OCMode", ")", ")", ";", "assert_param", "(", "IS_TIM_OUTPUT_STATE", "(", "TIM_OCInitStruct", "->", "TIM_OutputState", ")", ")", ";", "assert_param", "(", "IS_TIM_OC_POLARITY", "(", "TIM_OCInitStruct", "->", "TIM_OCPolarity", ")", ")", ";", "/*", "Disable", "the", "Channel", "5:", "Reset", "the", "CC5E", "Bit", "*/", "TIMx", "->", "CCER", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC5E", ";", "/*", "to", "be", "verified*/", "/*", "Get", "the", "TIMx", "CCER", "register", "value", "*/", "tmpccer", "=", "TIMx", "->", "CCER", ";", "/*", "Get", "the", "TIMx", "CR2", "register", "value", "*/", "tmpcr2", "=", "TIMx", "->", "CR2", ";", "/*", "Get", "the", "TIMx", "CCMR3", "register", "value", "*/", "tmpccmrx", "=", "TIMx", "->", "CCMR3", ";", "/*", "Reset", "the", "Output", "Compare", "mode", "and", "Capture/Compare", "selection", "Bits", "*/", "tmpccmrx", "&=", "(", "uint32_t", ")", "~", "TIM_CCMR3_OC5M", ";", "/*", "Select", "the", "Output", "Compare", "Mode", "*/", "tmpccmrx", "|=", "(", "uint32_t", ")", "(", "TIM_OCInitStruct", "->", "TIM_OCMode", ")", ";", "/*", "Reset", "the", "Output", "Polarity", "level", "*/", "tmpccer", "&=", "(", "uint32_t", ")", "~", "TIM_CCER_CC5P", ";", "/*", "Set", "the", "Output", "Compare", "Polarity", "*/", "tmpccer", "|=", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "TIM_OCInitStruct", "->", "TIM_OCPolarity", "<<", "16", ")", ";", "/*", "Set", "the", "Output", "State", "*/", "tmpccer", "|=", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "TIM_OCInitStruct", "->", "TIM_OutputState", "<<", "16", ")", ";", "if", "(", "(", "TIMx", "==", "TIM1", ")", "||", "(", "TIMx", "==", "TIM8", ")", ")", "{", "assert_param", "(", "IS_TIM_OCIDLE_STATE", "(", "TIM_OCInitStruct", "->", "TIM_OCIdleState", ")", ")", ";", "/*", "Reset", "the", "Output", "Compare", "IDLE", "State", "*/", "tmpcr2", "&=", "(", "uint32_t", ")", "~", "TIM_CR2_OIS5", ";", "/*", "Set", "the", "Output", "Idle", "state", "*/", "tmpcr2", "|=", "(", "uint32_t", ")", "(", "(", "uint32_t", ")", "TIM_OCInitStruct", "->", "TIM_OCIdleState", "<<", "16", ")", ";", "}", "/*", "Write", "to", "TIMx", "CR2", "*/", "TIMx", "->", "CR2", "=", "tmpcr2", ";", "/*", "Write", "to", "TIMx", "CCMR2", "*/", "TIMx", "->", "CCMR3", "=", "tmpccmrx", ";", "/*", "Set", "the", "Capture", "Compare", "Register", "value", "*/", "TIMx", "->", "CCR5", "=", "TIM_OCInitStruct", "->", "TIM_Pulse", ";", "/*", "Write", "to", "TIMx", "CCER", "*/", "TIMx", "->", "CCER", "=", "tmpccer", ";", "}'" ]

[ "Selects", "the", "TIMx", "Trigger", "Output", "Mode2", "(TRGO2)" ]

[ "'void", "TIM_SelectOutputTrigger2", "(", "TIM_TypeDef", "*", "TIMx", ",", "uint32_t", "TIM_TRGO2Source", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_TIM_LIST4_PERIPH", "(", "TIMx", ")", ")", ";", "assert_param", "(", "IS_TIM_TRGO2_SOURCE", "(", "TIM_TRGO2Source", ")", ")", ";", "/*", "Reset", "the", "MMS", "Bits", "*/", "TIMx", "->", "CR2", "&=", "(", "uint32_t", ")", "~", "TIM_CR2_MMS2", ";", "/*", "Select", "the", "TRGO", "source", "*/", "TIMx", "->", "CR2", "|=", "TIM_TRGO2Source", ";", "}'" ]