Datasets:

AISE-TUDelft

/

Capybara

like 2

Follow

AISE research lab at TU Delft 43

[ "Register", "the", "dataset", "access", "property", "list", "class's", "properties" ]

[ "'static", "herr_t", "H5P__dacc_reg_prop", "(", "H5P_genclass_t", "*", "pclass", ")", "{", "size_t", "rdcc_nslots", "=", "H5D_ACS_DATA_CACHE_NUM_SLOTS_DEF", ";", "/*", "Default", "raw", "data", "chunk", "cache", "#", "of", "slots", "*/", "size_t", "rdcc_nbytes", "=", "H5D_ACS_DATA_CACHE_BYTE_SIZE_DEF", ";", "/*", "Default", "raw", "data", "chunk", "cache", "#", "of", "bytes", "*/", "double", "rdcc_w0", "=", "H5D_ACS_PREEMPT_READ_CHUNKS_DEF", ";", "/*", "Default", "raw", "data", "chunk", "cache", "dirty", "ratio", "*/", "H5D_vds_view_t", "virtual_view", "=", "H5D_ACS_VDS_VIEW_DEF", ";", "/*", "Default", "VDS", "view", "option", "*/", "hsize_t", "printf_gap", "=", "H5D_ACS_VDS_PRINTF_GAP_DEF", ";", "/*", "Default", "VDS", "printf", "gap", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "Register", "the", "size", "of", "raw", "data", "chunk", "cache", "(elements)", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_DATA_CACHE_NUM_SLOTS_NAME", ",", "H5D_ACS_DATA_CACHE_NUM_SLOTS_SIZE", ",", "&", "rdcc_nslots", ",", "NULL", ",", "NULL", ",", "NULL", ",", "H5D_ACS_DATA_CACHE_NUM_SLOTS_ENC", ",", "H5D_ACS_DATA_CACHE_NUM_SLOTS_DEC", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "/*", "Register", "the", "size", "of", "raw", "data", "chunk", "cache(bytes)", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_DATA_CACHE_BYTE_SIZE_NAME", ",", "H5D_ACS_DATA_CACHE_BYTE_SIZE_SIZE", ",", "&", "rdcc_nbytes", ",", "NULL", ",", "NULL", ",", "NULL", ",", "H5D_ACS_DATA_CACHE_BYTE_SIZE_ENC", ",", "H5D_ACS_DATA_CACHE_BYTE_SIZE_DEC", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "/*", "Register", "the", "preemption", "for", "reading", "chunks", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_PREEMPT_READ_CHUNKS_NAME", ",", "H5D_ACS_PREEMPT_READ_CHUNKS_SIZE", ",", "&", "rdcc_w0", ",", "NULL", ",", "NULL", ",", "NULL", ",", "H5D_ACS_PREEMPT_READ_CHUNKS_ENC", ",", "H5D_ACS_PREEMPT_READ_CHUNKS_DEC", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "/*", "Register", "the", "VDS", "view", "option", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_VDS_VIEW_NAME", ",", "H5D_ACS_VDS_VIEW_SIZE", ",", "&", "virtual_view", ",", "NULL", ",", "NULL", ",", "NULL", ",", "H5D_ACS_VDS_VIEW_ENC", ",", "H5D_ACS_VDS_VIEW_DEC", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "/*", "Register", "the", "VDS", "printf", "gap", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_VDS_PRINTF_GAP_NAME", ",", "H5D_ACS_VDS_PRINTF_GAP_SIZE", ",", "&", "printf_gap", ",", "NULL", ",", "NULL", ",", "NULL", ",", "H5D_ACS_VDS_PRINTF_GAP_ENC", ",", "H5D_ACS_VDS_PRINTF_GAP_DEC", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "/*", "Register", "property", "for", "vds", "prefix", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_VDS_PREFIX_NAME", ",", "H5D_ACS_VDS_PREFIX_SIZE", ",", "&", "H5D_def_vds_prefix_g", ",", "NULL", ",", "H5D_ACS_VDS_PREFIX_SET", ",", "H5D_ACS_VDS_PREFIX_GET", ",", "H5D_ACS_VDS_PREFIX_ENC", ",", "H5D_ACS_VDS_PREFIX_DEC", ",", "H5D_ACS_VDS_PREFIX_DEL", ",", "H5D_ACS_VDS_PREFIX_COPY", ",", "H5D_ACS_VDS_PREFIX_CMP", ",", "H5D_ACS_VDS_PREFIX_CLOSE", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "/*", "Register", "info", "for", "append", "flush", "*/", "/*", "(Note:", "this", "property", "should", "not", "have", "an", "encode/decode", "callback", "-QAK)", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_APPEND_FLUSH_NAME", ",", "H5D_ACS_APPEND_FLUSH_SIZE", ",", "&", "H5D_def_append_flush_g", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "/*", "Register", "property", "for", "external", "file", "prefix", "*/", "if", "(", "H5P__register_real", "(", "pclass", ",", "H5D_ACS_EFILE_PREFIX_NAME", ",", "H5D_ACS_EFILE_PREFIX_SIZE", ",", "&", "H5D_def_efile_prefix_g", ",", "NULL", ",", "H5D_ACS_EFILE_PREFIX_SET", ",", "H5D_ACS_EFILE_PREFIX_GET", ",", "H5D_ACS_EFILE_PREFIX_ENC", ",", "H5D_ACS_EFILE_PREFIX_DEC", ",", "H5D_ACS_EFILE_PREFIX_DEL", ",", "H5D_ACS_EFILE_PREFIX_COPY", ",", "H5D_ACS_EFILE_PREFIX_CMP", ",", "H5D_ACS_EFILE_PREFIX_CLOSE", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"can\\'t", "insert", "property", "into", "class\"", ")", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Frees", "memory", "used", "to", "store", "the", "vds", "file", "prefix", "string" ]

[ "'static", "herr_t", "H5P__dapl_vds_file_pref_del", "(", "hid_t", "H5_ATTR_UNUSED", "prop_id", ",", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "HDassert", "(", "value", ")", ";", "H5MM_xfree", "(", "*", "(", "void", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Retrieves", "the", "boundary,", "callback", "function", "and", "user", "data", "set", "in", "property", "list" ]

[ "'herr_t", "H5Pget_append_flush", "(", "hid_t", "plist_id", ",", "unsigned", "ndims", ",", "hsize_t", "boundary", "[]", ",", "H5D_append_cb_t", "*", "func", ",", "void", "*", "*", "udata", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "property", "list", "pointer", "*/", "H5D_append_flush_t", "info", ";", "unsigned", "u", ";", "/*", "local", "index", "variable", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE5", "(", "\"e\"", ",", "\"iIu*h*x**x\"", ",", "plist_id", ",", "ndims", ",", "boundary", ",", "func", ",", "udata", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Retrieve", "info", "for", "append", "flush", "*/", "if", "(", "H5P_get", "(", "plist", ",", "H5D_ACS_APPEND_FLUSH_NAME", ",", "&", "info", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "object", "flush", "callback\"", ")", "/*", "Assign", "return", "values", "*/", "if", "(", "boundary", ")", "{", "HDmemset", "(", "boundary", ",", "0", ",", "ndims", "*", "sizeof", "(", "hsize_t", ")", ")", ";", "if", "(", "info", ".", "ndims", ">", "0", ")", "for", "(", "u", "=", "0", ";", "u", "<", "info", ".", "ndims", "&&", "u", "<", "ndims", ";", "u", "++", ")", "boundary", "[", "u", "]", "=", "info", ".", "boundary", "[", "u", "]", ";", "}", "/*", "end", "if", "*/", "if", "(", "func", ")", "*", "func", "=", "info", ".", "func", ";", "if", "(", "udata", ")", "*", "udata", "=", "info", ".", "udata", ";", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Frees", "memory", "used", "to", "store", "the", "vds", "file", "prefix", "string" ]

[ "'static", "herr_t", "H5P__dapl_vds_file_pref_close", "(", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "HDassert", "(", "value", ")", ";", "H5MM_xfree", "(", "*", "(", "void", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Sets", "the", "boundary,", "callback", "function,", "and", "user", "data", "in", "the", "property", "list" ]

[ "'herr_t", "H5Pset_append_flush", "(", "hid_t", "plist_id", ",", "unsigned", "ndims", ",", "const", "hsize_t", "*", "boundary", ",", "H5D_append_cb_t", "func", ",", "void", "*", "udata", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "H5D_append_flush_t", "info", ";", "/*", "Property", "for", "append", "flush", "parameters", "*/", "unsigned", "u", ";", "/*", "Local", "index", "variable", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE5", "(", "\"e\"", ",", "\"iIu*hx*x\"", ",", "plist_id", ",", "ndims", ",", "boundary", ",", "func", ",", "udata", ")", ";", "/*", "Check", "arguments", "*/", "if", "(", "0", "==", "ndims", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"dimensionality", "cannot", "be", "zero\"", ")", "if", "(", "ndims", ">", "H5S_MAX_RANK", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"dimensionality", "is", "too", "large\"", ")", "if", "(", "!", "boundary", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "boundary", "dimensions", "specified\"", ")", "/*", "Check", "if", "the", "callback", "function", "is", "NULL", "and", "the", "user", "data", "is", "non-NULL.", "*", "This", "is", "almost", "certainly", "an", "error", "as", "the", "user", "data", "will", "not", "be", "used.", "*/", "if", "(", "!", "func", "&&", "udata", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"callback", "is", "NULL", "while", "user", "data", "is", "not\"", ")", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Set", "up", "values", "*/", "info", ".", "ndims", "=", "ndims", ";", "info", ".", "func", "=", "func", ";", "info", ".", "udata", "=", "udata", ";", "HDmemset", "(", "info", ".", "boundary", ",", "0", ",", "sizeof", "(", "info", ".", "boundary", ")", ")", ";", "/*", "boundary", "can", "be", "0", "to", "indicate", "no", "boundary", "is", "set", "*/", "for", "(", "u", "=", "0", ";", "u", "<", "ndims", ";", "u", "++", ")", "{", "if", "(", "boundary", "[", "u", "]", "!=", "(", "boundary", "[", "u", "]", "&", "0xffffffff", ")", ")", "/*", "negative", "value", "(including", "H5S_UNLIMITED)", "*/", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADRANGE", ",", "FAIL", ",", "\"all", "boundary", "dimensions", "must", "be", "less", "than", "2^32\"", ")", "info", ".", "boundary", "[", "u", "]", "=", "boundary", "[", "u", "]", ";", "/*", "Store", "user\\'s", "boundary", "dimensions", "*/", "}", "/*", "end", "for", "*/", "/*", "Set", "values", "*/", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_APPEND_FLUSH_NAME", ",", "&", "info", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "append", "flush\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Callback", "routine", "which", "is", "called", "whenever", "the", "vds", "file", "prefix", "property", "in", "the", "dataset", "access", "property", "list", "is", "decoded" ]

[ "'static", "herr_t", "H5P__dapl_vds_file_pref_dec", "(", "const", "void", "*", "*", "_pp", ",", "void", "*", "_value", ")", "{", "char", "*", "*", "vds_file_pref", "=", "(", "char", "*", "*", ")", "_value", ";", "const", "uint8_t", "*", "*", "pp", "=", "(", "const", "uint8_t", "*", "*", ")", "_pp", ";", "size_t", "len", ";", "uint64_t", "enc_value", ";", "/*", "Decoded", "property", "value", "*/", "unsigned", "enc_size", ";", "/*", "Size", "of", "encoded", "property", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "FUNC_ENTER_NOAPI_NOINIT", "HDassert", "(", "pp", ")", ";", "HDassert", "(", "*", "pp", ")", ";", "HDassert", "(", "vds_file_pref", ")", ";", "HDcompile_assert", "(", "sizeof", "(", "size_t", ")", "<=", "sizeof", "(", "uint64_t", ")", ")", ";", "/*", "Decode", "the", "size", "*/", "enc_size", "=", "*", "(", "*", "pp", ")", "++", ";", "HDassert", "(", "enc_size", "<", "256", ")", ";", "/*", "Decode", "the", "value", "*/", "UINT64DECODE_VAR", "(", "*", "pp", ",", "enc_value", ",", "enc_size", ")", ";", "len", "=", "(", "size_t", ")", "enc_value", ";", "if", "(", "0", "!=", "len", ")", "{", "/*", "Make", "a", "copy", "of", "the", "user\\'s", "prefix", "string", "*/", "if", "(", "NULL", "==", "(", "*", "vds_file_pref", "=", "(", "char", "*", ")", "H5MM_malloc", "(", "len", "+", "1", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"memory", "allocation", "failed", "for", "prefix\"", ")", "HDstrncpy", "(", "*", "vds_file_pref", ",", "*", "(", "const", "char", "*", "*", ")", "pp", ",", "len", ")", ";", "(", "*", "vds_file_pref", ")", "[", "len", "]", "=", "\\'\\\\0\\'", ";", "*", "pp", "+=", "len", ";", "}", "/*", "end", "if", "*/", "else", "*", "vds_file_pref", "=", "NULL", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Copies", "an", "external", "file", "prefix", "property", "when", "it's", "set", "for", "a", "property", "list" ]

[ "'static", "herr_t", "H5P__dapl_efile_pref_set", "(", "hid_t", "H5_ATTR_UNUSED", "prop_id", ",", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_STATIC_NOERR", "/*", "Sanity", "check", "*/", "HDassert", "(", "value", ")", ";", "/*", "Copy", "the", "prefix", "*/", "*", "(", "char", "*", "*", ")", "value", "=", "H5MM_xstrdup", "(", "*", "(", "const", "char", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Sets", "the", "access", "property", "list", "for", "the", "virtual", "dataset,", "dapl_id,", "to", "instruct", "the", "library", "to", "stop", "looking", "for", "the", "mapped", "data", "stored", "in", "the", "files", "and", "or", "datasets", "with", "the", "printfstyle", "names", "after", "not", "finding", "gap_size", "files", "and", "or", "datasets" ]

[ "'herr_t", "H5Pset_virtual_printf_gap", "(", "hid_t", "plist_id", ",", "hsize_t", "gap_size", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"e\"", ",", "\"ih\"", ",", "plist_id", ",", "gap_size", ")", ";", "/*", "Check", "argument", "*/", "if", "(", "gap_size", "==", "HSIZE_UNDEF", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"not", "a", "valid", "printf", "gap", "size\"", ")", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Update", "property", "list", "*/", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_VDS_PRINTF_GAP_NAME", ",", "&", "gap_size", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"unable", "to", "set", "value\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Copies", "a", "vds", "file", "prefix", "property", "when", "it's", "retrieved", "from", "a", "property", "list" ]

[ "'static", "herr_t", "H5P__dapl_vds_file_pref_get", "(", "hid_t", "H5_ATTR_UNUSED", "prop_id", ",", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_STATIC_NOERR", "/*", "Sanity", "check", "*/", "HDassert", "(", "value", ")", ";", "/*", "Copy", "the", "prefix", "*/", "*", "(", "char", "*", "*", ")", "value", "=", "H5MM_xstrdup", "(", "*", "(", "const", "char", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Gets", "the", "maximum", "number", "of", "missing", "printfstyle", "files", "and", "or", "datasets", "for", "determining", "the", "extent", "of", "the", "unlimited", "VDS,", "gap_size,", "using", "the", "access", "property", "list", "for", "the", "virtual", "dataset,", "dapl_id" ]

[ "'herr_t", "H5Pget_virtual_printf_gap", "(", "hid_t", "plist_id", ",", "hsize_t", "*", "gap_size", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"e\"", ",", "\"i*h\"", ",", "plist_id", ",", "gap_size", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Get", "value", "from", "property", "list", "*/", "if", "(", "gap_size", ")", "if", "(", "H5P_get", "(", "plist", ",", "H5D_ACS_VDS_PRINTF_GAP_NAME", ",", "gap_size", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"unable", "to", "get", "value\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Frees", "memory", "used", "to", "store", "the", "external", "file", "prefix", "string" ]

[ "'static", "herr_t", "H5P__dapl_efile_pref_del", "(", "hid_t", "H5_ATTR_UNUSED", "prop_id", ",", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "HDassert", "(", "value", ")", ";", "H5MM_xfree", "(", "*", "(", "void", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Decode", "the", "rdcc_nbytes", "parameter", "from", "a", "serialized", "property", "list" ]

[ "'static", "herr_t", "H5P__decode_chunk_cache_nbytes", "(", "const", "void", "*", "*", "_pp", ",", "void", "*", "_value", ")", "{", "size_t", "*", "value", "=", "(", "size_t", "*", ")", "_value", ";", "/*", "Property", "value", "to", "return", "*/", "const", "uint8_t", "*", "*", "pp", "=", "(", "const", "uint8_t", "*", "*", ")", "_pp", ";", "uint64_t", "enc_value", ";", "/*", "Decoded", "property", "value", "*/", "unsigned", "enc_size", ";", "/*", "Size", "of", "encoded", "property", "*/", "FUNC_ENTER_PACKAGE_NOERR", "/*", "Sanity", "check", "*/", "HDcompile_assert", "(", "sizeof", "(", "size_t", ")", "<=", "sizeof", "(", "uint64_t", ")", ")", ";", "HDassert", "(", "pp", ")", ";", "HDassert", "(", "*", "pp", ")", ";", "HDassert", "(", "value", ")", ";", "/*", "Decode", "the", "size", "*/", "enc_size", "=", "*", "(", "*", "pp", ")", "++", ";", "HDassert", "(", "enc_size", "<", "256", ")", ";", "/*", "Determine", "if", "enc_size", "indicates", "that", "this", "is", "the", "default", "value,", "in", "which", "*", "case", "set", "value", "to", "H5D_ACS_DATA_CACHE_BYTE_SIZE_DEF", "and", "return", "*/", "if", "(", "enc_size", "==", "0", ")", "*", "value", "=", "H5D_ACS_DATA_CACHE_BYTE_SIZE_DEF", ";", "else", "{", "/*", "Decode", "the", "value", "*/", "UINT64DECODE_VAR", "(", "*", "pp", ",", "enc_value", ",", "enc_size", ")", ";", "H5_CHECKED_ASSIGN", "(", "*", "value", ",", "uint64_t", ",", "enc_value", ",", "size_t", ")", ";", "}", "/*", "end", "else", "*/", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Callback", "routine", "which", "is", "called", "whenever", "the", "efile", "prefix", "property", "in", "the", "dataset", "access", "property", "list", "is", "decoded" ]

[ "'static", "herr_t", "H5P__dapl_efile_pref_dec", "(", "const", "void", "*", "*", "_pp", ",", "void", "*", "_value", ")", "{", "char", "*", "*", "efile_pref", "=", "(", "char", "*", "*", ")", "_value", ";", "const", "uint8_t", "*", "*", "pp", "=", "(", "const", "uint8_t", "*", "*", ")", "_pp", ";", "size_t", "len", ";", "uint64_t", "enc_value", ";", "/*", "Decoded", "property", "value", "*/", "unsigned", "enc_size", ";", "/*", "Size", "of", "encoded", "property", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "FUNC_ENTER_NOAPI_NOINIT", "HDassert", "(", "pp", ")", ";", "HDassert", "(", "*", "pp", ")", ";", "HDassert", "(", "efile_pref", ")", ";", "HDcompile_assert", "(", "sizeof", "(", "size_t", ")", "<=", "sizeof", "(", "uint64_t", ")", ")", ";", "/*", "Decode", "the", "size", "*/", "enc_size", "=", "*", "(", "*", "pp", ")", "++", ";", "HDassert", "(", "enc_size", "<", "256", ")", ";", "/*", "Decode", "the", "value", "*/", "UINT64DECODE_VAR", "(", "*", "pp", ",", "enc_value", ",", "enc_size", ")", ";", "len", "=", "(", "size_t", ")", "enc_value", ";", "if", "(", "0", "!=", "len", ")", "{", "/*", "Make", "a", "copy", "of", "the", "user\\'s", "prefix", "string", "*/", "if", "(", "NULL", "==", "(", "*", "efile_pref", "=", "(", "char", "*", ")", "H5MM_malloc", "(", "len", "+", "1", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"memory", "allocation", "failed", "for", "prefix\"", ")", "HDstrncpy", "(", "*", "efile_pref", ",", "*", "(", "const", "char", "*", "*", ")", "pp", ",", "len", ")", ";", "(", "*", "efile_pref", ")", "[", "len", "]", "=", "\\'\\\\0\\'", ";", "*", "pp", "+=", "len", ";", "}", "/*", "end", "if", "*/", "else", "*", "efile_pref", "=", "NULL", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Encode", "the", "rdcc_nbytes", "parameter", "to", "a", "serialized", "property", "list" ]

[ "'static", "herr_t", "H5P__encode_chunk_cache_nbytes", "(", "const", "void", "*", "value", ",", "void", "*", "*", "_pp", ",", "size_t", "*", "size", ")", "{", "uint64_t", "enc_value", ";", "/*", "Property", "value", "to", "encode", "*/", "uint8_t", "*", "*", "pp", "=", "(", "uint8_t", "*", "*", ")", "_pp", ";", "unsigned", "enc_size", ";", "/*", "Size", "of", "encoded", "property", "*/", "FUNC_ENTER_PACKAGE_NOERR", "/*", "Sanity", "checks", "*/", "HDcompile_assert", "(", "sizeof", "(", "size_t", ")", "<=", "sizeof", "(", "uint64_t", ")", ")", ";", "HDassert", "(", "size", ")", ";", "/*", "Determine", "if", "this", "is", "the", "default", "value,", "in", "which", "case", "only", "encode", "*", "enc_size", "(as", "255).", "Also", "set", "size", "needed", "for", "encoding.", "*/", "if", "(", "*", "(", "const", "size_t", "*", ")", "value", "==", "H5D_ACS_DATA_CACHE_BYTE_SIZE_DEF", ")", "{", "enc_size", "=", "0", ";", "*", "size", "+=", "1", ";", "}", "/*", "end", "if", "*/", "else", "{", "enc_value", "=", "(", "uint64_t", ")", "*", "(", "const", "size_t", "*", ")", "value", ";", "enc_size", "=", "H5VM_limit_enc_size", "(", "enc_value", ")", ";", "HDassert", "(", "enc_size", ">", "0", ")", ";", "*", "size", "+=", "(", "1", "+", "enc_size", ")", ";", "}", "/*", "end", "else", "*/", "HDassert", "(", "enc_size", "<", "256", ")", ";", "if", "(", "NULL", "!=", "*", "pp", ")", "{", "/*", "Encode", "the", "size", "*/", "*", "(", "*", "pp", ")", "++", "=", "(", "uint8_t", ")", "enc_size", ";", "/*", "Encode", "the", "value", "if", "necessary", "*/", "if", "(", "enc_size", "!=", "0", ")", "{", "UINT64ENCODE_VAR", "(", "*", "pp", ",", "enc_value", ",", "enc_size", ")", ";", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Handle", "an", "incoming", "STUN", "message", "to", "a", "Client", "Transaction" ]

[ "'int", "stun_ctrans_recv", "(", "struct", "stun", "*", "stun", ",", "const", "struct", "stun_msg", "*", "msg", ",", "const", "struct", "stun_unknown_attr", "*", "ua", ")", "{", "struct", "stun_errcode", "ec", "=", "{", "0", ",", "\"OK\"", "}", ";", "struct", "stun_attr", "*", "errcode", ";", "struct", "stun_ctrans", "*", "ct", ";", "int", "err", "=", "0", ",", "<type", "ref=\"prev\"/>", "herr", "=", "0", ";", "if", "(", "!", "stun", "||", "!", "msg", "||", "!", "ua", ")", "return", "EINVAL", ";", "switch", "(", "stun_msg_class", "(", "msg", ")", ")", "{", "case", "STUN_CLASS_ERROR_RESP", ":", "errcode", "=", "stun_msg_attr", "(", "msg", ",", "STUN_ATTR_ERR_CODE", ")", ";", "if", "(", "!", "errcode", ")", "herr", "=", "EPROTO", ";", "else", "ec", "=", "errcode", "->", "v", ".", "err_code", ";", "/*@fallthrough@*/", "case", "STUN_CLASS_SUCCESS_RESP", ":", "ct", "=", "list_ledata", "(", "list_apply", "(", "&", "stun", "->", "ctl", ",", "true", ",", "match_handler", ",", "(", "void", "*", ")", "msg", ")", ")", ";", "if", "(", "!", "ct", ")", "{", "err", "=", "ENOENT", ";", "break;", "}", "switch", "(", "ec", ".", "code", ")", "{", "case", "401", ":", "case", "438", ":", "break;", "default:", "if", "(", "!", "ct", "->", "key", ")", "break;", "err", "=", "stun_msg_chk_mi", "(", "msg", ",", "ct", "->", "key", ",", "ct", "->", "keylen", ")", ";", "break;", "}", "if", "(", "err", ")", "break;", "if", "(", "!", "herr", "&&", "ua", "->", "typec", ">", "0", ")", "herr", "=", "EPROTO", ";", "completed", "(", "ct", ",", "herr", ",", "ec", ".", "code", ",", "ec", ".", "reason", ",", "msg", ")", ";", "break;", "default:", "break;", "}", "return", "err", ";", "}'" ]

[ "Guaranteed", "to", "work", "for", "any", "n,", "m", "where", "gcd(n,", "m)", "1" ]

[ "'int", "ff_tx_gen_compound_mapping", "(", "AVTXContext", "*", "s", ")", "{", "int", "*", "in_map", ",", "<type", "ref=\"prev\">", "*", "out_map", ";", "const", "int", "n", "=", "s", "->", "n", ";", "const", "int", "m", "=", "s", "->", "m", ";", "const", "int", "inv", "=", "s", "->", "inv", ";", "const", "int", "len", "=", "n", "*", "m", ";", "const", "int", "m_inv", "=", "mulinv", "(", "m", ",", "n", ")", ";", "const", "int", "n_inv", "=", "mulinv", "(", "n", ",", "m", ")", ";", "const", "int", "mdct", "=", "ff_tx_type_is_mdct", "(", "s", "->", "type", ")", ";", "if", "(", "!", "(", "s", "->", "pfatab", "=", "av_malloc", "(", "2", "*", "len", "*", "sizeof", "(", "*", "s", "->", "pfatab", ")", ")", ")", ")", "return", "AVERROR", "(", "ENOMEM", ")", ";", "in_map", "=", "s", "->", "pfatab", ";", "out_map", "=", "s", "->", "pfatab", "+", "n", "*", "m", ";", "/*", "Ruritanian", "map", "for", "input,", "CRT", "map", "for", "output,", "can", "be", "swapped", "*/", "for", "(", "int", "j", "=", "0", ";", "j", "<", "m", ";", "j", "++", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "/*", "Shifted", "by", "1", "to", "simplify", "MDCTs", "*/", "in_map", "[", "j", "*", "n", "+", "i", "]", "=", "(", "(", "i", "*", "m", "+", "j", "*", "n", ")", "%", "len", ")", "<<", "mdct", ";", "out_map", "[", "(", "i", "*", "m", "*", "m_inv", "+", "j", "*", "n", "*", "n_inv", ")", "%", "len", "]", "=", "i", "*", "m", "+", "j", ";", "}", "}", "/*", "Change", "transform", "direction", "by", "reversing", "all", "ACs", "*/", "if", "(", "inv", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "m", ";", "i", "++", ")", "{", "int", "*", "in", "=", "&", "in_map", "[", "i", "*", "n", "+", "1", "]", ";", "/*", "Skip", "the", "DC", "*/", "for", "(", "int", "j", "=", "0", ";", "j", "<", "(", "(", "n", "-", "1", ")", ">>", "1", ")", ";", "j", "++", ")", "FFSWAP", "(", "int", ",", "in", "[", "j", "]", ",", "in", "[", "n", "-", "j", "-", "2", "]", ")", ";", "}", "}", "/*", "Our", "15-point", "transform", "is", "also", "a", "compound", "one,", "so", "embed", "its", "input", "map", "*/", "if", "(", "n", "==", "15", ")", "{", "for", "(", "int", "k", "=", "0", ";", "k", "<", "m", ";", "k", "++", ")", "{", "int", "tmp", "[", "15", "]", ";", "memcpy", "(", "tmp", ",", "&", "in_map", "[", "k", "*", "15", "]", ",", "15", "*", "sizeof", "(", "*", "tmp", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "5", ";", "i", "++", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "3", ";", "j", "++", ")", "in_map", "[", "k", "*", "15", "+", "i", "*", "3", "+", "j", "]", "=", "tmp", "[", "(", "i", "*", "3", "+", "j", "*", "5", ")", "%", "15", "]", ";", "}", "}", "}", "return", "0", ";", "}'" ]

[ "Retrieve", "information", "about", "an", "object" ]

[ "'herr_t", "H5Oget_info_by_name1", "(", "hid_t", "loc_id", ",", "const", "char", "*", "name", ",", "H5O_info_t", "*", "oinfo", ",", "hid_t", "lapl_id", ")", "{", "H5G_loc_t", "loc", ";", "/*", "Location", "of", "group", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE4", "(", "\"e\"", ",", "\"i*s*xi\"", ",", "loc_id", ",", "name", ",", "oinfo", ",", "lapl_id", ")", ";", "/*", "Check", "args", "*/", "if", "(", "H5G_loc", "(", "loc_id", ",", "&", "loc", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"not", "a", "location\"", ")", "if", "(", "!", "name", "||", "!", "*", "name", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "name\"", ")", "if", "(", "!", "oinfo", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "info", "struct\"", ")", "/*", "Verify", "access", "property", "list", "and", "set", "up", "collective", "metadata", "if", "appropriate", "*/", "if", "(", "H5CX_set_apl", "(", "&", "lapl_id", ",", "H5P_CLS_LACC", ",", "loc_id", ",", "FALSE", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "access", "property", "list", "info\"", ")", "/*", "Retrieve", "the", "object\\'s", "information", "*/", "if", "(", "H5G_loc_info", "(", "&", "loc", ",", "name", ",", "oinfo", "/*out*/", ",", "H5O_INFO_ALL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "info", "for", "object:", "\\'%s\\'\"", ",", "name", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Recursively", "visit", "an", "object", "and", "all", "the", "objects", "reachable", "from", "it" ]

[ "'herr_t", "H5Ovisit1", "(", "hid_t", "obj_id", ",", "H5_index_t", "idx_type", ",", "H5_iter_order_t", "order", ",", "H5O_iterate_t", "op", ",", "void", "*", "op_data", ")", "{", "herr_t", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE5", "(", "\"e\"", ",", "\"iIiIox*x\"", ",", "obj_id", ",", "idx_type", ",", "order", ",", "op", ",", "op_data", ")", ";", "/*", "Check", "args", "*/", "if", "(", "idx_type", "<=", "H5_INDEX_UNKNOWN", "||", "idx_type", ">=", "H5_INDEX_N", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"invalid", "index", "type", "specified\"", ")", "if", "(", "order", "<=", "H5_ITER_UNKNOWN", "||", "order", ">=", "H5_ITER_N", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"invalid", "iteration", "order", "specified\"", ")", "if", "(", "!", "op", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "callback", "operator", "specified\"", ")", "/*", "Call", "internal", "object", "visitation", "routine", "*/", "if", "(", "(", "ret_value", "=", "H5O__visit", "(", "obj_id", ",", "\".\"", ",", "idx_type", ",", "order", ",", "op", ",", "op_data", ",", "H5O_INFO_ALL", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_BADITER", ",", "FAIL", ",", "\"object", "visitation", "failed\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Retrieve", "information", "about", "an", "object,", "according", "to", "the", "order", "of", "an", "index" ]

[ "'herr_t", "H5Oget_info_by_idx1", "(", "hid_t", "loc_id", ",", "const", "char", "*", "group_name", ",", "H5_index_t", "idx_type", ",", "H5_iter_order_t", "order", ",", "hsize_t", "n", ",", "H5O_info_t", "*", "oinfo", ",", "hid_t", "lapl_id", ")", "{", "H5G_loc_t", "loc", ";", "/*", "Location", "of", "group", "*/", "H5G_loc_t", "obj_loc", ";", "/*", "Location", "used", "to", "open", "group", "*/", "H5G_name_t", "obj_path", ";", "/*", "Opened", "object", "group", "hier.", "path", "*/", "H5O_loc_t", "obj_oloc", ";", "/*", "Opened", "object", "object", "location", "*/", "hbool_t", "loc_found", "=", "FALSE", ";", "/*", "Entry", "at", "\\'name\\'", "found", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE7", "(", "\"e\"", ",", "\"i*sIiIoh*xi\"", ",", "loc_id", ",", "group_name", ",", "idx_type", ",", "order", ",", "n", ",", "oinfo", ",", "lapl_id", ")", ";", "/*", "Check", "args", "*/", "if", "(", "H5G_loc", "(", "loc_id", ",", "&", "loc", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"not", "a", "location\"", ")", "if", "(", "!", "group_name", "||", "!", "*", "group_name", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "name", "specified\"", ")", "if", "(", "idx_type", "<=", "H5_INDEX_UNKNOWN", "||", "idx_type", ">=", "H5_INDEX_N", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"invalid", "index", "type", "specified\"", ")", "if", "(", "order", "<=", "H5_ITER_UNKNOWN", "||", "order", ">=", "H5_ITER_N", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"invalid", "iteration", "order", "specified\"", ")", "if", "(", "!", "oinfo", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "info", "struct\"", ")", "/*", "Verify", "access", "property", "list", "and", "set", "up", "collective", "metadata", "if", "appropriate", "*/", "if", "(", "H5CX_set_apl", "(", "&", "lapl_id", ",", "H5P_CLS_LACC", ",", "loc_id", ",", "FALSE", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "access", "property", "list", "info\"", ")", "/*", "Retrieve", "the", "object\\'s", "information", "*/", "if", "(", "H5O__get_info_by_idx", "(", "&", "loc", ",", "group_name", ",", "idx_type", ",", "order", ",", "n", ",", "oinfo", ",", "H5O_INFO_ALL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "info", "for", "object\"", ")", "done", ":", "/*", "Release", "the", "object", "location", "*/", "if", "(", "loc_found", "&&", "H5G_loc_free", "(", "&", "obj_loc", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTRELEASE", ",", "FAIL", ",", "\"can\\'t", "free", "location\"", ")", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Recursively", "visit", "an", "object", "and", "all", "the", "objects", "reachable", "from", "it" ]

[ "'herr_t", "H5Ovisit_by_name1", "(", "hid_t", "loc_id", ",", "const", "char", "*", "obj_name", ",", "H5_index_t", "idx_type", ",", "H5_iter_order_t", "order", ",", "H5O_iterate_t", "op", ",", "void", "*", "op_data", ",", "hid_t", "lapl_id", ")", "{", "herr_t", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE7", "(", "\"e\"", ",", "\"i*sIiIox*xi\"", ",", "loc_id", ",", "obj_name", ",", "idx_type", ",", "order", ",", "op", ",", "op_data", ",", "lapl_id", ")", ";", "/*", "Check", "args", "*/", "if", "(", "!", "obj_name", "||", "!", "*", "obj_name", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "name\"", ")", "if", "(", "idx_type", "<=", "H5_INDEX_UNKNOWN", "||", "idx_type", ">=", "H5_INDEX_N", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"invalid", "index", "type", "specified\"", ")", "if", "(", "order", "<=", "H5_ITER_UNKNOWN", "||", "order", ">=", "H5_ITER_N", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"invalid", "iteration", "order", "specified\"", ")", "if", "(", "!", "op", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "callback", "operator", "specified\"", ")", "/*", "Verify", "access", "property", "list", "and", "set", "up", "collective", "metadata", "if", "appropriate", "*/", "if", "(", "H5CX_set_apl", "(", "&", "lapl_id", ",", "H5P_CLS_LACC", ",", "loc_id", ",", "FALSE", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "access", "property", "list", "info\"", ")", "/*", "Call", "internal", "object", "visitation", "routine", "*/", "if", "(", "(", "ret_value", "=", "H5O__visit", "(", "loc_id", ",", "obj_name", ",", "idx_type", ",", "order", ",", "op", ",", "op_data", ",", "H5O_INFO_ALL", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_BADITER", ",", "FAIL", ",", "\"object", "visitation", "failed\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Retrieve", "information", "about", "an", "object" ]

[ "'herr_t", "H5Oget_info1", "(", "hid_t", "loc_id", ",", "H5O_info_t", "*", "oinfo", ")", "{", "H5G_loc_t", "loc", ";", "/*", "Location", "of", "group", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"e\"", ",", "\"i*x\"", ",", "loc_id", ",", "oinfo", ")", ";", "/*", "Check", "args", "*/", "if", "(", "H5G_loc", "(", "loc_id", ",", "&", "loc", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADTYPE", ",", "FAIL", ",", "\"not", "a", "location\"", ")", "if", "(", "!", "oinfo", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"no", "info", "struct\"", ")", "/*", "Retrieve", "the", "object\\'s", "information", "*/", "if", "(", "H5G_loc_info", "(", "&", "loc", ",", "\".\"", ",", "oinfo", "/*out*/", ",", "H5O_INFO_ALL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "retrieve", "object", "info\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Reset", "ignored", "signals", "back", "to", "default" ]

[ "'static", "void", "guest_exec_task_setup", "(", "gpointer", "data", ")", "{", "#", "if", "!", "defined", "(", "G_OS_WIN32", ")", "struct", "sigaction", "sigact", ";", "memset", "(", "&", "sigact", ",", "0", ",", "sizeof", "(", "struct", "sigaction", ")", ")", ";", "sigact", ".", "sa_handler", "=", "SIG_DFL", ";", "if", "(", "sigaction", "(", "SIGPIPE", ",", "&", "sigact", ",", "NULL", ")", "!=", "0", ")", "{", "slog", "(", "\"sigaction()", "failed", "to", "reset", "child", "process\\'s", "SIGPIPE:", "%s\"", ",", "strerror", "(", "errno", ")", ")", ";", "}", "#", "endif", "}'" ]

[ "Initialize", "the", "flash", "object", "setting", "FS" ]

[ "\"int32_t", "PIOS_FLASHFS_Logfs_Init", "(", "uintptr_t", "*", "fs_id", ",", "const", "struct", "flashfs_logfs_cfg", "*", "cfg", ",", "const", "struct", "pios_flash_driver", "*", "driver", ",", "uintptr_t", "flash_id", ")", "{", "#", "ifdef", "PIOS_INCLUDE_WDG", "PIOS_WDG_Clear", "()", ";", "#", "endif", "PIOS_Assert", "(", "cfg", ")", ";", "PIOS_Assert", "(", "fs_id", ")", ";", "PIOS_Assert", "(", "driver", ")", ";", "/*", "We", "must", "have", "at", "least", "2", "arenas", "for", "garbage", "collection", "to", "work", "*/", "PIOS_Assert", "(", "(", "cfg", "->", "total_fs_size", "/", "cfg", "->", "arena_size", ">", "1", ")", ")", ";", "/*", "Make", "sure", "the", "underlying", "flash", "driver", "provides", "the", "minimal", "set", "of", "required", "methods", "*/", "PIOS_Assert", "(", "driver", "->", "start_transaction", ")", ";", "PIOS_Assert", "(", "driver", "->", "end_transaction", ")", ";", "PIOS_Assert", "(", "driver", "->", "erase_sector", ")", ";", "PIOS_Assert", "(", "driver", "->", "write_data", ")", ";", "PIOS_Assert", "(", "driver", "->", "read_data", ")", ";", "int8_t", "rc", "=", "-", "1", ";", "//", "assume", "failure", "int8_t", "count", "=", "0", ";", "struct", "logfs_state", "*", "logfs", ";", "logfs", "=", "(", "struct", "logfs_state", "*", ")", "PIOS_FLASHFS_Logfs_alloc", "()", ";", "if", "(", "logfs", ")", "{", "while", "(", "rc", "&&", "count", "++", "<", "2", ")", "{", "/*", "Bind", "configuration", "parameters", "to", "this", "filesystem", "instance", "*/", "logfs", "->", "cfg", "=", "cfg", ";", "/*", "filesystem", "configuration", "*/", "logfs", "->", "driver", "=", "driver", ";", "/*", "lower-level", "flash", "driver", "*/", "logfs", "->", "flash_id", "=", "flash_id", ";", "/*", "lower-level", "flash", "device", "id", "*/", "logfs", "->", "mounted", "=", "false", ";", "if", "(", "logfs", "->", "driver", "->", "start_transaction", "(", "logfs", "->", "flash_id", ")", "==", "0", ")", "{", "bool", "found", "=", "false", ";", "int32_t", "arena_id", ";", "for", "(", "uint8_t", "try", "=", "0", ";", "!", "found", "&&", "try", "<", "2", ";", "try", "++", ")", "{", "/*", "Find", "the", "active", "arena", "*/", "arena_id", "=", "logfs_find_active_arena", "(", "logfs", ")", ";", "if", "(", "arena_id", ">=", "0", ")", "{", "/*", "Found", "the", "active", "arena", "*/", "found", "=", "true", ";", "break;", "}", "else", "{", "/*", "No", "active", "arena", "found,", "erase", "and", "activate", "arena", "0", "*/", "if", "(", "logfs_erase_arena", "(", "logfs", ",", "0", ")", "!=", "0", ")", "{", "break;", "}", "if", "(", "logfs_activate_arena", "(", "logfs", ",", "0", ")", "!=", "0", ")", "{", "break;", "}", "}", "}", "if", "(", "!", "found", ")", "{", "/*", "Still", "no", "active", "arena,", "something", "is", "broken", "*/", "rc", "=", "-", "2", ";", "goto", "out_end_trans", ";", "}", "/*", "We've", "found", "an", "active", "arena,", "mount", "it", "*/", "rc", "=", "logfs_mount_log", "(", "logfs", ",", "arena_id", ")", ";", "if", "(", "rc", "!=", "0", ")", "{", "/*", "Failed", "to", "mount", "the", "log,", "something", "is", "broken", "*/", "PIOS_FLASHFS_Format", "(", "(", "uintptr_t", ")", "logfs", ")", ";", "rc", "-=", "3", ";", "goto", "out_end_trans", ";", "}", "*", "fs_id", "=", "(", "uintptr_t", ")", "logfs", ";", "out_end_trans", ":", "logfs", "->", "driver", "->", "end_transaction", "(", "logfs", "->", "flash_id", ")", ";", "}", "}", "}", "return", "rc", ";", "}\"" ]

[ "Load", "one", "object", "instance", "from", "the", "filesystem" ]

[ "\"int32_t", "PIOS_FLASHFS_ObjLoad", "(", "uintptr_t", "fs_id", ",", "uint32_t", "obj_id", ",", "uint16_t", "obj_inst_id", ",", "uint8_t", "*", "obj_data", ",", "uint16_t", "obj_size", ")", "{", "int8_t", "rc", ";", "struct", "logfs_state", "*", "logfs", "=", "(", "struct", "logfs_state", "*", ")", "fs_id", ";", "if", "(", "!", "PIOS_FLASHFS_Logfs_validate", "(", "logfs", ")", ")", "{", "rc", "=", "-", "1", ";", "goto", "out_exit", ";", "}", "PIOS_Assert", "(", "obj_size", "<=", "(", "logfs", "->", "cfg", "->", "slot_size", "-", "sizeof", "(", "struct", "slot_header", ")", ")", ")", ";", "if", "(", "logfs", "->", "driver", "->", "start_transaction", "(", "logfs", "->", "flash_id", ")", "!=", "0", ")", "{", "rc", "=", "-", "2", ";", "goto", "out_exit", ";", "}", "/*", "Find", "the", "object", "in", "the", "log", "*/", "uint16_t", "slot_id", "=", "0", ";", "struct", "slot_header", "slot_hdr", ";", "if", "(", "logfs_object_find_next", "(", "logfs", ",", "&", "slot_hdr", ",", "&", "slot_id", ",", "obj_id", ",", "obj_inst_id", ")", "!=", "0", ")", "{", "/*", "Object", "does", "not", "exist", "in", "fs", "*/", "rc", "=", "-", "3", ";", "goto", "out_end_trans", ";", "}", "/*", "Sanity", "check", "what", "we've", "found", "*/", "if", "(", "slot_hdr", ".", "obj_size", "!=", "obj_size", ")", "{", "/*", "Object", "sizes", "don't", "match.", "Not", "safe", "to", "copy", "contents.", "*/", "rc", "=", "-", "4", ";", "goto", "out_end_trans", ";", "}", "/*", "Read", "the", "contents", "of", "the", "object", "from", "the", "log", "*/", "if", "(", "obj_size", ">", "0", ")", "{", "uintptr_t", "slot_addr", "=", "logfs_get_addr", "(", "logfs", ",", "logfs", "->", "active_arena_id", ",", "slot_id", ")", ";", "if", "(", "logfs", "->", "driver", "->", "read_data", "(", "logfs", "->", "flash_id", ",", "slot_addr", "+", "sizeof", "(", "slot_hdr", ")", ",", "(", "uint8_t", "*", ")", "obj_data", ",", "obj_size", ")", "!=", "0", ")", "{", "/*", "Failed", "to", "read", "object", "data", "from", "the", "log", "*/", "rc", "=", "-", "5", ";", "goto", "out_end_trans", ";", "}", "}", "/*", "Object", "successfully", "loaded", "*/", "rc", "=", "0", ";", "out_end_trans", ":", "logfs", "->", "driver", "->", "end_transaction", "(", "logfs", "->", "flash_id", ")", ";", "out_exit", ":", "return", "rc", ";", "}\"" ]

[ "NOTE:", "Must", "be", "called", "while", "holding", "the", "flash", "transaction", "lock" ]

[ "'static", "int16_t", "logfs_object_find_next", "(", "const", "struct", "logfs_state", "*", "logfs", ",", "struct", "slot_header", "*", "slot_hdr", ",", "uint16_t", "*", "curr_slot", ",", "uint32_t", "obj_id", ",", "uint16_t", "obj_inst_id", ")", "{", "PIOS_Assert", "(", "slot_hdr", ")", ";", "PIOS_Assert", "(", "curr_slot", ")", ";", "/*", "First", "slot", "in", "the", "arena", "is", "reserved", "for", "arena", "header,", "skip", "it.", "*/", "if", "(", "*", "curr_slot", "==", "0", ")", "{", "*", "curr_slot", "=", "1", ";", "}", "for", "(", "uint16_t", "slot_id", "=", "*", "curr_slot", ";", "slot_id", "<", "(", "logfs", "->", "cfg", "->", "arena_size", "/", "logfs", "->", "cfg", "->", "slot_size", ")", ";", "slot_id", "++", ")", "{", "uintptr_t", "slot_addr", "=", "logfs_get_addr", "(", "logfs", ",", "logfs", "->", "active_arena_id", ",", "slot_id", ")", ";", "if", "(", "logfs", "->", "driver", "->", "read_data", "(", "logfs", "->", "flash_id", ",", "slot_addr", ",", "(", "uint8_t", "*", ")", "slot_hdr", ",", "sizeof", "(", "*", "slot_hdr", ")", ")", "!=", "0", ")", "{", "return", "-", "2", ";", "}", "if", "(", "slot_hdr", "->", "state", "==", "SLOT_STATE_EMPTY", ")", "{", "/*", "We", "hit", "the", "end", "of", "the", "log", "*/", "break;", "}", "if", "(", "slot_hdr", "->", "state", "==", "SLOT_STATE_ACTIVE", "&&", "slot_hdr", "->", "obj_id", "==", "obj_id", "&&", "slot_hdr", "->", "obj_inst_id", "==", "obj_inst_id", ")", "{", "/*", "Found", "what", "we", "were", "looking", "for", "*/", "*", "curr_slot", "=", "slot_id", ";", "return", "0", ";", "}", "#", "ifdef", "PIOS_INCLUDE_WDG", "PIOS_WDG_Clear", "()", ";", "#", "endif", "}", "/*", "No", "matching", "entry", "was", "found", "*/", "return", "-", "1", ";", "}'" ]

[ "Delete", "one", "instance", "of", "an", "object", "from", "the", "filesystem" ]

[ "'int32_t", "PIOS_FLASHFS_ObjDelete", "(", "uintptr_t", "fs_id", ",", "uint32_t", "obj_id", ",", "uint16_t", "obj_inst_id", ")", "{", "int8_t", "rc", ";", "struct", "logfs_state", "*", "logfs", "=", "(", "struct", "logfs_state", "*", ")", "fs_id", ";", "if", "(", "!", "PIOS_FLASHFS_Logfs_validate", "(", "logfs", ")", ")", "{", "rc", "=", "-", "1", ";", "goto", "out_exit", ";", "}", "if", "(", "logfs", "->", "driver", "->", "start_transaction", "(", "logfs", "->", "flash_id", ")", "!=", "0", ")", "{", "rc", "=", "-", "2", ";", "goto", "out_exit", ";", "}", "if", "(", "logfs_delete_object", "(", "logfs", ",", "obj_id", ",", "obj_inst_id", ")", "!=", "0", ")", "{", "rc", "=", "-", "3", ";", "goto", "out_end_trans", ";", "}", "/*", "Object", "successfully", "deleted", "from", "the", "log", "*/", "rc", "=", "0", ";", "out_end_trans", ":", "logfs", "->", "driver", "->", "end_transaction", "(", "logfs", "->", "flash_id", ")", ";", "out_exit", ":", "return", "rc", ";", "}'" ]

[ "Returs", "stats", "for", "the", "filesystems" ]

[ "'int32_t", "PIOS_FLASHFS_GetStats", "(", "uintptr_t", "fs_id", ",", "struct", "PIOS_FLASHFS_Stats", "*", "stats", ")", "{", "PIOS_Assert", "(", "stats", ")", ";", "struct", "logfs_state", "*", "logfs", "=", "(", "struct", "logfs_state", "*", ")", "fs_id", ";", "if", "(", "!", "PIOS_FLASHFS_Logfs_validate", "(", "logfs", ")", ")", "{", "return", "-", "1", ";", "}", "stats", "->", "num_active_slots", "=", "logfs", "->", "num_active_slots", ";", "stats", "->", "num_free_slots", "=", "logfs", "->", "num_free_slots", ";", "return", "0", ";", "}'" ]

[ "Saves", "one", "object", "instance", "to", "the", "filesystem" ]

[ "\"int32_t", "PIOS_FLASHFS_ObjSave", "(", "uintptr_t", "fs_id", ",", "uint32_t", "obj_id", ",", "uint16_t", "obj_inst_id", ",", "uint8_t", "*", "obj_data", ",", "uint16_t", "obj_size", ")", "{", "int8_t", "rc", ";", "struct", "logfs_state", "*", "logfs", "=", "(", "struct", "logfs_state", "*", ")", "fs_id", ";", "if", "(", "!", "PIOS_FLASHFS_Logfs_validate", "(", "logfs", ")", ")", "{", "rc", "=", "-", "1", ";", "goto", "out_exit", ";", "}", "PIOS_Assert", "(", "obj_size", "<=", "(", "logfs", "->", "cfg", "->", "slot_size", "-", "sizeof", "(", "struct", "slot_header", ")", ")", ")", ";", "if", "(", "logfs", "->", "driver", "->", "start_transaction", "(", "logfs", "->", "flash_id", ")", "!=", "0", ")", "{", "rc", "=", "-", "2", ";", "goto", "out_exit", ";", "}", "if", "(", "logfs_delete_object", "(", "logfs", ",", "obj_id", ",", "obj_inst_id", ")", "!=", "0", ")", "{", "rc", "=", "-", "3", ";", "goto", "out_end_trans", ";", "}", "/*", "*", "All", "old", "versions", "of", "this", "object", "+", "instance", "have", "been", "invalidated.", "*", "Write", "the", "new", "object.", "*/", "/*", "Check", "if", "the", "arena", "is", "entirely", "full.", "*/", "if", "(", "logfs_fs_is_full", "(", "logfs", ")", ")", "{", "/*", "Note:", "Filesystem", "Full", "means", "we're", "full", "of", "*active*", "records", "so", "gc", "won't", "help", "at", "all.", "*/", "rc", "=", "-", "4", ";", "goto", "out_end_trans", ";", "}", "/*", "Is", "garbage", "collection", "required?", "*/", "if", "(", "logfs_log_is_full", "(", "logfs", ")", ")", "{", "/*", "Note:", "Log", "Full", "means", "the", "log", "is", "full", "but", "may", "contain", "obsolete", "slots", "so", "gc", "may", "free", "some", "space", "*/", "if", "(", "logfs_garbage_collect", "(", "logfs", ")", "!=", "0", ")", "{", "rc", "=", "-", "5", ";", "goto", "out_end_trans", ";", "}", "/*", "Check", "one", "more", "time", "just", "to", "be", "sure", "we", "actually", "free'd", "some", "space", "*/", "if", "(", "logfs_log_is_full", "(", "logfs", ")", ")", "{", "/*", "*", "Log", "is", "still", "full", "even", "after", "gc!", "*", "NOTE:", "This", "should", "not", "happen", "since", "the", "filesystem", "wasn't", "full", "*", "when", "we", "checked", "above", "so", "gc", "should", "have", "helped.", "*/", "PIOS_DEBUG_Assert", "(", "0", ")", ";", "rc", "=", "-", "6", ";", "goto", "out_end_trans", ";", "}", "}", "/*", "We", "have", "room", "for", "our", "new", "object.", "Append", "it", "to", "the", "log.", "*/", "if", "(", "logfs_append_to_log", "(", "logfs", ",", "obj_id", ",", "obj_inst_id", ",", "obj_data", ",", "obj_size", ")", "!=", "0", ")", "{", "/*", "Error", "during", "append", "*/", "rc", "=", "-", "7", ";", "goto", "out_end_trans", ";", "}", "/*", "Object", "successfully", "written", "to", "the", "log", "*/", "rc", "=", "0", ";", "out_end_trans", ":", "logfs", "->", "driver", "->", "end_transaction", "(", "logfs", "->", "flash_id", ")", ";", "out_exit", ":", "return", "rc", ";", "}\"" ]

[ "Marks", "the", "given", "arena", "as", "active", "so", "it", "can", "be", "mounted" ]

[ "\"static", "int32_t", "logfs_activate_arena", "(", "const", "struct", "logfs_state", "*", "logfs", ",", "uint8_t", "arena_id", ")", "{", "uintptr_t", "arena_addr", "=", "logfs_get_addr", "(", "logfs", ",", "arena_id", ",", "0", ")", ";", "/*", "Make", "sure", "this", "arena", "has", "been", "previously", "erased", "*/", "struct", "arena_header", "arena_hdr", ";", "if", "(", "logfs", "->", "driver", "->", "read_data", "(", "logfs", "->", "flash_id", ",", "arena_addr", ",", "(", "uint8_t", "*", ")", "&", "arena_hdr", ",", "sizeof", "(", "arena_hdr", ")", ")", "!=", "0", ")", "{", "/*", "Failed", "to", "read", "arena", "header", "*/", "return", "-", "1", ";", "}", "if", "(", "(", "arena_hdr", ".", "state", "!=", "ARENA_STATE_RESERVED", ")", "&&", "(", "arena_hdr", ".", "state", "!=", "ARENA_STATE_ERASED", ")", ")", "{", "/*", "Arena", "was", "not", "erased", "or", "reserved,", "can't", "activate", "it", "*/", "return", "-", "2", ";", "}", "/*", "Mark", "this", "arena", "as", "active", "*/", "arena_hdr", ".", "state", "=", "ARENA_STATE_ACTIVE", ";", "if", "(", "logfs", "->", "driver", "->", "write_data", "(", "logfs", "->", "flash_id", ",", "arena_addr", ",", "(", "uint8_t", "*", ")", "&", "arena_hdr", ",", "sizeof", "(", "arena_hdr", ")", ")", "!=", "0", ")", "{", "return", "-", "3", ";", "}", "/*", "The", "arena", "is", "now", "activated", "and", "the", "log", "may", "be", "mounted", "*/", "return", "0", ";", "}\"" ]

[ "Erases", "all", "filesystem", "arenas", "and", "activate", "the", "first", "arena" ]

[ "'int32_t", "PIOS_FLASHFS_Format", "(", "uintptr_t", "fs_id", ")", "{", "int32_t", "rc", ";", "struct", "logfs_state", "*", "logfs", "=", "(", "struct", "logfs_state", "*", ")", "fs_id", ";", "if", "(", "!", "PIOS_FLASHFS_Logfs_validate", "(", "logfs", ")", ")", "{", "rc", "=", "-", "1", ";", "goto", "out_exit", ";", "}", "if", "(", "logfs", "->", "mounted", ")", "{", "logfs_unmount_log", "(", "logfs", ")", ";", "}", "if", "(", "logfs", "->", "driver", "->", "start_transaction", "(", "logfs", "->", "flash_id", ")", "!=", "0", ")", "{", "rc", "=", "-", "2", ";", "goto", "out_exit", ";", "}", "if", "(", "logfs_erase_all_arenas", "(", "logfs", ")", "!=", "0", ")", "{", "rc", "=", "-", "3", ";", "goto", "out_end_trans", ";", "}", "/*", "Reinitialize", "arena", "0", "*/", "if", "(", "logfs_activate_arena", "(", "logfs", ",", "0", ")", "!=", "0", ")", "{", "rc", "=", "-", "4", ";", "goto", "out_end_trans", ";", "}", "/*", "Mount", "arena", "0", "*/", "if", "(", "logfs_mount_log", "(", "logfs", ",", "0", ")", "!=", "0", ")", "{", "rc", "=", "-", "5", ";", "goto", "out_end_trans", ";", "}", "/*", "Chip", "erased", "and", "log", "remounted", "successfully", "*/", "rc", "=", "0", ";", "out_end_trans", ":", "logfs", "->", "driver", "->", "end_transaction", "(", "logfs", "->", "flash_id", ")", ";", "out_exit", ":", "return", "rc", ";", "}'" ]

[ "Erases", "all", "sectors", "within", "the", "given", "arena", "and", "sets", "arena", "to", "erased", "state" ]

[ "'static", "int32_t", "logfs_erase_arena", "(", "const", "struct", "logfs_state", "*", "logfs", ",", "uint8_t", "arena_id", ")", "{", "uintptr_t", "arena_addr", "=", "logfs_get_addr", "(", "logfs", ",", "arena_id", ",", "0", ")", ";", "/*", "Erase", "all", "of", "the", "sectors", "in", "the", "arena", "*/", "for", "(", "uint8_t", "sector_id", "=", "0", ";", "sector_id", "<", "(", "logfs", "->", "cfg", "->", "arena_size", "/", "logfs", "->", "cfg", "->", "sector_size", ")", ";", "sector_id", "++", ")", "{", "#", "ifdef", "PIOS_INCLUDE_WDG", "PIOS_WDG_Clear", "()", ";", "#", "endif", "if", "(", "logfs", "->", "driver", "->", "erase_sector", "(", "logfs", "->", "flash_id", ",", "arena_addr", "+", "(", "sector_id", "*", "logfs", "->", "cfg", "->", "sector_size", ")", ")", ")", "{", "return", "-", "1", ";", "}", "}", "/*", "Mark", "this", "arena", "as", "fully", "erased", "*/", "struct", "arena_header", "arena_hdr", "=", "{", ".", "magic", "=", "logfs", "->", "cfg", "->", "fs_magic", ",", ".", "state", "=", "ARENA_STATE_ERASED", ",", "}", ";", "if", "(", "logfs", "->", "driver", "->", "write_data", "(", "logfs", "->", "flash_id", ",", "arena_addr", ",", "(", "uint8_t", "*", ")", "&", "arena_hdr", ",", "sizeof", "(", "arena_hdr", ")", ")", "!=", "0", ")", "{", "return", "-", "2", ";", "}", "/*", "Arena", "is", "ready", "to", "be", "activated", "*/", "return", "0", ";", "}'" ]

[ "threadshared", "initialization", "that", "should", "be", "repeated", "after", "a", "reset" ]

[ "'void", "link_reset_init", "(", "void", ")", "{", "if", "(", "DYNAMO_OPTION", "(", "separate_private_stubs", ")", "||", "DYNAMO_OPTION", "(", "separate_shared_stubs", ")", ")", "{", "stub_heap", "=", "special_heap_init", "(", "SEPARATE_STUB_ALLOC_SIZE", "(", "0", "/*default*/", ")", ",", "true", "/*", "must", "synch", "*/", ",", "true", "/*", "+x", "*/", ",", "false", "/*", "not", "persistent", "*/", ")", ";", "#", "if", "defined", "(", "X86", ")", "&&", "defined", "(", "X64", ")", "stub32_heap", "=", "special_heap_init", "(", "SEPARATE_STUB_ALLOC_SIZE", "(", "FRAG_32_BIT", ")", ",", "true", "/*", "must", "synch", "*/", ",", "true", "/*", "+x", "*/", ",", "false", "/*", "not", "persistent", "*/", ")", ";", "#", "endif", "}", "}'" ]

[ "Must", "pass", "NULL", "for", "exactly", "one", "of", "coarse", "or", "fine" ]

[ "'static", "coarse_incoming_t", "*", "prepend_new_coarse_incoming", "(", "coarse_info_t", "*", "info", ",", "cache_pc", "coarse", ",", "linkstub_t", "*", "fine", ")", "{", "coarse_incoming_t", "*", "entry", "=", "NONPERSISTENT_HEAP_TYPE_ALLOC", "(", "GLOBAL_DCONTEXT", ",", "coarse_incoming_t", ",", "ACCT_COARSE_LINK", ")", ";", "/*", "entries", "are", "freed", "in", "coarse_remove_outgoing()/coarse_unit_unlink()", "*/", "if", "(", "fine", "==", "NULL", ")", "{", "/*", "FIXME:", "rather", "than", "separate", "entries", "per", "stub", "pc,", "to", "save", "memory", "*", "we", "could", "have", "a", "single", "one", "for", "the", "whole", "unit", "(and", "we\\'d", "search", "*", "here", "to", "see", "if", "it", "already", "exists)", "and", "search", "when", "unlinking", "to", "*", "find", "the", "individual", "stubs", "*/", "ASSERT", "(", "coarse", "!=", "NULL", ")", ";", "entry", "->", "coarse", "=", "true", ";", "entry", "->", "in", ".", "stub_pc", "=", "coarse", ";", "LOG", "(", "THREAD_GET", ",", "LOG_LINKS", ",", "4", ",", "\"created", "new", "coarse_incoming_t", "\"", "PFX", "\"", "coarse", "from", "\"", "PFX", "\"\\\"", ",", "entry", ",", "entry", "->", "in", ".", "stub_pc", ")", ";", "}", "else", "{", "ASSERT", "(", "coarse", "==", "NULL", ")", ";", "entry", "->", "coarse", "=", "false", ";", "/*", "We", "put", "the", "whole", "linkstub_t", "list", "as", "one", "entry", "*/", "entry", "->", "in", ".", "fine_l", "=", "fine", ";", "LOG", "(", "THREAD_GET", ",", "LOG_LINKS", ",", "4", ",", "\"created", "new", "coarse_incoming_t", "\"", "PFX", "\"", "fine", "from", "\"", "PFX", "\"\\\"", ",", "entry", ",", "entry", "->", "in", ".", "fine_l", ")", ";", "DOCHECK", "(", "1", ",", "{", "linkstub_t", "*l;", "for", "(l", "=", "fine;", "l", "!=", "NULL;", "l", "=", "LINKSTUB_NEXT_INCOMING(l))", "ASSERT(!TEST(LINK_FAKE,", "l->flags));", "}", ")", ";", "}", "ASSERT", "(", "info", "!=", "NULL", ")", ";", "d_r_mutex_lock", "(", "&", "info", "->", "incoming_lock", ")", ";", "entry", "->", "next", "=", "info", "->", "incoming", ";", "info", "->", "incoming", "=", "entry", ";", "DOLOG", "(", "5", ",", "LOG_LINKS", ",", "{", "LOG(GLOBAL,", "LOG_LINKS,", "4", ",", "\"after", "adding", "new", "incoming", "\"", "PFX", "\":\\\"", ",", "entry);", "print_coarse_incoming(GLOBAL_DCONTEXT,", "info);", "}", ")", ";", "d_r_mutex_unlock", "(", "&", "info", "->", "incoming_lock", ")", ";", "return", "entry", ";", "}'" ]

[ "Returns", "true", "if", "the", "link", "from", "f's", "exit", "l", "exists", "in", "targetf's", "incoming", "list" ]

[ "'static", "bool", "incoming_link_exists", "(", "dcontext_t", "*", "dcontext", ",", "fragment_t", "*", "f", ",", "linkstub_t", "*", "l", ",", "fragment_t", "*", "targetf", ")", "{", "return", "incoming_find_link", "(", "dcontext", ",", "f", ",", "l", ",", "targetf", ")", "!=", "NULL", ";", "}'" ]

[ "Removes", "an", "incoming", "entry", "from", "a", "fine", "fragment", "to", "a", "coarse", "unit" ]

[ "'static", "void", "coarse_remove_incoming", "(", "dcontext_t", "*", "dcontext", ",", "fragment_t", "*", "src_f", ",", "linkstub_t", "*", "src_l", ",", "fragment_t", "*", "targetf", ")", "{", "coarse_info_t", "*", "info", "=", "get_fragment_coarse_info", "(", "targetf", ")", ";", "coarse_incoming_t", "*", "e", ",", "<type", "ref=\"prev\">", "*", "prev_e", ";", "ASSERT", "(", "!", "TEST", "(", "FRAG_COARSE_GRAIN", ",", "src_f", "->", "flags", ")", ")", ";", "ASSERT", "(", "!", "LINKSTUB_FAKE", "(", "src_l", ")", ")", ";", "ASSERT", "(", "TEST", "(", "FRAG_COARSE_GRAIN", ",", "targetf", "->", "flags", ")", ")", ";", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"coarse_remove_incoming", "%s", "\"", "PFX", "\"", "to", "\"", "PFX", "\"\\\"", ",", "info", "->", "module", ",", "src_f", "->", "tag", ",", "targetf", "->", "tag", ")", ";", "d_r_mutex_lock", "(", "&", "info", "->", "incoming_lock", ")", ";", "for", "(", "prev_e", "=", "NULL", ",", "e", "=", "info", "->", "incoming", ";", "e", "!=", "NULL", ";", "prev_e", "=", "e", ",", "e", "=", "e", "->", "next", ")", "{", "if", "(", "!", "e", "->", "coarse", ")", "{", "if", "(", "incoming_remove_link_search", "(", "dcontext", ",", "src_f", ",", "src_l", ",", "targetf", ",", "(", "common_direct_linkstub_t", "*", "*", ")", "&", "e", "->", "in", ".", "fine_l", ")", ")", "{", "if", "(", "e", "->", "in", ".", "fine_l", "==", "NULL", ")", "{", "/*", "If", "no", "fine", "entries", "left,", "remove", "the", "incoming", "entry", "wrapper", "*/", "if", "(", "prev_e", "==", "NULL", ")", "info", "->", "incoming", "=", "e", "->", "next", ";", "else", "prev_e", "->", "next", "=", "e", "->", "next", ";", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"freeing", "coarse_incoming_t", "\"", "PFX", "\"\\\"", ",", "e", ")", ";", "NONPERSISTENT_HEAP_TYPE_FREE", "(", "GLOBAL_DCONTEXT", ",", "e", ",", "coarse_incoming_t", ",", "ACCT_COARSE_LINK", ")", ";", "}", "break;", "}", "}", "}", "DOLOG", "(", "5", ",", "LOG_LINKS", ",", "{", "LOG(THREAD,", "LOG_LINKS,", "4", ",", "\"after", "removing", "incoming:\\\"", ");", "print_coarse_incoming(dcontext,", "info);", "}", ")", ";", "d_r_mutex_unlock", "(", "&", "info", "->", "incoming_lock", ")", ";", "}'" ]

[ "Either", "the", "stub", "pc", "or", "the", "cti", "pc", "will", "work,", "as", "indirect", "stubs", "are", "inlined" ]

[ "'cache_pc", "get_coarse_ibl_prefix", "(", "dcontext_t", "*", "dcontext", ",", "cache_pc", "stub_pc", ",", "ibl_branch_type_t", "branch_type", ")", "{", "/*", "Indirect", "stubs", "are", "inlined", "in", "the", "cache", "*/", "coarse_info_t", "*", "info", "=", "(", "coarse_info_t", "*", ")", "get_fcache_coarse_info", "(", "stub_pc", ")", ";", "if", "(", "info", "!=", "NULL", ")", "{", "if", "(", "branch_type", "==", "IBL_RETURN", ")", "return", "info", "->", "ibl_ret_prefix", ";", "<if", "type=\"elseif\">", "else", "if", "(", "branch_type", "==", "IBL_INDCALL", ")", "return", "info", "->", "ibl_call_prefix", ";", "<if", "type=\"elseif\">", "else", "if", "(", "branch_type", "==", "IBL_INDJMP", ")", "return", "info", "->", "ibl_jmp_prefix", ";", "else", "ASSERT_NOT_REACHED", "()", ";", "}", "return", "NULL", ";", "}'" ]

[ "Removes", "any", "incoming", "data", "recording", "the", "outgoing", "link", "from", "stub" ]

[ "'void", "coarse_remove_outgoing", "(", "dcontext_t", "*", "dcontext", ",", "cache_pc", "stub", ",", "coarse_info_t", "*", "src_info", ")", "{", "cache_pc", "target_tag", "=", "entrance_stub_target_tag", "(", "stub", ",", "src_info", ")", ";", "/*", "ASSUMPTION:", "coarse-grain", "are", "always", "shared", "and", "cannot", "target", "private", "*/", "fragment_t", "*", "targetf", "=", "fragment_lookup_same_sharing", "(", "dcontext", ",", "target_tag", ",", "FRAG_SHARED", ")", ";", "ASSERT", "(", "entrance_stub_linked", "(", "stub", ",", "src_info", ")", ")", ";", "if", "(", "targetf", "!=", "NULL", ")", "{", "/*", "targeting", "a", "real", "fragment_t", "*/", "direct_linkstub_t", "proxy", ";", "set_fake_direct_linkstub", "(", "&", "proxy", ",", "target_tag", ",", "stub", ")", ";", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"", "removing", "coarse", "link", "\"", "PFX", "\"", "->", "F%d(\"", "PFX", "\").\"", "PFX", "\"\\\"", ",", "stub", ",", "targetf", "->", "id", ",", "targetf", "->", "tag", ",", "FCACHE_ENTRY_PC", "(", "targetf", ")", ")", ";", "incoming_remove_link", "(", "dcontext", ",", "(", "fragment_t", "*", ")", "&", "coarse_fragment", ",", "(", "linkstub_t", "*", ")", "&", "proxy", ",", "targetf", ")", ";", "ASSERT", "(", "entrance_stub_linked", "(", "stub", ",", "src_info", ")", ")", ";", "/*", "case", "9635:", "pass", "flags", "*/", "unlink_entrance_stub", "(", "dcontext", ",", "stub", ",", "targetf", "->", "flags", ",", "src_info", ")", ";", "}", "else", "{", "cache_pc", "target_pc", "=", "entrance_stub_jmp_target", "(", "stub", ")", ";", "coarse_info_t", "*", "target_info", "=", "get_fcache_coarse_info", "(", "target_pc", ")", ";", "/*", "can", "only", "be", "NULL", "if", "targeting", "fine", "fragment,", "which", "is", "covered", "above!", "*/", "ASSERT", "(", "target_info", "!=", "NULL", ")", ";", "if", "(", "target_info", "!=", "src_info", ")", "{", "coarse_incoming_t", "*", "e", ",", "<type", "ref=\"prev\">", "*", "prev_e", "=", "NULL", ";", "bool", "found", "=", "false", ";", "unlink_entrance_stub", "(", "dcontext", ",", "stub", ",", "0", ",", "src_info", ")", ";", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"", "removing", "coarse", "link", "\"", "PFX", "\"", "->", "%s", "\"", "PFX", "\"\\\"", ",", "stub", ",", "target_info", "->", "module", ",", "target_tag", ")", ";", "d_r_mutex_lock", "(", "&", "target_info", "->", "incoming_lock", ")", ";", "for", "(", "e", "=", "target_info", "->", "incoming", ";", "e", "!=", "NULL", ";", "e", "=", "e", "->", "next", ")", "{", "if", "(", "e", "->", "coarse", "&&", "e", "->", "in", ".", "stub_pc", "==", "stub", ")", "{", "if", "(", "prev_e", "==", "NULL", ")", "target_info", "->", "incoming", "=", "e", "->", "next", ";", "else", "prev_e", "->", "next", "=", "e", "->", "next", ";", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"freeing", "coarse_incoming_t", "\"", "PFX", "\"\\\"", ",", "e", ")", ";", "NONPERSISTENT_HEAP_TYPE_FREE", "(", "GLOBAL_DCONTEXT", ",", "e", ",", "coarse_incoming_t", ",", "ACCT_COARSE_LINK", ")", ";", "found", "=", "true", ";", "break;", "}", "else", "prev_e", "=", "e", ";", "}", "DOLOG", "(", "5", ",", "LOG_LINKS", ",", "{", "LOG(THREAD,", "LOG_LINKS,", "4", ",", "\"after", "removing", "outgoing,", "target:\\\"", ");", "print_coarse_incoming(dcontext,", "target_info);", "}", ")", ";", "d_r_mutex_unlock", "(", "&", "target_info", "->", "incoming_lock", ")", ";", "ASSERT", "(", "found", ")", ";", "}", "else", "{", "/*", "an", "intra-unit", "link,", "so", "no", "incoming", "entry", "*/", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"", "not", "removing", "coarse", "link", "to", "self", "\"", "PFX", "\"", "->", "%s", "\"", "PFX", "\"\\\"", ",", "stub", ",", "target_info", "->", "module", ",", "target_tag", ")", ";", "}", "}", "}'" ]

[ "current", "prefix", "size", "is", "37", "bytes,", "so", "need", "3", "stub", "slots" ]

[ "'static", "inline", "uint", "num_coarse_stubs_for_prefix", "(", "coarse_info_t", "*", "info", ")", "{", "uint", "prefix_size", "=", "coarse_exit_prefix_size", "(", "info", ")", ";", "size_t", "stub_size", "=", "COARSE_STUB_ALLOC_SIZE", "(", "COARSE_32_FLAG", "(", "info", ")", ")", ";", "ASSERT", "(", "CHECK_TRUNCATE_TYPE_uint", "(", "ALIGN_FORWARD", "(", "prefix_size", ",", "stub_size", ")", ")", ")", ";", "return", "(", "uint", ")", "(", "ALIGN_FORWARD", "(", "prefix_size", ",", "stub_size", ")", "/", "stub_size", ")", ";", "}'" ]

[ "is", "a", "post_linkstub_t", "structure", "required", "to", "store", "the", "fragment_t", "offset?" ]

[ "\"bool", "linkstub_frag_offs_at_end", "(", "uint", "flags", ",", "int", "direct_exits", ",", "int", "indirect_exits", ")", "{", "ASSERT", "(", "(", "direct_exits", "+", "indirect_exits", ">", "0", ")", "||", "TEST", "(", "FRAG_COARSE_GRAIN", ",", "flags", ")", ")", ";", "/*", "common", "bb", "types", "do", "not", "have", "an", "offset", "at", "the", "end:", "*", "1)", "single", "indirect", "exit", "*", "2)", "two", "direct", "exits", "*", "3)", "coarse-grain,", "which", "of", "course", "have", "no", "fragment_t", "*", "see", "linkstub_fragment()", "for", "how", "we", "find", "their", "owning", "fragment_t's.", "*", "Since", "we", "have", "to", "assume", "sizeof(fragment_t)", "we", "can", "only", "allow", "*", "shared", "fragments", "to", "not", "have", "an", "offset,", "unless", "we", "add", "a", "LINK_SHARED", "*", "flag,", "which", "we", "can", "do", "if", "we", "end", "up", "having", "a", "product", "config", "w/", "private", "bbs.", "*", "FIXME:", "make", "the", "sizeof", "calculation", "dynamic", "such", "that", "the", "dominant", "*", "type", "of", "bb", "fragment", "is", "the", "one", "w/o", "the", "post_linkstub_t.", "*/", "return", "!", "(", "!", "TEST", "(", "FRAG_IS_TRACE", ",", "flags", ")", "&&", "TEST", "(", "FRAG_SHARED", ",", "flags", ")", "&&", "/*", "We", "can't", "tell", "from", "the", "linkstub_t", "whether", "there", "is", "a", "*", "translation", "field.", "FIXME:", "we", "could", "avoid", "this", "problem", "*", "by", "storing", "the", "translation", "field", "after", "the", "linkstubs.", "*/", "!", "TEST", "(", "FRAG_HAS_TRANSLATION_INFO", ",", "flags", ")", "&&", "(", "(", "direct_exits", "==", "2", "&&", "indirect_exits", "==", "0", ")", "||", "(", "direct_exits", "==", "0", "&&", "indirect_exits", "==", "1", ")", ")", ")", "&&", "!", "TEST", "(", "FRAG_COARSE_GRAIN", ",", "flags", ")", ";", "}\"" ]

[ "Locate", "the", "owning", "fragment_t", "for", "a", "linkstub_t" ]

[ "'fragment_t", "*", "linkstub_fragment", "(", "dcontext_t", "*", "dcontext", ",", "linkstub_t", "*", "l", ")", "{", "if", "(", "LINKSTUB_FAKE", "(", "l", ")", ")", "{", "#", "ifdef", "WINDOWS", "if", "(", "l", "==", "&", "linkstub_shared_syscall_trace", ")", "return", "(", "fragment_t", "*", ")", "&", "linkstub_shared_syscall_trace_fragment", ";", "<if", "type=\"elseif\">", "else", "if", "(", "l", "==", "&", "linkstub_shared_syscall_bb", ")", "return", "(", "fragment_t", "*", ")", "&", "linkstub_shared_syscall_bb_fragment", ";", "#", "endif", "if", "(", "l", "==", "&", "linkstub_ibl_trace_ret", "||", "l", "==", "&", "linkstub_ibl_trace_jmp", "||", "l", "==", "&", "linkstub_ibl_trace_call", ")", "return", "(", "fragment_t", "*", ")", "&", "linkstub_ibl_trace_fragment", ";", "<if", "type=\"elseif\">", "else", "if", "(", "l", "==", "&", "linkstub_ibl_bb_ret", "||", "l", "==", "&", "linkstub_ibl_bb_jmp", "||", "l", "==", "&", "linkstub_ibl_bb_call", ")", "return", "(", "fragment_t", "*", ")", "&", "linkstub_ibl_bb_fragment", ";", "if", "(", "dcontext", "!=", "NULL", "&&", "dcontext", "!=", "GLOBAL_DCONTEXT", ")", "{", "thread_link_data_t", "*", "ldata", "=", "(", "thread_link_data_t", "*", ")", "dcontext", "->", "link_field", ";", "if", "(", "l", "==", "&", "ldata", "->", "linkstub_deleted", ")", "return", "&", "ldata", "->", "linkstub_deleted_fragment", ";", "}", "/*", "For", "coarse", "proxies,", "we", "need", "a", "fake", "FRAG_SHARED", "fragment_t", "for", "is_linkable", "*/", "if", "(", "LINKSTUB_COARSE_PROXY", "(", "l", "->", "flags", ")", ")", "return", "(", "fragment_t", "*", ")", "&", "coarse_fragment", ";", "return", "(", "fragment_t", "*", ")", "&", "linkstub_empty_fragment", ";", "}", "/*", "To", "save", "space", "we", "no", "longer", "store", "a", "backpointer", "in", "the", "linkstub_t.", "*", "Instead", "we", "use", "several", "schemes", "based", "on", "the", "type", "of", "owning", "*", "fragment_t.", "We", "could", "walk", "backward", "but", "that", "gets", "complicated", "with", "*", "hacks", "to", "distinguish", "types", "of", "structs", "by", "their", "final", "fields", "w/o", "*", "adding", "secondary", "flags", "fields.", "*/", "if", "(", "TEST", "(", "LINK_FRAG_OFFS_AT_END", ",", "l", "->", "flags", ")", ")", "{", "/*", "For", "traces", "and", "unusual", "bbs,", "we", "store", "an", "offset", "to", "the", "*", "fragment_t", "at", "the", "end", "of", "the", "linkstub_t", "list.", "*/", "post_linkstub_t", "*", "post", ";", "for", "(", ";", "!", "LINKSTUB_FINAL", "(", "l", ")", ";", "l", "=", "LINKSTUB_NEXT_EXIT", "(", "l", ")", ")", ";", "/*", "nothing", "*/", "ASSERT", "(", "l", "!=", "NULL", "&&", "TEST", "(", "LINK_END_OF_LIST", ",", "l", "->", "flags", ")", ")", ";", "post", "=", "(", "post_linkstub_t", "*", ")", "(", "(", "(", "byte", "*", ")", "l", ")", "+", "LINKSTUB_SIZE", "(", "l", ")", ")", ";", "return", "(", "fragment_t", "*", ")", "(", "(", "(", "byte", "*", ")", "post", ")", "-", "post", "->", "fragment_offset", ")", ";", "}", "else", "{", "/*", "Otherwise,", "we", "assume", "this", "is", "one", "of", "2", "types", "of", "basic", "block!", "*/", "if", "(", "LINKSTUB_INDIRECT", "(", "l", "->", "flags", ")", ")", "{", "/*", "Option", "1:", "a", "single", "indirect", "exit", "*/", "ASSERT", "(", "TEST", "(", "LINK_END_OF_LIST", ",", "l", "->", "flags", ")", ")", ";", "return", "(", "fragment_t", "*", ")", "(", "(", "(", "byte", "*", ")", "l", ")", "-", "sizeof", "(", "fragment_t", ")", ")", ";", "}", "else", "{", "ASSERT", "(", "LINKSTUB_DIRECT", "(", "l", "->", "flags", ")", ")", ";", "/*", "Option", "2:", "two", "direct", "exits", "(doesn\\'t", "matter", "if", "2nd", "uses", "*", "cbr_fallthrough_linkstub_t", "or", "not)", "*", "(single", "direct", "exit", "is", "very", "rare", "but", "if", "later", "becomes", "common", "*", "could", "add", "a", "LINK_", "flag", "to", "distinguish)", "*/", "if", "(", "TEST", "(", "LINK_END_OF_LIST", ",", "l", "->", "flags", ")", ")", "{", "return", "(", "fragment_t", "*", ")", "(", "(", "(", "byte", "*", ")", "l", ")", "-", "sizeof", "(", "direct_linkstub_t", ")", "-", "sizeof", "(", "fragment_t", ")", ")", ";", "}", "else", "{", "return", "(", "fragment_t", "*", ")", "(", "(", "(", "byte", "*", ")", "l", ")", "-", "sizeof", "(", "fragment_t", ")", ")", ";", "}", "}", "}", "ASSERT_NOT_REACHED", "()", ";", "return", "NULL", ";", "}'" ]

[ "Sets", "flags", "for", "a", "fake", "linkstub_t", "for", "an", "incoming", "list", "entry", "for", "a", "coarse", "source" ]

[ "'static", "void", "set_fake_direct_linkstub", "(", "direct_linkstub_t", "*", "proxy", ",", "app_pc", "target", ",", "cache_pc", "stub", ")", "{", "/*", "ASSUMPTION:", "this", "combination", "is", "unique", "to", "coarse-grain", "proxy", "stubs.", "*", "The", "LINKSTUB_COARSE_PROXY()", "macro", "tests", "these", "(except", "LINK_LINKED).", "*/", "proxy", "->", "cdl", ".", "l", ".", "flags", "=", "LINK_FAKE", "|", "LINK_DIRECT", "|", "LINK_LINKED", "|", "LINK_SEPARATE_STUB", ";", "proxy", "->", "cdl", ".", "l", ".", "cti_offset", "=", "0", ";", "proxy", "->", "target_tag", "=", "target", ";", "proxy", "->", "stub_pc", "=", "stub", ";", "}'" ]

[ "Initializes", "an", "array", "of", "linkstubs", "beginning", "with", "first" ]

[ "\"void", "linkstubs_init", "(", "linkstub_t", "*", "first", ",", "int", "num_direct", ",", "int", "num_indirect", ",", "fragment_t", "*", "f", ")", "{", "/*", "we", "don't", "know", "the", "sequencing", "of", "direct", "and", "indirect", "so", "all", "we", "do", "*", "here", "is", "zero", "everything", "out", "*/", "uint", "size", "=", "linkstubs_heap_size", "(", "f", "->", "flags", ",", "num_direct", ",", "num_indirect", ")", ";", "ASSERT", "(", "num_direct", "+", "num_indirect", ">", "0", ")", ";", "memset", "(", "first", ",", "0", ",", "size", ")", ";", "/*", "place", "the", "offset", "to", "the", "fragment_t*,", "if", "necessary", "*/", "if", "(", "linkstub_frag_offs_at_end", "(", "f", "->", "flags", ",", "num_direct", ",", "num_indirect", ")", ")", "{", "ushort", "offs", ";", "/*", "size", "includes", "post_linkstub_t", "so", "we", "have", "to", "subtract", "it", "off", "*/", "post_linkstub_t", "*", "post", "=", "(", "post_linkstub_t", "*", ")", "(", "(", "(", "byte", "*", ")", "first", ")", "+", "size", "-", "sizeof", "(", "post_linkstub_t", ")", ")", ";", "ASSERT_TRUNCATE", "(", "offs", ",", "ushort", ",", "(", "(", "(", "byte", "*", ")", "post", ")", "-", "(", "(", "byte", "*", ")", "f", ")", ")", ")", ";", "offs", "=", "(", "ushort", ")", "(", "(", "(", "byte", "*", ")", "post", ")", "-", "(", "(", "byte", "*", ")", "f", ")", ")", ";", "post", "->", "fragment_offset", "=", "offs", ";", "}", "}\"" ]

[ "Updates", "the", "info", "pointers", "embedded", "in", "the", "coarse_stub_areas", "vector" ]

[ "'void", "coarse_stubs_set_info", "(", "coarse_info_t", "*", "info", ")", "{", "special_heap_set_vector_data", "(", "info", "->", "stubs", ",", "info", ")", ";", "}'" ]

[ "fragment_t", "f", "is", "being", "removed" ]

[ "'future_fragment_t", "*", "incoming_remove_fragment", "(", "dcontext_t", "*", "dcontext", ",", "fragment_t", "*", "f", ")", "{", "future_fragment_t", "*", "future", "=", "NULL", ";", "linkstub_t", "*", "l", ";", "/*", "pendel-del", "frags", "use", "fragment_t.in_xlate", "differently:", "they", "should", "*", "never", "call", "this", "routine", "once", "they\\'re", "marked", "for", "deletion", "*/", "ASSERT", "(", "!", "TEST", "(", "FRAG_WAS_DELETED", ",", "f", "->", "flags", ")", ")", ";", "/*", "link", "data", "struct", "change", "in", "shared", "fragment", "must", "be", "synchronized", "*", "no", "links", "across", "caches", "so", "only", "checking", "f\\'s", "sharedness", "is", "enough", "*/", "ASSERT", "(", "!", "NEED_SHARED_LOCK", "(", "f", "->", "flags", ")", "||", "self_owns_recursive_lock", "(", "&", "change_linking_lock", ")", ")", ";", "/*", "if", "removing", "shared", "trace,", "move", "its", "links", "back", "to", "the", "shadowed", "shared", "trace", "head", "*/", "/*", "flags", "not", "preserved", "for", "coarse", "so", "we", "have", "to", "check", "all", "coarse", "bbs", "*/", "if", "(", "TESTANY", "(", "FRAG_TRACE_LINKS_SHIFTED", "|", "FRAG_COARSE_GRAIN", ",", "f", "->", "flags", ")", ")", "{", "if", "(", "TEST", "(", "FRAG_IS_TRACE", ",", "f", "->", "flags", ")", ")", "{", "fragment_t", "wrapper", ";", "/*", "FIXME", "case", "8600:", "provide", "single", "lookup", "routine", "here", "*/", "fragment_t", "*", "bb", "=", "fragment_lookup_bb", "(", "dcontext", ",", "f", "->", "tag", ")", ";", "if", "(", "bb", "==", "NULL", "||", "(", "bb", "->", "flags", "&", "FRAG_SHARED", ")", "!=", "(", "f", "->", "flags", "&", "FRAG_SHARED", ")", ")", "{", "/*", "Can\\'t", "use", "lookup_fine_and_coarse", "since", "trace", "will", "shadow", "coarse", "*/", "bb", "=", "fragment_coarse_lookup_wrapper", "(", "dcontext", ",", "f", "->", "tag", ",", "&", "wrapper", ")", ";", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"incoming_remove_fragment", "shared", "trace", "\"", "PFX", "\":", "%s", "coarse", "thead\\\"", ",", "f", "->", "tag", ",", "bb", "==", "NULL", "?", "\"did", "not", "find\"", ":", "\"found\"", ")", ";", "}", "if", "(", "bb", "!=", "NULL", "&&", "(", "TESTANY", "(", "FRAG_TRACE_LINKS_SHIFTED", "|", "FRAG_COARSE_GRAIN", ",", "bb", "->", "flags", ")", ")", ")", "{", "ASSERT", "(", "TEST", "(", "FRAG_IS_TRACE_HEAD", ",", "bb", "->", "flags", ")", "||", "TEST", "(", "FRAG_COARSE_GRAIN", ",", "bb", "->", "flags", ")", ")", ";", "/*", "FIXME:", "this", "will", "mark", "trace", "head", "as", "FRAG_LINKED_INCOMING", "--", "*", "but", "then", "same", "thing", "for", "a", "new", "bb", "marked", "as", "a", "trace", "head", "*", "before", "linking", "via", "its", "previous", "future,", "so", "not", "a", "new", "problem.", "*", "won\\'t", "actually", "link", "incoming", "since", "!linkable.", "*/", "if", "(", "TEST", "(", "FRAG_COARSE_GRAIN", ",", "bb", "->", "flags", ")", ")", "{", "/*", "We", "assume", "the", "coarse-grain", "bb", "is", "a", "trace", "head", "--", "our", "method", "*", "of", "lookup", "is", "unable", "to", "mark", "it", "so", "we", "mark", "it", "here", "*/", "bb", "->", "flags", "|=", "FRAG_IS_TRACE_HEAD", ";", "}", "shift_links_to_new_fragment", "(", "dcontext", ",", "f", ",", "bb", ")", ";", "STATS_INC", "(", "links_shared_trace_to_head", ")", ";", "ASSERT", "(", "f", "->", "in_xlate", ".", "incoming_stubs", "==", "NULL", ")", ";", "return", "NULL", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "TEST", "(", "FRAG_IS_TRACE_HEAD", ",", "f", "->", "flags", ")", ")", "{", "fragment_t", "*", "trace", "=", "fragment_lookup_trace", "(", "dcontext", ",", "f", "->", "tag", ")", ";", "/*", "regardless", "of", "-remove_shared_trace_heads,", "a", "shared", "trace", "will", "*", "at", "least", "briefly", "shadow", "and", "shift", "links", "from", "a", "shared", "trace", "head.", "*", "FIXME:", "add", "a", "FRAG_LINKS_SHIFTED", "flag", "to", "know", "for", "sure?", "*/", "if", "(", "trace", "!=", "NULL", "&&", "(", "trace", "->", "flags", "&", "FRAG_SHARED", ")", "==", "(", "f", "->", "flags", "&", "FRAG_SHARED", ")", ")", "{", "/*", "nothing", "to", "do", "--", "links", "already", "shifted,", "no", "future", "needed", "*/", "STATS_INC", "(", "shadowed_trace_head_deleted", ")", ";", "ASSERT", "(", "f", "->", "in_xlate", ".", "incoming_stubs", "==", "NULL", ")", ";", "return", "NULL", ";", "}", "}", "}", "/*", "remove", "outgoing", "links", "from", "others\\'", "incoming", "lists", "*/", "for", "(", "l", "=", "FRAGMENT_EXIT_STUBS", "(", "f", ")", ";", "l", ";", "l", "=", "LINKSTUB_NEXT_EXIT", "(", "l", ")", ")", "{", "if", "(", "LINKSTUB_DIRECT", "(", "l", "->", "flags", ")", ")", "{", "/*", "must", "explicitly", "check", "for", "self", "--", "may", "not", "be", "in", "table,", "if", "*", "flushing", "due", "to", "munmap", "*/", "fragment_t", "*", "targetf", ";", "app_pc", "target_tag", "=", "EXIT_TARGET_TAG", "(", "dcontext", ",", "f", ",", "l", ")", ";", "if", "(", "target_tag", "==", "f", "->", "tag", ")", "targetf", "=", "f", ";", "else", "{", "/*", "only", "want", "fragments", "in", "same", "shared/private", "cache", "*/", "targetf", "=", "fragment_link_lookup_same_sharing", "(", "dcontext", ",", "target_tag", ",", "NULL", ",", "f", "->", "flags", ")", ";", "if", "(", "targetf", "==", "NULL", ")", "{", "/*", "don\\'t", "worry,", "all", "routines", "can", "handle", "fragment_t*", "that", "is", "really", "*", "future_fragment_t*", "*/", "/*", "make", "sure", "future", "is", "in", "proper", "shared/private", "table", "*/", "if", "(", "!", "TEST", "(", "FRAG_SHARED", ",", "f", "->", "flags", ")", ")", "{", "targetf", "=", "(", "fragment_t", "*", ")", "fragment_lookup_private_future", "(", "dcontext", ",", "target_tag", ")", ";", "}", "else", "{", "targetf", "=", "(", "fragment_t", "*", ")", "fragment_lookup_future", "(", "dcontext", ",", "target_tag", ")", ";", "}", "}", "}", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"", "removed", "F%d(\"", "PFX", "\").\"", "PFX", "\"", "->", "(\"", "PFX", "\")", "from", "incoming", "list\\\"", ",", "f", "->", "id", ",", "f", "->", "tag", ",", "EXIT_CTI_PC", "(", "f", ",", "l", ")", ",", "target_tag", ")", ";", "ASSERT", "(", "targetf", "!=", "NULL", ")", ";", "if", "(", "targetf", "!=", "NULL", ")", "/*", "play", "it", "safe", "*/", "incoming_remove_link", "(", "dcontext", ",", "f", ",", "l", ",", "targetf", ")", ";", "}", "}", "if", "(", "TEST", "(", "FRAG_TEMP_PRIVATE", ",", "f", "->", "flags", ")", "&&", "f", "->", "in_xlate", ".", "incoming_stubs", "==", "NULL", ")", "{", "/*", "if", "there", "are", "incoming", "stubs,", "the", "private", "displaced", "a", "prior", "future,", "which", "*", "does", "need", "to", "be", "replaced", "--", "if", "not,", "we", "don\\'t", "need", "a", "future", "*/", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"", "not", "bothering", "with", "future", "for", "temp", "private", "F%d(\"", "PFX", "\")\\\"", ",", "f", "->", "id", ",", "f", "->", "tag", ")", ";", "STATS_INC", "(", "num_trace_private_fut_avoid", ")", ";", "return", "NULL", ";", "}", "/*", "add", "future", "fragment", "*", "FIXME:", "optimization", "is", "to", "convert", "f", "to", "future,", "that", "requires", "*", "coordinating", "with", "fragment_remove,", "fragment_delete,", "etc.", "*/", "LOG", "(", "THREAD", ",", "LOG_LINKS", ",", "4", ",", "\"", "adding", "future", "fragment", "for", "deleted", "F%d(\"", "PFX", "\")\\\"", ",", "f", "->", "id", ",", "f", "->", "tag", ")", ";", "DOCHECK", "(", "1", ",", "{", "if", "(TEST(FRAG_SHARED,", "f->flags))", "ASSERT(fragment_lookup_future(dcontext,", "f->tag)", "==", "NULL);", "else", "ASSERT(fragment_lookup_private_future(dcontext,", "f->tag)", "==", "NULL);", "}", ")", ";", "future", "=", "fragment_create_and_add_future", "(", "dcontext", ",", "f", "->", "tag", ",", "/*", "make", "sure", "future", "is", "in", "proper", "shared/private", "table.", "*", "Do", "not", "keep", "FRAG_TEMP_PRIVATE", "as", "getting", "here", "means", "*", "there", "was", "a", "real", "future", "here", "before", "the", "private,", "so", "our", "*", "future", "removal", "optimization", "does", "not", "apply.", "*/", "(", "FRAG_SHARED", "&", "f", "->", "flags", ")", "|", "FRAG_WAS_DELETED", ")", ";", "future", "->", "incoming_stubs", "=", "f", "->", "in_xlate", ".", "incoming_stubs", ";", "DODEBUG", "(", "{", "f->in_xlate.incoming_stubs", "=", "NULL;", "}", ")", ";", "return", "future", ";", "}'" ]

[ "Pass", "in", "coarse", "if", "you", "already", "know", "it;", "else,", "this", "routine", "will", "look", "it", "up" ]

[ "'static", "fragment_t", "*", "fragment_coarse_link_wrapper", "(", "dcontext_t", "*", "dcontext", ",", "app_pc", "target_tag", ",", "cache_pc", "know_coarse", ")", "{", "ASSERT", "(", "self_owns_recursive_lock", "(", "&", "change_linking_lock", ")", ")", ";", "if", "(", "know_coarse", "==", "NULL", ")", "{", "return", "fragment_coarse_lookup_wrapper", "(", "dcontext", ",", "target_tag", ",", "&", "temp_targetf", ")", ";", "}", "else", "{", "fragment_coarse_wrapper", "(", "&", "temp_targetf", ",", "target_tag", ",", "know_coarse", ")", ";", "return", "&", "temp_targetf", ";", "}", "return", "NULL", ";", "}'" ]

[ "includes", "the", "post_linkstub_t", "offset", "struct", "size" ]

[ "'uint", "linkstubs_heap_size", "(", "uint", "flags", ",", "int", "direct_exits", ",", "int", "indirect_exits", ")", "{", "uint", "offset_sz", ",", "<type", "ref=\"prev\"/>", "linkstub_size", ";", "ASSERT", "(", "(", "direct_exits", "+", "indirect_exits", ">", "0", ")", "||", "TEST", "(", "FRAG_COARSE_GRAIN", ",", "flags", ")", ")", ";", "if", "(", "use_cbr_fallthrough_short", "(", "flags", ",", "direct_exits", ",", "indirect_exits", ")", ")", "{", "linkstub_size", "=", "sizeof", "(", "direct_linkstub_t", ")", "+", "sizeof", "(", "cbr_fallthrough_linkstub_t", ")", ";", "}", "else", "{", "linkstub_size", "=", "direct_exits", "*", "sizeof", "(", "direct_linkstub_t", ")", "+", "indirect_exits", "*", "sizeof", "(", "indirect_linkstub_t", ")", ";", "}", "if", "(", "linkstub_frag_offs_at_end", "(", "flags", ",", "direct_exits", ",", "indirect_exits", ")", ")", "offset_sz", "=", "sizeof", "(", "post_linkstub_t", ")", ";", "else", "offset_sz", "=", "0", ";", "return", "linkstub_size", "+", "offset_sz", ";", "}'" ]

[ "we", "don't", "want", "to", "propagate", "our", "cbr", "hack", "during", "trace", "building,", "etc" ]

[ "'uint", "linkstub_propagatable_flags", "(", "uint", "flags", ")", "{", "if", "(", "LINKSTUB_CBR_FALLTHROUGH", "(", "flags", ")", ")", "flags", "&=", "~", "LINK_INDIRECT", ";", "return", "flags", ";", "}'" ]

[ "Passing", "in", "stub_pc's", "info", "avoids", "a", "vmvector", "lookup" ]

[ "'cache_pc", "trace_head_return_coarse_prefix", "(", "cache_pc", "stub_pc", ",", "coarse_info_t", "*", "info", "/*OPTIONAL*/", ")", "{", "if", "(", "info", "==", "NULL", ")", "info", "=", "(", "coarse_info_t", "*", ")", "vmvector_lookup", "(", "coarse_stub_areas", ",", "stub_pc", ")", ";", "else", "{", "DOCHECK", "(", "CHKLVL_DEFAULT", "+", "1", ",", "{", "/*", "PR", "307698:", "perf", "hit", "*/", "ASSERT(info", "==", "vmvector_lookup(coarse_stub_areas,", "stub_pc));", "}", ")", ";", "}", "if", "(", "info", "!=", "NULL", ")", "{", "return", "info", "->", "trace_head_return_prefix", ";", "}", "return", "NULL", ";", "}'" ]

[ "update", "the", "x", "position", "of", "a", "decoration" ]

[ "'void", "deco_update", "(", "struct", "SYMBOL", "*", "s", ",", "float", "dx", ")", "{", "struct", "deco_elt", "*", "de", ";", "for", "(", "de", "=", "deco_head", ";", "de", ";", "de", "=", "de", "->", "next", ")", "{", "if", "(", "de", "->", "s", "==", "s", ")", "{", "while", "(", "de", "&&", "de", "->", "s", "==", "s", ")", "{", "de", "->", "x", "+=", "dx", ";", "de", "=", "de", "->", "next", ";", "}", "break;", "}", "}", "}'" ]

[ "get", "the", "max", "min", "vertical", "offset" ]

[ "'float", "y_get", "(", "int", "staff", ",", "int", "up", ",", "float", "x", ",", "float", "w", ")", "{", "struct", "STAFF_S", "*", "p_staff", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "float", "y", ";", "p_staff", "=", "&", "staff_tb", "[", "staff", "]", ";", "i", "=", "(", "int", ")", "(", "x", "/", "realwidth", "*", "YSTEP", ")", ";", "if", "(", "i", "<", "0", ")", "{", "//", "fprintf(stderr,", "\"y_get", "i:%d\\\",", "i);", "i", "=", "0", ";", "}", "j", "=", "(", "int", ")", "(", "(", "x", "+", "w", ")", "/", "realwidth", "*", "YSTEP", ")", ";", "if", "(", "j", ">=", "YSTEP", ")", "{", "j", "=", "YSTEP", "-", "1", ";", "if", "(", "i", ">", "j", ")", "i", "=", "j", ";", "}", "if", "(", "up", ")", "{", "y", "=", "p_staff", "->", "top", "[", "i", "++", "]", ";", "while", "(", "i", "<=", "j", ")", "{", "if", "(", "y", "<", "p_staff", "->", "top", "[", "i", "]", ")", "y", "=", "p_staff", "->", "top", "[", "i", "]", ";", "i", "++", ";", "}", "}", "else", "{", "y", "=", "p_staff", "->", "bot", "[", "i", "++", "]", ";", "while", "(", "i", "<=", "j", ")", "{", "if", "(", "y", ">", "p_staff", "->", "bot", "[", "i", "]", ")", "y", "=", "p_staff", "->", "bot", "[", "i", "]", ";", "i", "++", ";", "}", "}", "return", "y", ";", "}'" ]

[ "create", "the", "deco", "elements,", "and", "treat", "the", "near", "ones" ]

[ "'static", "void", "deco_create", "(", "struct", "SYMBOL", "*", "s", ",", "struct", "decos", "*", "dc", ")", "{", "int", "k", ",", "<type", "ref=\"prev\"/>", "m", ",", "<type", "ref=\"prev\"/>", "posit", ";", "unsigned", "char", "ideco", ";", "struct", "deco_def_s", "*", "dd", ";", "struct", "deco_elt", "*", "de", ";", "/*fixme:pb", "with", "decorations", "above", "the", "staff*/", "for", "(", "k", "=", "0", ";", "k", "<", "dc", "->", "n", ";", "k", "++", ")", "{", "m", "=", "dc", "->", "tm", "[", "k", "]", ".", "m", ";", "if", "(", "(", "ideco", "=", "dc", "->", "tm", "[", "k", "]", ".", "t", ")", "==", "0", ")", "continue;", "dd", "=", "&", "deco_def_tb", "[", "ideco", "]", ";", "/*", "check", "if", "hidden", "*/", "switch", "(", "dd", "->", "func", ")", "{", "default:", "posit", "=", "0", ";", "break;", "case", "3", ":", "/*", "d_upstaff", "*/", "case", "4", ":", "posit", "=", "s", "->", "posit", ".", "orn", ";", "break;", "case", "6", ":", "/*", "d_pf", "*/", "posit", "=", "s", "->", "posit", ".", "vol", ";", "break;", "case", "7", ":", "/*", "d_cresc", "*/", "posit", "=", "s", "->", "posit", ".", "dyn", ";", "break;", "}", "if", "(", "posit", "==", "SL_HIDDEN", ")", "{", "dc", "->", "tm", "[", "k", "]", ".", "t", "=", "0", ";", "continue;", "}", "de", "=", "(", "struct", "deco_elt", "*", ")", "getarena", "(", "sizeof", "*", "de", ")", ";", "memset", "(", "de", ",", "0", ",", "sizeof", "*", "de", ")", ";", "de", "->", "prev", "=", "deco_tail", ";", "if", "(", "!", "deco_tail", ")", "deco_head", "=", "de", ";", "else", "deco_tail", "->", "next", "=", "de", ";", "deco_tail", "=", "de", ";", "de", "->", "s", "=", "s", ";", "de", "->", "t", "=", "dd", "-", "deco_def_tb", ";", "de", "->", "staff", "=", "s", "->", "staff", ";", "de", "->", "m", "=", "m", ";", "//", "if", "(s->flags", "&", "ABC_F_GRACE)", "//", "de->flags", "=", "DE_GRACE;", "if", "(", "dd", "->", "flags", "&", "DE_LDST", ")", "{", "de", "->", "flags", "|=", "DE_LDST", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "dd", "->", "flags", "&", "DE_LDEN", ")", "{", "de", "->", "flags", "|=", "DE_LDEN", ";", "de", "->", "defl", "=", "DEF_NOST", ";", "}", "if", "(", "cfmt", ".", "setdefl", "&&", "s", "->", "stem", ">=", "0", ")", "de", "->", "defl", "|=", "DEF_STEMUP", ";", "/*", "set", "the", "coordinates", "of", "the", "decoration", "*/", "if", "(", "m", ">=", "0", ")", "{", "/*", "head", "decoration", "*/", "de", "->", "x", "=", "s", "->", "x", ";", "de", "->", "y", "=", "3", "*", "(", "s", "->", "pits", "[", "m", "]", "-", "18", ")", ";", "//", "if", "(dd->func", "==", "9)", "/*", "alternate", "note", "head", "*/", "//", "s->u.note.notes[m].invisible", "=", "1;", "continue;", "}", "if", "(", "!", "(", "f_near", "&", "(", "1", "<<", "dd", "->", "func", ")", ")", ")", "/*", "if", "not", "near", "the", "note", "*/", "continue;", "func_tb", "[", "dd", "->", "func", "]", "(", "de", ")", ";", "}", "}'" ]

[ "special", "case", "for", "long", "dynamics" ]

[ "'static", "void", "d_cresc", "(", "struct", "deco_elt", "*", "de", ")", "{", "struct", "SYMBOL", "*", "s", ",", "<type", "ref=\"prev\">", "*", "s2", ";", "struct", "deco_def_s", "*", "dd", ",", "<type", "ref=\"prev\">", "*", "dd2", ";", "struct", "deco_elt", "*", "de1", ";", "int", "up", ";", "float", "x", ",", "<type", "ref=\"prev\"/>", "dx", ",", "<type", "ref=\"prev\"/>", "x2", ";", "if", "(", "de", "->", "flags", "&", "DE_LDST", ")", "return", ";", "s2", "=", "de", "->", "s", ";", "de1", "=", "de", "->", "start", ";", "/*", "start", "of", "the", "deco", "*/", "//", "if", "(de1)", "{", "s", "=", "de1", "->", "s", ";", "x", "=", "s", "->", "x", "+", "3", ";", "//", "}", "else", "{", "/*", "end", "without", "start", "*/", "//", "if", "(!first_note)", "{", "//", "dd", "=", "&deco_def_tb[de->t];", "//", "error(1,", "s2,", "\"No", "start", "of", "deco", "!%s!\",", "dd->name);", "//", "de->t", "=", "0;", "//", "return", ";", "//", "}", "//", "s", "=", "first_note;", "//", "x", "=", "s->x", "-", "s->wl", "-", "4;", "//", "}", "de", "->", "staff", "=", "s2", "->", "staff", ";", "de", "->", "flags", "&=", "~", "DE_LDEN", ";", "/*", "old", "behaviour", "*/", "de", "->", "flags", "|=", "DE_VAL", ";", "up", "=", "up_p", "(", "s2", ",", "s2", "->", "posit", ".", "dyn", ")", ";", "if", "(", "up", ")", "de", "->", "flags", "|=", "DE_UP", ";", "/*", "shift", "the", "starting", "point", "if", "any", "dynamic", "mark", "on", "the", "left", "*/", "if", "(", "de1", "&&", "de1", "->", "prev", "&&", "de1", "->", "prev", "->", "s", "==", "s", "&&", "(", "(", "de", "->", "flags", "^", "de1", "->", "prev", "->", "flags", ")", "&", "DE_UP", ")", "==", "0", ")", "{", "dd2", "=", "&", "deco_def_tb", "[", "de1", "->", "prev", "->", "t", "]", ";", "if", "(", "f_staff", "&", "(", "1", "<<", "dd2", "->", "func", ")", ")", "{", "x2", "=", "de1", "->", "prev", "->", "x", "+", "de1", "->", "prev", "->", "val", "+", "4", ";", "if", "(", "x2", ">", "x", ")", "x", "=", "x2", ";", "}", "}", "if", "(", "de", "->", "defl", "&", "DEF_NOEN", ")", "{", "/*", "if", "no", "decoration", "end", "*/", "dx", "=", "de", "->", "x", "-", "x", ";", "if", "(", "dx", "<", "20", ")", "{", "x", "=", "de", "->", "x", "-", "20", "-", "3", ";", "dx", "=", "20", ";", "}", "}", "else", "{", "x2", "=", "s2", "->", "x", ";", "if", "(", "de", "->", "next", "&&", "de", "->", "next", "->", "s", "==", "s", "&&", "(", "(", "de", "->", "flags", "^", "de", "->", "next", "->", "flags", ")", "&", "DE_UP", ")", "==", "0", ")", "{", "dd2", "=", "&", "deco_def_tb", "[", "de", "->", "next", "->", "t", "]", ";", "if", "(", "f_staff", "&", "(", "1", "<<", "dd2", "->", "func", ")", ")", "/*", "if", "dynamic", "mark", "*/", "x2", "-=", "5", ";", "}", "dx", "=", "x2", "-", "x", "-", "4", ";", "if", "(", "dx", "<", "20", ")", "{", "x", "-=", "(", "20", "-", "dx", ")", "*", "0.5", ";", "//", "if", "(!de->start)", "//", "x", "-=", "(20", "-", "dx)", "*", "0.5;", "dx", "=", "20", ";", "}", "}", "de", "->", "val", "=", "dx", ";", "de", "->", "x", "=", "x", ";", "de", "->", "y", "=", "y_get", "(", "de", "->", "staff", ",", "up", ",", "x", ",", "dx", ")", ";", "if", "(", "!", "up", ")", "{", "dd", "=", "&", "deco_def_tb", "[", "de", "->", "t", "]", ";", "de", "->", "y", "-=", "dd", "->", "h", ";", "}", "/*", "(y_set", "is", "done", "later", "in", "draw_deco_staff)", "*/", "}'" ]

[ "special", "case", "for", "long", "decoration" ]

[ "'static", "void", "d_trill", "(", "struct", "deco_elt", "*", "de", ")", "{", "struct", "SYMBOL", "*", "s", ",", "<type", "ref=\"prev\">", "*", "s2", ";", "struct", "deco_def_s", "*", "dd", ";", "int", "staff", ",", "<type", "ref=\"prev\"/>", "up", ";", "float", "x", ",", "<type", "ref=\"prev\"/>", "y", ",", "<type", "ref=\"prev\"/>", "w", ";", "if", "(", "de", "->", "flags", "&", "DE_LDST", ")", "return", ";", "s2", "=", "de", "->", "s", ";", "//", "only", "one", "ottava", "per", "staff", "if", "(", "s2", "->", "sflags", "&", "S_OTTAVA", ")", "{", "struct", "deco_elt", "*", "de2", ";", "for", "(", "de2", "=", "de", "->", "next", ";", "de2", ";", "de2", "=", "de2", "->", "next", ")", "{", "if", "(", "de2", "->", "t", "==", "de", "->", "t", "&&", "de2", "->", "s", "->", "time", "==", "s2", "->", "time", "&&", "de2", "->", "s", "->", "staff", "==", "s2", "->", "staff", ")", "{", "de2", "->", "s", "->", "sflags", "&=", "~", "S_OTTAVA", ";", "de2", "->", "t", "=", "0", ";", "}", "}", "s2", "->", "sflags", "&=", "~", "S_OTTAVA", ";", "}", "//", "if", "(de->start)", "{", "/*", "deco", "start", "*/", "s", "=", "de", "->", "start", "->", "s", ";", "x", "=", "s", "->", "x", ";", "if", "(", "s", "->", "abc_type", "==", "ABC_T_NOTE", "&&", "s", "->", "u", ".", "note", ".", "dc", ".", "n", ">", "1", ")", "x", "+=", "10", ";", "//", "}", "else", "{", "/*", "end", "without", "start", "*/", "//", "s", "=", "first_note;", "//", "if", "(!s)", "{", "//", "dd", "=", "&deco_def_tb[de->t];", "//", "error(1,", "s2,", "\"No", "start", "of", "deco", "!%s!\",", "dd->name);", "//", "de->t", "=", "0;", "//", "return", ";", "//", "}", "//", "x", "=", "s->x", "-", "s->wl", "-", "4;", "//", "}", "de", "->", "staff", "=", "staff", "=", "s2", "->", "staff", ";", "dd", "=", "&", "deco_def_tb", "[", "de", "->", "t", "]", ";", "if", "(", "dd", "->", "func", "==", "4", ")", "//", "if", "below", "up", "=", "0", ";", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "ps_func_tb", "[", "dd", "->", "ps_func", "]", ",", "\"o8va\"", ")", "==", "0", ")", "up", "=", "1", ";", "else", "up", "=", "s2", "->", "multi", ">=", "0", ";", "if", "(", "de", "->", "defl", "&", "DEF_NOEN", ")", "{", "/*", "if", "no", "decoration", "end", "*/", "w", "=", "de", "->", "x", "-", "x", ";", "if", "(", "w", "<", "20", ")", "{", "x", "=", "de", "->", "x", "-", "20", "-", "3", ";", "w", "=", "20", ";", "}", "}", "else", "{", "w", "=", "s2", "->", "x", "-", "x", "-", "6", ";", "if", "(", "s2", "->", "abc_type", "==", "ABC_T_NOTE", ")", "w", "-=", "6", ";", "if", "(", "w", "<", "20", ")", "{", "x", "-=", "(", "20", "-", "w", ")", "*", "0.5", ";", "//", "if", "(!de->start)", "//", "x", "-=", "(20", "-", "w)", "*", "0.5;", "w", "=", "20", ";", "}", "}", "y", "=", "y_get", "(", "staff", ",", "up", ",", "x", ",", "w", ")", ";", "if", "(", "up", ")", "{", "float", "stafft", ";", "stafft", "=", "staff_tb", "[", "s", "->", "staff", "]", ".", "topbar", "+", "2", ";", "if", "(", "y", "<", "stafft", ")", "y", "=", "stafft", ";", "}", "else", "{", "float", "staffb", ";", "y", "-=", "dd", "->", "h", ";", "staffb", "=", "staff_tb", "[", "s", "->", "staff", "]", ".", "botbar", "-", "2", ";", "if", "(", "y", ">", "staffb", ")", "y", "=", "staffb", ";", "}", "de", "->", "flags", "&=", "~", "DE_LDEN", ";", "de", "->", "flags", "|=", "DE_VAL", ";", "de", "->", "val", "=", "w", ";", "de", "->", "x", "=", "x", ";", "de", "->", "y", "=", "y", ";", "if", "(", "up", ")", "y", "+=", "dd", "->", "h", ";", "y_set", "(", "staff", ",", "up", ",", "x", ",", "w", ",", "y", ")", ";", "if", "(", "up", ")", "s", "->", "ymx", "=", "s2", "->", "ymx", "=", "y", ";", "else", "s", "->", "ymn", "=", "s2", "->", "ymn", "=", "y", ";", "}'" ]

[ "adjust", "the", "vertical", "offsets" ]

[ "'void", "y_set", "(", "int", "staff", ",", "int", "up", ",", "float", "x", ",", "float", "w", ",", "float", "y", ")", "{", "struct", "STAFF_S", "*", "p_staff", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "p_staff", "=", "&", "staff_tb", "[", "staff", "]", ";", "i", "=", "(", "int", ")", "(", "x", "/", "realwidth", "*", "YSTEP", ")", ";", "/*", "(may", "occur", "when", "annotation", "on", "\\'y\\'", "at", "start", "of", "an", "empty", "staff)", "*/", "if", "(", "i", "<", "0", ")", "{", "//", "fprintf(stderr,", "\"y_set", "i:%d\\\",", "i);", "i", "=", "0", ";", "}", "j", "=", "(", "int", ")", "(", "(", "x", "+", "w", ")", "/", "realwidth", "*", "YSTEP", ")", ";", "if", "(", "j", ">=", "YSTEP", ")", "{", "j", "=", "YSTEP", "-", "1", ";", "if", "(", "i", ">", "j", ")", "i", "=", "j", ";", "}", "if", "(", "up", ")", "{", "while", "(", "i", "<=", "j", ")", "{", "if", "(", "p_staff", "->", "top", "[", "i", "]", "<", "y", ")", "p_staff", "->", "top", "[", "i", "]", "=", "y", ";", "i", "++", ";", "}", "}", "else", "{", "while", "(", "i", "<=", "j", ")", "{", "if", "(", "p_staff", "->", "bot", "[", "i", "]", ">", "y", ")", "p_staff", "->", "bot", "[", "i", "]", "=", "y", ";", "i", "++", ";", "}", "}", "}'" ]

[ "3,", "4:", "above", "(or", "below)", "the", "staff" ]

[ "'static", "void", "d_upstaff", "(", "struct", "deco_elt", "*", "de", ")", "{", "struct", "SYMBOL", "*", "s", ";", "struct", "deco_def_s", "*", "dd", ";", "char", "*", "ps_name", ";", "float", "x", ",", "<type", "ref=\"prev\"/>", "yc", ",", "<type", "ref=\"prev\"/>", "stafft", ",", "<type", "ref=\"prev\"/>", "staffb", ",", "<type", "ref=\"prev\"/>", "w", ";", "int", "up", ",", "<type", "ref=\"prev\"/>", "inv", ";", "//", "don\\'t", "treat", "here", "the", "start", "of", "long", "decorations", "if", "(", "de", "->", "flags", "&", "DE_LDST", ")", "return", ";", "if", "(", "de", "->", "start", ")", "{", "d_trill", "(", "de", ")", ";", "return", ";", "}", "s", "=", "de", "->", "s", ";", "dd", "=", "&", "deco_def_tb", "[", "de", "->", "t", "]", ";", "inv", "=", "0", ";", "x", "=", "s", "->", "x", ";", "if", "(", "s", "->", "type", "==", "NOTEREST", ")", "x", "+=", "s", "->", "u", ".", "note", ".", "notes", "[", "s", "->", "stem", ">=", "0", "?", "0", ":", "s", "->", "nhd", "]", ".", "shhd", ";", "w", "=", "dd", "->", "wl", "+", "dd", "->", "wr", ";", "stafft", "=", "staff_tb", "[", "s", "->", "staff", "]", ".", "topbar", "+", "2", ";", "staffb", "=", "staff_tb", "[", "s", "->", "staff", "]", ".", "botbar", "-", "2", ";", "up", "=", "-", "1", ";", "//", "undefined", "if", "(", "dd", "->", "func", "==", "4", ")", "{", "//", "upstaff", "below", "up", "=", "0", ";", "}", "else", "{", "switch", "(", "s", "->", "posit", ".", "orn", ")", "{", "case", "SL_ABOVE", ":", "up", "=", "1", ";", "break;", "case", "SL_BELOW", ":", "up", "=", "0", ";", "break;", "}", "}", "ps_name", "=", "ps_func_tb", "[", "dd", "->", "ps_func", "]", ";", "if", "(", "strcmp", "(", "ps_name", ",", "\"accent\"", ")", "==", "0", "||", "strcmp", "(", "ps_name", ",", "\"cpu\"", ")", "==", "0", ")", "{", "if", "(", "!", "up", "||", "(", "up", "<", "0", "&&", "(", "s", "->", "multi", "<", "0", "||", "(", "s", "->", "multi", "==", "0", "&&", "s", "->", "stem", ">", "0", ")", ")", ")", ")", "{", "yc", "=", "y_get", "(", "s", "->", "staff", ",", "0", ",", "s", "->", "x", "-", "dd", "->", "wl", ",", "w", ")", ";", "if", "(", "yc", ">", "staffb", ")", "yc", "=", "staffb", ";", "yc", "-=", "dd", "->", "h", ";", "y_set", "(", "s", "->", "staff", ",", "0", ",", "s", "->", "x", ",", "0", ",", "yc", ")", ";", "inv", "=", "1", ";", "s", "->", "ymn", "=", "yc", ";", "}", "else", "{", "yc", "=", "y_get", "(", "s", "->", "staff", ",", "1", ",", "s", "->", "x", ",", "0", ")", ";", "if", "(", "yc", "<", "stafft", ")", "yc", "=", "stafft", ";", "y_set", "(", "s", "->", "staff", ",", "1", ",", "s", "->", "x", "-", "dd", "->", "wl", ",", "w", ",", "yc", "+", "dd", "->", "h", ")", ";", "s", "->", "ymx", "=", "yc", "+", "dd", "->", "h", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "ps_name", ",", "\"brth\"", ")", "==", "0", "||", "strcmp", "(", "ps_name", ",", "\"lphr\"", ")", "==", "0", "||", "strcmp", "(", "ps_name", ",", "\"mphr\"", ")", "==", "0", "||", "strcmp", "(", "ps_name", ",", "\"sphr\"", ")", "==", "0", ")", "{", "yc", "=", "stafft", "+", "1", ";", "if", "(", "ps_name", "[", "0", "]", "==", "\\'b\\'", ")", "{", "//", "if", "breath", "if", "(", "yc", "<", "s", "->", "ymx", ")", "yc", "=", "s", "->", "ymx", ";", "}", "for", "(", "s", "=", "s", "->", "ts_next", ";", "s", ";", "s", "=", "s", "->", "ts_next", ")", "if", "(", "s", "->", "shrink", "!=", "0", ")", "break;", "if", "(", "s", ")", "x", "+=", "(", "s", "->", "x", "-", "x", ")", "*", "0.4", ";", "else", "x", "+=", "(", "realwidth", "-", "x", ")", "*", "0.4", ";", "}", "else", "{", "if", "(", "strncmp", "(", "dd", "->", "name", ",", "\"invert\"", ",", "6", ")", "==", "0", ")", "inv", "=", "1", ";", "if", "(", "strcmp", "(", "dd", "->", "name", ",", "\"invertedfermata\"", ")", "!=", "0", "&&", "(", "up", ">", "0", "||", "(", "up", "<", "0", "&&", "s", "->", "multi", ">=", "0", ")", ")", ")", "{", "yc", "=", "y_get", "(", "s", "->", "staff", ",", "1", ",", "s", "->", "x", "-", "dd", "->", "wl", ",", "w", ")", ";", "if", "(", "yc", "<", "stafft", ")", "yc", "=", "stafft", ";", "y_set", "(", "s", "->", "staff", ",", "1", ",", "s", "->", "x", "-", "dd", "->", "wl", ",", "w", ",", "yc", "+", "dd", "->", "h", ")", ";", "s", "->", "ymx", "=", "yc", "+", "dd", "->", "h", ";", "}", "else", "{", "yc", "=", "y_get", "(", "s", "->", "staff", ",", "0", ",", "s", "->", "x", "-", "dd", "->", "wl", ",", "w", ")", ";", "if", "(", "yc", ">", "staffb", ")", "yc", "=", "staffb", ";", "yc", "-=", "dd", "->", "h", ";", "y_set", "(", "s", "->", "staff", ",", "0", ",", "s", "->", "x", "-", "dd", "->", "wl", ",", "w", ",", "yc", ")", ";", "if", "(", "strcmp", "(", "dd", "->", "name", ",", "\"fermata\"", ")", "==", "0", ")", "//", "||", "strcmp(dd->name,", "\"invertedfermata\")", "==", "0)", "inv", "=", "1", ";", "s", "->", "ymn", "=", "yc", ";", "}", "}", "if", "(", "inv", ")", "{", "yc", "+=", "dd", "->", "h", ";", "de", "->", "flags", "|=", "DE_INV", ";", "}", "de", "->", "x", "=", "x", ";", "de", "->", "y", "=", "yc", ";", "//", "if", "(dd->strx", "!=", "0)", "{", "//", "if", "(dd->strx", "==", "255)", "//", "de->str", "=", "dd->name;", "//", "else", "//", "de->str", "=", "set_str(de,", "str_tb[dd->strx]);", "//", "}", "}'" ]

[ "0:", "near", "the", "note", "(dot,", "tenuto)" ]

[ "'static", "void", "d_near", "(", "struct", "deco_elt", "*", "de", ")", "{", "struct", "SYMBOL", "*", "s", ";", "struct", "deco_def_s", "*", "dd", ";", "int", "y", ",", "<type", "ref=\"prev\"/>", "up", ";", "s", "=", "de", "->", "s", ";", "dd", "=", "&", "deco_def_tb", "[", "de", "->", "t", "]", ";", "if", "(", "s", "->", "multi", ")", "up", "=", "s", "->", "multi", ">", "0", ";", "else", "up", "=", "s", "->", "stem", "<", "0", ";", "if", "(", "up", ")", "y", "=", "s", "->", "ymx", ";", "else", "y", "=", "s", "->", "ymn", "-", "dd", "->", "h", ";", "if", "(", "y", ">", "-", "6", "&&", "y", "<", "24", ")", "{", "if", "(", "up", ")", "y", "+=", "3", ";", "y", "=", "(", "y", "+", "6", ")", "/", "6", "*", "6", "-", "6", ";", "/*", "between", "lines", "*/", "}", "if", "(", "up", ")", "s", "->", "ymx", "=", "y", "+", "dd", "->", "h", ";", "else", "s", "->", "ymn", "=", "y", ";", "de", "->", "y", "=", "(", "float", ")", "y", ";", "de", "->", "x", "=", "s", "->", "x", ";", "if", "(", "s", "->", "type", "==", "NOTEREST", ")", "de", "->", "x", "+=", "s", "->", "u", ".", "note", ".", "notes", "[", "s", "->", "stem", ">=", "0", "?", "0", ":", "s", "->", "nhd", "]", ".", "shhd", ";", "if", "(", "dd", "->", "name", "[", "0", "]", "==", "\\'d\\'", "/*", "if", "dot", "decoration", "*/", "&&", "s", "->", "nflags", ">=", "-", "1", ")", "{", "/*", "on", "stem", "*/", "if", "(", "up", ")", "{", "if", "(", "s", "->", "stem", ">", "0", ")", "de", "->", "x", "+=", "STEM_XOFF", ";", "}", "else", "{", "if", "(", "s", "->", "stem", "<", "0", ")", "de", "->", "x", "-=", "STEM_XOFF", ";", "}", "}", "if", "(", "dd", "->", "strx", "!=", "0", "&&", "dd", "->", "strx", "!=", "255", ")", "{", "de", "->", "x", "=", "s", "->", "x", ";", "de", "->", "y", "=", "s", "->", "y", ";", "//", "de->str", "=", "set_str(de,", "str_tb[dd->strx]);", "}", "}'" ]

[ "draw", "the", "note", "of", "the", "tempo" ]

[ "'static", "void", "draw_notempo", "(", "struct", "SYMBOL", "*", "s", ",", "int", "len", ",", "float", "sc", ")", "{", "int", "head", ",", "<type", "ref=\"prev\"/>", "dots", ",", "<type", "ref=\"prev\"/>", "flags", ";", "float", "dx", ";", "a2b", "(", "\"gsave", "%.2f", "dup", "scale", "8", "3", "RM", "currentpoint", "\"", ",", "sc", ")", ";", "identify_note", "(", "s", ",", "len", ",", "&", "head", ",", "&", "dots", ",", "&", "flags", ")", ";", "switch", "(", "head", ")", "{", "case", "H_OVAL", ":", "a2b", "(", "\"HD\"", ")", ";", "break;", "case", "H_EMPTY", ":", "a2b", "(", "\"Hd\"", ")", ";", "break;", "default:", "a2b", "(", "\"hd\"", ")", ";", "break;", "}", "dx", "=", "4", ";", "if", "(", "dots", ")", "{", "float", "dotx", ";", "dotx", "=", "8", ";", "if", "(", "flags", ">", "0", ")", "dotx", "+=", "4", ";", "switch", "(", "head", ")", "{", "case", "H_SQUARE", ":", "case", "H_OVAL", ":", "dotx", "+=", "2", ";", "break;", "case", "H_EMPTY", ":", "dotx", "+=", "1", ";", "break;", "}", "while", "(", "--", "dots", ">=", "0", ")", "{", "a2b", "(", "\"", "%.1f", "0", "dt\"", ",", "dotx", ")", ";", "dx", "=", "dotx", ";", "dotx", "+=", "3.5", ";", "}", "}", "if", "(", "len", "<", "SEMIBREVE", ")", "{", "if", "(", "flags", "<=", "0", ")", "{", "a2b", "(", "\"", "%d", "su\"", ",", "STEM", ")", ";", "}", "else", "{", "a2b", "(", "\"", "%d", "%d", "sfu\"", ",", "flags", ",", "STEM", ")", ";", "if", "(", "dx", "<", "6", ")", "dx", "=", "6", ";", "}", "}", "a2b", "(", "\"", "grestore", "%.1f", "0", "RM\\\"", ",", "(", "dx", "+", "15", ")", "*", "sc", ")", ";", "}'" ]

[ "1:", "special", "case", "for", "slide" ]

[ "'static", "void", "d_slide", "(", "struct", "deco_elt", "*", "de", ")", "{", "struct", "SYMBOL", "*", "s", ";", "int", "m", ",", "<type", "ref=\"prev\"/>", "yc", ";", "float", "xc", ",", "<type", "ref=\"prev\"/>", "dx", ";", "s", "=", "de", "->", "s", ";", "yc", "=", "s", "->", "pits", "[", "0", "]", ";", "xc", "=", "5", ";", "if", "(", "s", "->", "type", "==", "NOTEREST", ")", "{", "for", "(", "m", "=", "0", ";", "m", "<=", "s", "->", "nhd", ";", "m", "++", ")", "{", "if", "(", "s", "->", "u", ".", "note", ".", "notes", "[", "m", "]", ".", "acc", ")", "{", "dx", "=", "4", "+", "s", "->", "u", ".", "note", ".", "notes", "[", "m", "]", ".", "shac", ";", "}", "else", "{", "dx", "=", "5", "-", "s", "->", "u", ".", "note", ".", "notes", "[", "m", "]", ".", "shhd", ";", "switch", "(", "s", "->", "head", ")", "{", "case", "H_SQUARE", ":", "case", "H_OVAL", ":", "dx", "+=", "2.5", ";", "break;", "}", "}", "if", "(", "s", "->", "pits", "[", "m", "]", "<=", "yc", "+", "3", "&&", "dx", ">", "xc", ")", "xc", "=", "dx", ";", "}", "}", "de", "->", "x", "=", "s", "->", "x", "-", "xc", ";", "de", "->", "y", "=", "(", "float", ")", "(", "3", "*", "(", "yc", "-", "18", ")", ")", ";", "}'" ]

[ "Uses", "an", "onchip", "algorithm", "for", "an", "ARM", "device", "to", "read", "from", "a", "NAND", "device", "and", "store", "the", "data", "into", "the", "host", "machine's", "memory" ]

[ "'int", "arm_nandread", "(", "struct", "arm_nand_data", "*", "nand", ",", "uint8_t", "*", "data", ",", "uint32_t", "size", ")", "{", "struct", "target", "*", "target", "=", "nand", "->", "target", ";", "struct", "arm_algorithm", "armv4_5_algo", ";", "struct", "armv7m_algorithm", "armv7m_algo", ";", "void", "*", "arm_algo", ";", "struct", "arm", "*", "arm", "=", "target", "->", "arch_info", ";", "struct", "reg_param", "reg_params", "[", "3", "]", ";", "uint32_t", "target_buf", ";", "uint32_t", "exit_var", "=", "0", ";", "int", "retval", ";", "/*", "Inputs:", "*", "r0", "buffer", "address", "*", "r1", "NAND", "data", "address", "(byte", "wide)", "*", "r2", "buffer", "length", "*/", "static", "const", "uint32_t", "code_armv4_5", "[]", "=", "{", "0xe5d13000", ",", "/*", "s:", "ldrb", "r3,", "[r1]", "*/", "0xe4c03001", ",", "/*", "strb", "r3,", "[r0],", "#1", "*/", "0xe2522001", ",", "/*", "subs", "r2,", "r2,", "#1", "*/", "0x1afffffb", ",", "/*", "bne", "s", "*/", "/*", "exit:", "ARMv4", "needs", "hardware", "breakpoint", "*/", "0xe1200070", ",", "/*", "e:", "bkpt", "#0", "*/", "}", ";", "/*", "Inputs:", "*", "r0", "buffer", "address", "*", "r1", "NAND", "data", "address", "(byte", "wide)", "*", "r2", "buffer", "length", "*", "*", "see", "contrib/loaders/flash/armv7m_io.s", "for", "src", "*/", "static", "const", "uint32_t", "code_armv7m", "[]", "=", "{", "0xf800780b", ",", "0x3a013b01", ",", "0xaffaf47f", ",", "0xbf00be00", ",", "}", ";", "int", "target_code_size", "=", "0", ";", "const", "uint32_t", "*", "target_code_src", "=", "NULL", ";", "/*", "set", "up", "algorithm", "*/", "if", "(", "is_armv7m", "(", "target_to_armv7m", "(", "target", ")", ")", ")", "{", "/*", "armv7m", "target", "*/", "armv7m_algo", ".", "common_magic", "=", "ARMV7M_COMMON_MAGIC", ";", "armv7m_algo", ".", "core_mode", "=", "ARM_MODE_THREAD", ";", "arm_algo", "=", "&", "armv7m_algo", ";", "target_code_size", "=", "sizeof", "(", "code_armv7m", ")", ";", "target_code_src", "=", "code_armv7m", ";", "}", "else", "{", "armv4_5_algo", ".", "common_magic", "=", "ARM_COMMON_MAGIC", ";", "armv4_5_algo", ".", "core_mode", "=", "ARM_MODE_SVC", ";", "armv4_5_algo", ".", "core_state", "=", "ARM_STATE_ARM", ";", "arm_algo", "=", "&", "armv4_5_algo", ";", "target_code_size", "=", "sizeof", "(", "code_armv4_5", ")", ";", "target_code_src", "=", "code_armv4_5", ";", "}", "/*", "create", "the", "copy", "area", "if", "not", "yet", "available", "*/", "if", "(", "nand", "->", "op", "!=", "ARM_NAND_READ", "||", "!", "nand", "->", "copy_area", ")", "{", "retval", "=", "arm_code_to_working_area", "(", "target", ",", "target_code_src", ",", "target_code_size", ",", "nand", "->", "chunk_size", ",", "&", "nand", "->", "copy_area", ")", ";", "if", "(", "retval", "!=", "ERROR_OK", ")", "return", "retval", ";", "}", "nand", "->", "op", "=", "ARM_NAND_READ", ";", "target_buf", "=", "nand", "->", "copy_area", "->", "address", "+", "target_code_size", ";", "/*", "set", "up", "parameters", "*/", "init_reg_param", "(", "&", "reg_params", "[", "0", "]", ",", "\"r0\"", ",", "32", ",", "PARAM_IN", ")", ";", "init_reg_param", "(", "&", "reg_params", "[", "1", "]", ",", "\"r1\"", ",", "32", ",", "PARAM_IN", ")", ";", "init_reg_param", "(", "&", "reg_params", "[", "2", "]", ",", "\"r2\"", ",", "32", ",", "PARAM_IN", ")", ";", "buf_set_u32", "(", "reg_params", "[", "0", "]", ".", "value", ",", "0", ",", "32", ",", "target_buf", ")", ";", "buf_set_u32", "(", "reg_params", "[", "1", "]", ".", "value", ",", "0", ",", "32", ",", "nand", "->", "data", ")", ";", "buf_set_u32", "(", "reg_params", "[", "2", "]", ".", "value", ",", "0", ",", "32", ",", "size", ")", ";", "/*", "armv4", "must", "exit", "using", "a", "hardware", "breakpoint", "*/", "if", "(", "arm", "->", "is_armv4", ")", "exit_var", "=", "nand", "->", "copy_area", "->", "address", "+", "target_code_size", "-", "4", ";", "/*", "use", "alg", "to", "write", "data", "from", "NAND", "chip", "to", "work", "area", "*/", "retval", "=", "target_run_algorithm", "(", "target", ",", "0", ",", "NULL", ",", "3", ",", "reg_params", ",", "nand", "->", "copy_area", "->", "address", ",", "exit_var", ",", "1000", ",", "arm_algo", ")", ";", "if", "(", "retval", "!=", "ERROR_OK", ")", "LOG_ERROR", "(", "\"error", "executing", "hosted", "NAND", "read\"", ")", ";", "destroy_reg_param", "(", "&", "reg_params", "[", "0", "]", ")", ";", "destroy_reg_param", "(", "&", "reg_params", "[", "1", "]", ")", ";", "destroy_reg_param", "(", "&", "reg_params", "[", "2", "]", ")", ";", "/*", "read", "from", "work", "area", "to", "the", "host\\'s", "memory", "*/", "retval", "=", "target_read_buffer", "(", "target", ",", "target_buf", ",", "size", ",", "data", ")", ";", "return", "retval", ";", "}'" ]

[ "ARMspecific", "bulk", "write", "from", "buffer", "to", "address", "of", "8bit", "wide", "NAND" ]

[ "'int", "arm_nandwrite", "(", "struct", "arm_nand_data", "*", "nand", ",", "uint8_t", "*", "data", ",", "int", "size", ")", "{", "struct", "target", "*", "target", "=", "nand", "->", "target", ";", "struct", "arm_algorithm", "armv4_5_algo", ";", "struct", "armv7m_algorithm", "armv7m_algo", ";", "void", "*", "arm_algo", ";", "struct", "arm", "*", "arm", "=", "target", "->", "arch_info", ";", "struct", "reg_param", "reg_params", "[", "3", "]", ";", "uint32_t", "target_buf", ";", "uint32_t", "exit_var", "=", "0", ";", "int", "retval", ";", "/*", "Inputs:", "*", "r0", "NAND", "data", "address", "(byte", "wide)", "*", "r1", "buffer", "address", "*", "r2", "buffer", "length", "*/", "static", "const", "uint32_t", "code_armv4_5", "[]", "=", "{", "0xe4d13001", ",", "/*", "s:", "ldrb", "r3,", "[r1],", "#1", "*/", "0xe5c03000", ",", "/*", "strb", "r3,", "[r0]", "*/", "0xe2522001", ",", "/*", "subs", "r2,", "r2,", "#1", "*/", "0x1afffffb", ",", "/*", "bne", "s", "*/", "/*", "exit:", "ARMv4", "needs", "hardware", "breakpoint", "*/", "0xe1200070", ",", "/*", "e:", "bkpt", "#0", "*/", "}", ";", "/*", "Inputs:", "*", "r0", "NAND", "data", "address", "(byte", "wide)", "*", "r1", "buffer", "address", "*", "r2", "buffer", "length", "*", "*", "see", "contrib/loaders/flash/armv7m_io.s", "for", "src", "*/", "static", "const", "uint32_t", "code_armv7m", "[]", "=", "{", "0x3b01f811", ",", "0x3a017003", ",", "0xaffaf47f", ",", "0xbf00be00", ",", "}", ";", "int", "target_code_size", "=", "0", ";", "const", "uint32_t", "*", "target_code_src", "=", "NULL", ";", "/*", "set", "up", "algorithm", "*/", "if", "(", "is_armv7m", "(", "target_to_armv7m", "(", "target", ")", ")", ")", "{", "/*", "armv7m", "target", "*/", "armv7m_algo", ".", "common_magic", "=", "ARMV7M_COMMON_MAGIC", ";", "armv7m_algo", ".", "core_mode", "=", "ARM_MODE_THREAD", ";", "arm_algo", "=", "&", "armv7m_algo", ";", "target_code_size", "=", "sizeof", "(", "code_armv7m", ")", ";", "target_code_src", "=", "code_armv7m", ";", "}", "else", "{", "armv4_5_algo", ".", "common_magic", "=", "ARM_COMMON_MAGIC", ";", "armv4_5_algo", ".", "core_mode", "=", "ARM_MODE_SVC", ";", "armv4_5_algo", ".", "core_state", "=", "ARM_STATE_ARM", ";", "arm_algo", "=", "&", "armv4_5_algo", ";", "target_code_size", "=", "sizeof", "(", "code_armv4_5", ")", ";", "target_code_src", "=", "code_armv4_5", ";", "}", "if", "(", "nand", "->", "op", "!=", "ARM_NAND_WRITE", "||", "!", "nand", "->", "copy_area", ")", "{", "retval", "=", "arm_code_to_working_area", "(", "target", ",", "target_code_src", ",", "target_code_size", ",", "nand", "->", "chunk_size", ",", "&", "nand", "->", "copy_area", ")", ";", "if", "(", "retval", "!=", "ERROR_OK", ")", "return", "retval", ";", "}", "nand", "->", "op", "=", "ARM_NAND_WRITE", ";", "/*", "copy", "data", "to", "work", "area", "*/", "target_buf", "=", "nand", "->", "copy_area", "->", "address", "+", "target_code_size", ";", "retval", "=", "target_write_buffer", "(", "target", ",", "target_buf", ",", "size", ",", "data", ")", ";", "if", "(", "retval", "!=", "ERROR_OK", ")", "return", "retval", ";", "/*", "set", "up", "parameters", "*/", "init_reg_param", "(", "&", "reg_params", "[", "0", "]", ",", "\"r0\"", ",", "32", ",", "PARAM_IN", ")", ";", "init_reg_param", "(", "&", "reg_params", "[", "1", "]", ",", "\"r1\"", ",", "32", ",", "PARAM_IN", ")", ";", "init_reg_param", "(", "&", "reg_params", "[", "2", "]", ",", "\"r2\"", ",", "32", ",", "PARAM_IN", ")", ";", "buf_set_u32", "(", "reg_params", "[", "0", "]", ".", "value", ",", "0", ",", "32", ",", "nand", "->", "data", ")", ";", "buf_set_u32", "(", "reg_params", "[", "1", "]", ".", "value", ",", "0", ",", "32", ",", "target_buf", ")", ";", "buf_set_u32", "(", "reg_params", "[", "2", "]", ".", "value", ",", "0", ",", "32", ",", "size", ")", ";", "/*", "armv4", "must", "exit", "using", "a", "hardware", "breakpoint", "*/", "if", "(", "arm", "->", "is_armv4", ")", "exit_var", "=", "nand", "->", "copy_area", "->", "address", "+", "target_code_size", "-", "4", ";", "/*", "use", "alg", "to", "write", "data", "from", "work", "area", "to", "NAND", "chip", "*/", "retval", "=", "target_run_algorithm", "(", "target", ",", "0", ",", "NULL", ",", "3", ",", "reg_params", ",", "nand", "->", "copy_area", "->", "address", ",", "exit_var", ",", "1000", ",", "arm_algo", ")", ";", "if", "(", "retval", "!=", "ERROR_OK", ")", "LOG_ERROR", "(", "\"error", "executing", "hosted", "NAND", "write\"", ")", ";", "destroy_reg_param", "(", "&", "reg_params", "[", "0", "]", ")", ";", "destroy_reg_param", "(", "&", "reg_params", "[", "1", "]", ")", ";", "destroy_reg_param", "(", "&", "reg_params", "[", "2", "]", ")", ";", "return", "retval", ";", "}'" ]

[ "Copies", "code", "to", "a", "working", "area" ]

[ "'static", "int", "arm_code_to_working_area", "(", "struct", "target", "*", "target", ",", "const", "uint32_t", "*", "code", ",", "unsigned", "code_size", ",", "unsigned", "additional", ",", "struct", "working_area", "*", "*", "area", ")", "{", "uint8_t", "code_buf", "[", "code_size", "]", ";", "int", "retval", ";", "unsigned", "size", "=", "code_size", "+", "additional", ";", "/*", "REVISIT", "this", "assumes", "size", "doesn\\'t", "ever", "change.", "*", "That\\'s", "usually", "correct;", "but", "there", "are", "boards", "with", "*", "both", "large", "and", "small", "page", "chips,", "where", "it", "won\\'t", "be...", "*/", "/*", "make", "sure", "we", "have", "a", "working", "area", "*/", "if", "(", "NULL", "==", "*", "area", ")", "{", "retval", "=", "target_alloc_working_area", "(", "target", ",", "size", ",", "area", ")", ";", "if", "(", "retval", "!=", "ERROR_OK", ")", "{", "LOG_DEBUG", "(", "\"%s:", "no", "%d", "byte", "buffer\"", ",", "__func__", ",", "(", "int", ")", "size", ")", ";", "return", "ERROR_NAND_NO_BUFFER", ";", "}", "}", "/*", "buffer", "code", "in", "target", "endianness", "*/", "target_buffer_set_u32_array", "(", "target", ",", "code_buf", ",", "code_size", "/", "4", ",", "code", ")", ";", "/*", "copy", "code", "to", "work", "area", "*/", "retval", "=", "target_write_memory", "(", "target", ",", "(", "*", "area", ")", "->", "address", ",", "4", ",", "code_size", "/", "4", ",", "code_buf", ")", ";", "return", "retval", ";", "}'" ]

[ "Create", "subnet", "management", "agent", "and", "interface" ]

[ "'int", "ib_create_sma", "(", "struct", "ib_device", "*", "ibdev", ",", "struct", "ib_mad_interface", "*", "mi", ")", "{", "/*", "Nothing", "to", "do", "*/", "DBGC", "(", "ibdev", ",", "\"IBDEV", "%s", "SMA", "using", "SMI", "%p\\\"", ",", "ibdev", "->", "name", ",", "mi", ")", ";", "return", "0", ";", "}'" ]

[ "Destroy", "subnet", "management", "agent", "and", "interface" ]

[ "'void", "ib_destroy_sma", "(", "struct", "ib_device", "*", "ibdev", "__unused", ",", "struct", "ib_mad_interface", "*", "mi", "__unused", ")", "{", "/*", "Nothing", "to", "do", "*/", "}'" ]

[ "@file", "Infiniband", "Subnet", "Management", "Agent", "Node", "information" ]

[ "'static", "void", "ib_sma_node_info", "(", "struct", "ib_device", "*", "ibdev", ",", "struct", "ib_mad_interface", "*", "mi", ",", "union", "ib_mad", "*", "mad", ",", "struct", "ib_address_vector", "*", "av", ")", "{", "struct", "ib_node_info", "*", "node_info", "=", "&", "mad", "->", "smp", ".", "smp_data", ".", "node_info", ";", "int", "rc", ";", "/*", "Fill", "in", "information", "*/", "memset", "(", "node_info", ",", "0", ",", "sizeof", "(", "*", "node_info", ")", ")", ";", "node_info", "->", "base_version", "=", "IB_MGMT_BASE_VERSION", ";", "node_info", "->", "class_version", "=", "IB_SMP_CLASS_VERSION", ";", "node_info", "->", "node_type", "=", "IB_NODE_TYPE_HCA", ";", "node_info", "->", "num_ports", "=", "ib_count_ports", "(", "ibdev", ")", ";", "memcpy", "(", "&", "node_info", "->", "sys_guid", ",", "&", "ibdev", "->", "node_guid", ",", "sizeof", "(", "node_info", "->", "sys_guid", ")", ")", ";", "memcpy", "(", "&", "node_info", "->", "node_guid", ",", "&", "ibdev", "->", "node_guid", ",", "sizeof", "(", "node_info", "->", "node_guid", ")", ")", ";", "memcpy", "(", "&", "node_info", "->", "port_guid", ",", "&", "ibdev", "->", "gid", ".", "s", ".", "guid", ",", "sizeof", "(", "node_info", "->", "port_guid", ")", ")", ";", "node_info", "->", "partition_cap", "=", "htons", "(", "1", ")", ";", "node_info", "->", "local_port_num", "=", "ibdev", "->", "port", ";", "/*", "Send", "GetResponse", "*/", "mad", "->", "hdr", ".", "method", "=", "IB_MGMT_METHOD_GET_RESP", ";", "if", "(", "(", "rc", "=", "ib_mi_send", "(", "ibdev", ",", "mi", ",", "mad", ",", "av", ")", ")", "!=", "0", ")", "{", "DBGC", "(", "mi", ",", "\"SMA", "%p", "could", "not", "send", "NodeInfo", "GetResponse:", "%s\\\"", ",", "mi", ",", "strerror", "(", "rc", ")", ")", ";", "return", ";", "}", "}'" ]

[ "Multikey", "introsort", "for", "medium", "size", "groups" ]

[ "'static", "void", "ss_mintrosort", "(", "const", "sauchar_t", "*", "T", ",", "const", "saidx_t", "*", "PA", ",", "saidx_t", "*", "first", ",", "saidx_t", "*", "last", ",", "saidx_t", "depth", ")", "{", "#", "define", "STACK_SIZE", "SS_MISORT_STACKSIZE", "struct", "{", "saidx_t", "*", "a", ",", "<type", "ref=\"prev\">", "*", "b", ",", "<type", "ref=\"prev\"/>", "c", ";", "saint_t", "d", ";", "}", "stack", "[", "STACK_SIZE", "]", ";", "const", "sauchar_t", "*", "Td", ";", "saidx_t", "*", "a", ",", "<type", "ref=\"prev\">", "*", "b", ",", "<type", "ref=\"prev\">", "*", "c", ",", "<type", "ref=\"prev\">", "*", "d", ",", "<type", "ref=\"prev\">", "*", "e", ",", "<type", "ref=\"prev\">", "*", "f", ";", "saidx_t", "s", ",", "<type", "ref=\"prev\"/>", "t", ";", "saint_t", "ssize", ";", "saint_t", "limit", ";", "saint_t", "v", ",", "<type", "ref=\"prev\"/>", "x", "=", "0", ";", "for", "(", "ssize", "=", "0", ",", "limit", "=", "ss_ilg", "(", "last", "-", "first", ")", ";", ";", ")", "{", "if", "(", "(", "last", "-", "first", ")", "<=", "SS_INSERTIONSORT_THRESHOLD", ")", "{", "#", "if", "1", "<", "SS_INSERTIONSORT_THRESHOLD", "if", "(", "1", "<", "(", "last", "-", "first", ")", ")", "{", "ss_insertionsort", "(", "T", ",", "PA", ",", "first", ",", "last", ",", "depth", ")", ";", "}", "#", "endif", "STACK_POP", "(", "first", ",", "last", ",", "depth", ",", "limit", ")", ";", "continue;", "}", "Td", "=", "T", "+", "depth", ";", "if", "(", "limit", "--", "==", "0", ")", "{", "ss_heapsort", "(", "Td", ",", "PA", ",", "first", ",", "last", "-", "first", ")", ";", "}", "if", "(", "limit", "<", "0", ")", "{", "for", "(", "a", "=", "first", "+", "1", ",", "v", "=", "Td", "[", "PA", "[", "*", "first", "]", "]", ";", "a", "<", "last", ";", "++", "a", ")", "{", "if", "(", "(", "x", "=", "Td", "[", "PA", "[", "*", "a", "]", "]", ")", "!=", "v", ")", "{", "if", "(", "1", "<", "(", "a", "-", "first", ")", ")", "{", "break;", "}", "v", "=", "x", ";", "first", "=", "a", ";", "}", "}", "if", "(", "Td", "[", "PA", "[", "*", "first", "]", "-", "1", "]", "<", "v", ")", "{", "first", "=", "ss_partition", "(", "PA", ",", "first", ",", "a", ",", "depth", ")", ";", "}", "if", "(", "(", "a", "-", "first", ")", "<=", "(", "last", "-", "a", ")", ")", "{", "if", "(", "1", "<", "(", "a", "-", "first", ")", ")", "{", "STACK_PUSH", "(", "a", ",", "last", ",", "depth", ",", "-", "1", ")", ";", "last", "=", "a", ",", "depth", "+=", "1", ",", "limit", "=", "ss_ilg", "(", "a", "-", "first", ")", ";", "}", "else", "{", "first", "=", "a", ",", "limit", "=", "-", "1", ";", "}", "}", "else", "{", "if", "(", "1", "<", "(", "last", "-", "a", ")", ")", "{", "STACK_PUSH", "(", "first", ",", "a", ",", "depth", "+", "1", ",", "ss_ilg", "(", "a", "-", "first", ")", ")", ";", "first", "=", "a", ",", "limit", "=", "-", "1", ";", "}", "else", "{", "last", "=", "a", ",", "depth", "+=", "1", ",", "limit", "=", "ss_ilg", "(", "a", "-", "first", ")", ";", "}", "}", "continue;", "}", "/*", "choose", "pivot", "*/", "a", "=", "ss_pivot", "(", "Td", ",", "PA", ",", "first", ",", "last", ")", ";", "v", "=", "Td", "[", "PA", "[", "*", "a", "]", "]", ";", "SWAP", "(", "*", "first", ",", "*", "a", ")", ";", "/*", "partition", "*/", "for", "(", "b", "=", "first", ";", "(", "++", "b", "<", "last", ")", "&&", "(", "(", "x", "=", "Td", "[", "PA", "[", "*", "b", "]", "]", ")", "==", "v", ")", ";", ")", "{", "}", "if", "(", "(", "(", "a", "=", "b", ")", "<", "last", ")", "&&", "(", "x", "<", "v", ")", ")", "{", "for", "(", ";", "(", "++", "b", "<", "last", ")", "&&", "(", "(", "x", "=", "Td", "[", "PA", "[", "*", "b", "]", "]", ")", "<=", "v", ")", ";", ")", "{", "if", "(", "x", "==", "v", ")", "{", "SWAP", "(", "*", "b", ",", "*", "a", ")", ";", "++", "a", ";", "}", "}", "}", "for", "(", "c", "=", "last", ";", "(", "b", "<", "--", "c", ")", "&&", "(", "(", "x", "=", "Td", "[", "PA", "[", "*", "c", "]", "]", ")", "==", "v", ")", ";", ")", "{", "}", "if", "(", "(", "b", "<", "(", "d", "=", "c", ")", ")", "&&", "(", "x", ">", "v", ")", ")", "{", "for", "(", ";", "(", "b", "<", "--", "c", ")", "&&", "(", "(", "x", "=", "Td", "[", "PA", "[", "*", "c", "]", "]", ")", ">=", "v", ")", ";", ")", "{", "if", "(", "x", "==", "v", ")", "{", "SWAP", "(", "*", "c", ",", "*", "d", ")", ";", "--", "d", ";", "}", "}", "}", "for", "(", ";", "b", "<", "c", ";", ")", "{", "SWAP", "(", "*", "b", ",", "*", "c", ")", ";", "for", "(", ";", "(", "++", "b", "<", "c", ")", "&&", "(", "(", "x", "=", "Td", "[", "PA", "[", "*", "b", "]", "]", ")", "<=", "v", ")", ";", ")", "{", "if", "(", "x", "==", "v", ")", "{", "SWAP", "(", "*", "b", ",", "*", "a", ")", ";", "++", "a", ";", "}", "}", "for", "(", ";", "(", "b", "<", "--", "c", ")", "&&", "(", "(", "x", "=", "Td", "[", "PA", "[", "*", "c", "]", "]", ")", ">=", "v", ")", ";", ")", "{", "if", "(", "x", "==", "v", ")", "{", "SWAP", "(", "*", "c", ",", "*", "d", ")", ";", "--", "d", ";", "}", "}", "}", "if", "(", "a", "<=", "d", ")", "{", "c", "=", "b", "-", "1", ";", "if", "(", "(", "s", "=", "a", "-", "first", ")", ">", "(", "t", "=", "b", "-", "a", ")", ")", "{", "s", "=", "t", ";", "}", "for", "(", "e", "=", "first", ",", "f", "=", "b", "-", "s", ";", "0", "<", "s", ";", "--", "s", ",", "++", "e", ",", "++", "f", ")", "{", "SWAP", "(", "*", "e", ",", "*", "f", ")", ";", "}", "if", "(", "(", "s", "=", "d", "-", "c", ")", ">", "(", "t", "=", "last", "-", "d", "-", "1", ")", ")", "{", "s", "=", "t", ";", "}", "for", "(", "e", "=", "b", ",", "f", "=", "last", "-", "s", ";", "0", "<", "s", ";", "--", "s", ",", "++", "e", ",", "++", "f", ")", "{", "SWAP", "(", "*", "e", ",", "*", "f", ")", ";", "}", "a", "=", "first", "+", "(", "b", "-", "a", ")", ",", "c", "=", "last", "-", "(", "d", "-", "c", ")", ";", "b", "=", "(", "v", "<=", "Td", "[", "PA", "[", "*", "a", "]", "-", "1", "]", ")", "?", "a", ":", "ss_partition", "(", "PA", ",", "a", ",", "c", ",", "depth", ")", ";", "if", "(", "(", "a", "-", "first", ")", "<=", "(", "last", "-", "c", ")", ")", "{", "if", "(", "(", "last", "-", "c", ")", "<=", "(", "c", "-", "b", ")", ")", "{", "STACK_PUSH", "(", "b", ",", "c", ",", "depth", "+", "1", ",", "ss_ilg", "(", "c", "-", "b", ")", ")", ";", "STACK_PUSH", "(", "c", ",", "last", ",", "depth", ",", "limit", ")", ";", "last", "=", "a", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "a", "-", "first", ")", "<=", "(", "c", "-", "b", ")", ")", "{", "STACK_PUSH", "(", "c", ",", "last", ",", "depth", ",", "limit", ")", ";", "STACK_PUSH", "(", "b", ",", "c", ",", "depth", "+", "1", ",", "ss_ilg", "(", "c", "-", "b", ")", ")", ";", "last", "=", "a", ";", "}", "else", "{", "STACK_PUSH", "(", "c", ",", "last", ",", "depth", ",", "limit", ")", ";", "STACK_PUSH", "(", "first", ",", "a", ",", "depth", ",", "limit", ")", ";", "first", "=", "b", ",", "last", "=", "c", ",", "depth", "+=", "1", ",", "limit", "=", "ss_ilg", "(", "c", "-", "b", ")", ";", "}", "}", "else", "{", "if", "(", "(", "a", "-", "first", ")", "<=", "(", "c", "-", "b", ")", ")", "{", "STACK_PUSH", "(", "b", ",", "c", ",", "depth", "+", "1", ",", "ss_ilg", "(", "c", "-", "b", ")", ")", ";", "STACK_PUSH", "(", "first", ",", "a", ",", "depth", ",", "limit", ")", ";", "first", "=", "c", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "last", "-", "c", ")", "<=", "(", "c", "-", "b", ")", ")", "{", "STACK_PUSH", "(", "first", ",", "a", ",", "depth", ",", "limit", ")", ";", "STACK_PUSH", "(", "b", ",", "c", ",", "depth", "+", "1", ",", "ss_ilg", "(", "c", "-", "b", ")", ")", ";", "first", "=", "c", ";", "}", "else", "{", "STACK_PUSH", "(", "first", ",", "a", ",", "depth", ",", "limit", ")", ";", "STACK_PUSH", "(", "c", ",", "last", ",", "depth", ",", "limit", ")", ";", "first", "=", "b", ",", "last", "=", "c", ",", "depth", "+=", "1", ",", "limit", "=", "ss_ilg", "(", "c", "-", "b", ")", ";", "}", "}", "}", "else", "{", "limit", "+=", "1", ";", "if", "(", "Td", "[", "PA", "[", "*", "first", "]", "-", "1", "]", "<", "v", ")", "{", "first", "=", "ss_partition", "(", "PA", ",", "first", ",", "last", ",", "depth", ")", ";", "limit", "=", "ss_ilg", "(", "last", "-", "first", ")", ";", "}", "depth", "+=", "1", ";", "}", "}", "#", "undef", "STACK_SIZE", "}'" ]

[ "Produce", "content", "octets", "from", "a", "structure" ]

[ "'int", "asn1_ex_i2c", "(", "ASN1_VALUE", "*", "*", "pval", ",", "unsigned", "char", "*", "cout", ",", "int", "*", "putype", ",", "const", "ASN1_ITEM", "*", "it", ")", "{", "ASN1_BOOLEAN", "*", "tbool", "=", "NULL", ";", "ASN1_STRING", "*", "strtmp", ";", "ASN1_OBJECT", "*", "otmp", ";", "int", "utype", ";", "const", "unsigned", "char", "*", "cont", ";", "unsigned", "char", "c", ";", "int", "len", ";", "const", "ASN1_PRIMITIVE_FUNCS", "*", "pf", ";", "pf", "=", "it", "->", "funcs", ";", "if", "(", "pf", "&&", "pf", "->", "prim_i2c", ")", "return", "pf", "->", "prim_i2c", "(", "pval", ",", "cout", ",", "putype", ",", "it", ")", ";", "/*", "Should", "type", "be", "omitted?", "*/", "if", "(", "(", "it", "->", "itype", "!=", "ASN1_ITYPE_PRIMITIVE", ")", "||", "(", "it", "->", "utype", "!=", "V_ASN1_BOOLEAN", ")", ")", "{", "if", "(", "!", "*", "pval", ")", "return", "-", "1", ";", "}", "if", "(", "it", "->", "itype", "==", "ASN1_ITYPE_MSTRING", ")", "{", "/*", "If", "MSTRING", "type", "set", "the", "underlying", "type", "*/", "strtmp", "=", "(", "ASN1_STRING", "*", ")", "*", "pval", ";", "utype", "=", "strtmp", "->", "type", ";", "*", "putype", "=", "utype", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "it", "->", "utype", "==", "V_ASN1_ANY", ")", "{", "/*", "If", "ANY", "set", "type", "and", "pointer", "to", "value", "*/", "ASN1_TYPE", "*", "typ", ";", "typ", "=", "(", "ASN1_TYPE", "*", ")", "*", "pval", ";", "utype", "=", "typ", "->", "type", ";", "*", "putype", "=", "utype", ";", "pval", "=", "&", "typ", "->", "value", ".", "asn1_value", ";", "}", "else", "utype", "=", "*", "putype", ";", "switch", "(", "utype", ")", "{", "case", "V_ASN1_OBJECT", ":", "otmp", "=", "(", "ASN1_OBJECT", "*", ")", "*", "pval", ";", "cont", "=", "otmp", "->", "data", ";", "len", "=", "otmp", "->", "length", ";", "break;", "case", "V_ASN1_NULL", ":", "cont", "=", "NULL", ";", "len", "=", "0", ";", "break;", "case", "V_ASN1_BOOLEAN", ":", "tbool", "=", "(", "ASN1_BOOLEAN", "*", ")", "pval", ";", "if", "(", "*", "tbool", "==", "-", "1", ")", "return", "-", "1", ";", "if", "(", "it", "->", "utype", "!=", "V_ASN1_ANY", ")", "{", "/*", "Default", "handling", "if", "value", "==", "size", "field", "then", "omit", "*/", "if", "(", "*", "tbool", "&&", "(", "it", "->", "size", ">", "0", ")", ")", "return", "-", "1", ";", "if", "(", "!", "*", "tbool", "&&", "!", "it", "->", "size", ")", "return", "-", "1", ";", "}", "c", "=", "(", "unsigned", "char", ")", "*", "tbool", ";", "cont", "=", "&", "c", ";", "len", "=", "1", ";", "break;", "case", "V_ASN1_BIT_STRING", ":", "return", "i2c_ASN1_BIT_STRING", "(", "(", "ASN1_BIT_STRING", "*", ")", "*", "pval", ",", "cout", "?", "&", "cout", ":", "NULL", ")", ";", "break;", "case", "V_ASN1_INTEGER", ":", "case", "V_ASN1_NEG_INTEGER", ":", "case", "V_ASN1_ENUMERATED", ":", "case", "V_ASN1_NEG_ENUMERATED", ":", "/*", "These", "are", "all", "have", "the", "same", "content", "format", "*", "as", "ASN1_INTEGER", "*/", "return", "i2c_ASN1_INTEGER", "(", "(", "ASN1_INTEGER", "*", ")", "*", "pval", ",", "cout", "?", "&", "cout", ":", "NULL", ")", ";", "break;", "case", "V_ASN1_OCTET_STRING", ":", "case", "V_ASN1_NUMERICSTRING", ":", "case", "V_ASN1_PRINTABLESTRING", ":", "case", "V_ASN1_T61STRING", ":", "case", "V_ASN1_VIDEOTEXSTRING", ":", "case", "V_ASN1_IA5STRING", ":", "case", "V_ASN1_UTCTIME", ":", "case", "V_ASN1_GENERALIZEDTIME", ":", "case", "V_ASN1_GRAPHICSTRING", ":", "case", "V_ASN1_VISIBLESTRING", ":", "case", "V_ASN1_GENERALSTRING", ":", "case", "V_ASN1_UNIVERSALSTRING", ":", "case", "V_ASN1_BMPSTRING", ":", "case", "V_ASN1_UTF8STRING", ":", "case", "V_ASN1_SEQUENCE", ":", "case", "V_ASN1_SET", ":", "default:", "/*", "All", "based", "on", "ASN1_STRING", "and", "handled", "the", "same", "*/", "strtmp", "=", "(", "ASN1_STRING", "*", ")", "*", "pval", ";", "/*", "Special", "handling", "for", "NDEF", "*/", "if", "(", "(", "it", "->", "size", "==", "ASN1_TFLG_NDEF", ")", "&&", "(", "strtmp", "->", "flags", "&", "ASN1_STRING_FLAG_NDEF", ")", ")", "{", "if", "(", "cout", ")", "{", "strtmp", "->", "data", "=", "cout", ";", "strtmp", "->", "length", "=", "0", ";", "}", "/*", "Special", "return", "code", "*/", "return", "-", "2", ";", "}", "cont", "=", "strtmp", "->", "data", ";", "len", "=", "strtmp", "->", "length", ";", "break;", "}", "if", "(", "cout", "&&", "len", ")", "memcpy", "(", "cout", ",", "cont", ",", "len", ")", ";", "return", "len", ";", "}'" ]

[ "convert", "experience", "level", "(1" ]

[ "'int", "xlev_to_rank", "(", "int", "xlev", ")", "{", "return", "(", "xlev", "<=", "2", ")", "?", "0", ":", "(", "xlev", "<=", "30", ")", "?", "(", "(", "xlev", "+", "2", ")", "/", "4", ")", ":", "8", ";", "}'" ]

[ "provide", "the", "name", "of", "the", "current", "level" ]

[ "'int", "describe_level", "(", "char", "*", "buf", ")", "{", "int", "ret", "=", "1", ";", "if", "(", "Is_knox", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "\"%s\"", ",", "find_dungeon", "(", "&", "u", ".", "uz", ")", ".", "dname", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "In_quest", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "\"Home:%d\"", ",", "dunlev", "(", "&", "u", ".", "uz", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "In_endgame", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "Is_astralevel", "(", "&", "u", ".", "uz", ")", "?", "\"Astral", "Plane\"", ":", "\"End", "Game\"", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "In_mines", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "\"Mines:%d\"", ",", "depth", "(", "&", "u", ".", "uz", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "In_sokoban", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "\"Sokoban:%d\"", ",", "depth", "(", "&", "u", ".", "uz", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "Is_valley", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "\"Valley:%d\"", ",", "depth", "(", "&", "u", ".", "uz", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "In_hell", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "\"Gehennom:%d\"", ",", "depth", "(", "&", "u", ".", "uz", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "In_V_tower", "(", "&", "u", ".", "uz", ")", ")", "sprintf", "(", "buf", ",", "\"Tower:%d\"", ",", "depth", "(", "&", "u", ".", "uz", ")", ")", ";", "else", "sprintf", "(", "buf", ",", "\"Dungeons:%d\"", ",", "depth", "(", "&", "u", ".", "uz", ")", ")", ",", "(", "ret", "=", "0", ")", ";", "return", "ret", ";", "}'" ]

[ "Functions", "recording", "PMD", "metrics", "per", "iteration" ]

[ "'void", "pmd_perf_start_iteration", "(", "struct", "pmd_perf_stats", "*", "s", ")", "OVS_REQUIRES", "(", "s", "->", "stats_mutex", ")", "{", "if", "(", "s", "->", "clear", ")", "{", "/*", "Clear", "the", "PMD", "stats", "before", "starting", "next", "iteration.", "*/", "pmd_perf_stats_clear_lock", "(", "s", ")", ";", "}", "s", "->", "iteration_cnt", "++", ";", "/*", "Initialize", "the", "current", "interval", "stats.", "*/", "memset", "(", "&", "s", "->", "current", ",", "0", ",", "sizeof", "(", "struct", "iter_stats", ")", ")", ";", "if", "(", "OVS_LIKELY", "(", "s", "->", "last_tsc", ")", ")", "{", "/*", "We", "assume", "here", "that", "last_tsc", "was", "updated", "immediately", "prior", "at", "*", "the", "end", "of", "the", "previous", "iteration,", "or", "just", "before", "the", "first", "*", "iteration.", "*/", "s", "->", "start_tsc", "=", "s", "->", "last_tsc", ";", "}", "else", "{", "/*", "In", "case", "last_tsc", "has", "never", "been", "set", "before.", "*/", "s", "->", "start_tsc", "=", "cycles_counter_update", "(", "s", ")", ";", "}", "}'" ]

[ "NOTE:", "you", "should", "be", "passing", "1,", "not", "0", "as", "lastpos" ]

[ "'int", "X509_NAME_get_index_by_OBJ", "(", "X509_NAME", "*", "name", ",", "const", "ASN1_OBJECT", "*", "obj", ",", "int", "lastpos", ")", "{", "int", "n", ";", "X509_NAME_ENTRY", "*", "ne", ";", "STACK_OF", "(", "X509_NAME_ENTRY", ")", "*", "sk", ";", "if", "(", "name", "==", "NULL", ")", "return", "-", "1", ";", "if", "(", "lastpos", "<", "0", ")", "lastpos", "=", "-", "1", ";", "sk", "=", "name", "->", "entries", ";", "n", "=", "sk_X509_NAME_ENTRY_num", "(", "sk", ")", ";", "for", "(", "lastpos", "++", ";", "lastpos", "<", "n", ";", "lastpos", "++", ")", "{", "ne", "=", "sk_X509_NAME_ENTRY_value", "(", "sk", ",", "lastpos", ")", ";", "if", "(", "OBJ_cmp", "(", "ne", "->", "object", ",", "obj", ")", "==", "0", ")", "return", "lastpos", ";", "}", "return", "-", "1", ";", "}'" ]

[ "Creates", "dense", "attribute", "storage", "structures", "for", "an", "object" ]

[ "'herr_t", "H5A_dense_create", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "H5O_ainfo_t", "*", "ainfo", ")", "{", "H5HF_create_t", "fheap_cparam", ";", "/*", "Fractal", "heap", "creation", "parameters", "*/", "H5B2_create_t", "bt2_cparam", ";", "/*", "v2", "B-tree", "creation", "parameters", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5B2_t", "*", "bt2_name", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "names", "*/", "H5B2_t", "*", "bt2_corder", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "creation", "order", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "/*", "Set", "fractal", "heap", "creation", "parameters", "*/", "/*", "XXX:", "Give", "some", "control", "of", "these", "to", "applications?", "*/", "HDmemset", "(", "&", "fheap_cparam", ",", "0", ",", "sizeof", "(", "fheap_cparam", ")", ")", ";", "fheap_cparam", ".", "managed", ".", "width", "=", "H5O_FHEAP_MAN_WIDTH", ";", "fheap_cparam", ".", "managed", ".", "start_block_size", "=", "H5O_FHEAP_MAN_START_BLOCK_SIZE", ";", "fheap_cparam", ".", "managed", ".", "max_direct_size", "=", "H5O_FHEAP_MAN_MAX_DIRECT_SIZE", ";", "fheap_cparam", ".", "managed", ".", "max_index", "=", "H5O_FHEAP_MAN_MAX_INDEX", ";", "fheap_cparam", ".", "managed", ".", "start_root_rows", "=", "H5O_FHEAP_MAN_START_ROOT_ROWS", ";", "fheap_cparam", ".", "checksum_dblocks", "=", "H5O_FHEAP_CHECKSUM_DBLOCKS", ";", "fheap_cparam", ".", "max_man_size", "=", "H5O_FHEAP_MAX_MAN_SIZE", ";", "/*", "Create", "fractal", "heap", "for", "storing", "attributes", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_create", "(", "f", ",", "dxpl_id", ",", "&", "fheap_cparam", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"unable", "to", "create", "fractal", "heap\"", ")", "/*", "Retrieve", "the", "heap\\'s", "address", "in", "the", "file", "*/", "if", "(", "H5HF_get_heap_addr", "(", "fheap", ",", "&", "ainfo", "->", "fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGETSIZE", ",", "FAIL", ",", "\"can\\'t", "get", "fractal", "heap", "address\"", ")", "#", "ifdef", "QAK", "HDfprintf", "(", "stderr", ",", "\"%s:", "ainfo->fheap_addr", "=", "%a\\\"", ",", "FUNC", ",", "ainfo", "->", "fheap_addr", ")", ";", "#", "endif", "/*", "QAK", "*/", "#", "ifndef", "NDEBUG", "{", "size_t", "fheap_id_len", ";", "/*", "Fractal", "heap", "ID", "length", "*/", "/*", "Retrieve", "the", "heap\\'s", "ID", "length", "in", "the", "file", "*/", "if", "(", "H5HF_get_id_len", "(", "fheap", ",", "&", "fheap_id_len", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGETSIZE", ",", "FAIL", ",", "\"can\\'t", "get", "fractal", "heap", "ID", "length\"", ")", "HDassert", "(", "fheap_id_len", "==", "H5O_FHEAP_ID_LEN", ")", ";", "#", "ifdef", "QAK", "HDfprintf", "(", "stderr", ",", "\"%s:", "fheap_id_len", "=", "%Zu\\\"", ",", "FUNC", ",", "fheap_id_len", ")", ";", "#", "endif", "/*", "QAK", "*/", "}", "#", "endif", "/*", "NDEBUG", "*/", "/*", "Create", "the", "name", "index", "v2", "B-tree", "*/", "HDmemset", "(", "&", "bt2_cparam", ",", "0", ",", "sizeof", "(", "bt2_cparam", ")", ")", ";", "bt2_cparam", ".", "cls", "=", "H5A_BT2_NAME", ";", "bt2_cparam", ".", "node_size", "=", "(", "size_t", ")", "H5A_NAME_BT2_NODE_SIZE", ";", "bt2_cparam", ".", "rrec_size", "=", "4", "+", "/*", "Name\\'s", "hash", "value", "*/", "4", "+", "/*", "Creation", "order", "index", "*/", "1", "+", "/*", "Message", "flags", "*/", "H5O_FHEAP_ID_LEN", ";", "/*", "Fractal", "heap", "ID", "*/", "bt2_cparam", ".", "split_percent", "=", "H5A_NAME_BT2_SPLIT_PERC", ";", "bt2_cparam", ".", "merge_percent", "=", "H5A_NAME_BT2_MERGE_PERC", ";", "if", "(", "NULL", "==", "(", "bt2_name", "=", "H5B2_create", "(", "f", ",", "dxpl_id", ",", "&", "bt2_cparam", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"unable", "to", "create", "v2", "B-tree", "for", "name", "index\"", ")", "/*", "Retrieve", "the", "v2", "B-tree\\'s", "address", "in", "the", "file", "*/", "if", "(", "H5B2_get_addr", "(", "bt2_name", ",", "&", "ainfo", "->", "name_bt2_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "v2", "B-tree", "address", "for", "name", "index\"", ")", "#", "ifdef", "QAK", "HDfprintf", "(", "stderr", ",", "\"%s:", "ainfo->name_bt2_addr", "=", "%a\\\"", ",", "FUNC", ",", "ainfo", "->", "name_bt2_addr", ")", ";", "#", "endif", "/*", "QAK", "*/", "/*", "Check", "if", "we", "should", "create", "a", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "ainfo", "->", "index_corder", ")", "{", "/*", "Create", "the", "creation", "order", "index", "v2", "B-tree", "*/", "HDmemset", "(", "&", "bt2_cparam", ",", "0", ",", "sizeof", "(", "bt2_cparam", ")", ")", ";", "bt2_cparam", ".", "cls", "=", "H5A_BT2_CORDER", ";", "bt2_cparam", ".", "node_size", "=", "(", "size_t", ")", "H5A_CORDER_BT2_NODE_SIZE", ";", "bt2_cparam", ".", "rrec_size", "=", "4", "+", "/*", "Creation", "order", "index", "*/", "1", "+", "/*", "Message", "flags", "*/", "H5O_FHEAP_ID_LEN", ";", "/*", "Fractal", "heap", "ID", "*/", "bt2_cparam", ".", "split_percent", "=", "H5A_CORDER_BT2_SPLIT_PERC", ";", "bt2_cparam", ".", "merge_percent", "=", "H5A_CORDER_BT2_MERGE_PERC", ";", "if", "(", "NULL", "==", "(", "bt2_corder", "=", "H5B2_create", "(", "f", ",", "dxpl_id", ",", "&", "bt2_cparam", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"unable", "to", "create", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "/*", "Retrieve", "the", "v2", "B-tree\\'s", "address", "in", "the", "file", "*/", "if", "(", "H5B2_get_addr", "(", "bt2_corder", ",", "&", "ainfo", "->", "corder_bt2_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "v2", "B-tree", "address", "for", "creation", "order", "index\"", ")", "#", "ifdef", "QAK", "HDfprintf", "(", "stderr", ",", "\"%s:", "ainfo->corder_bt2_addr", "=", "%a\\\"", ",", "FUNC", ",", "ainfo", "->", "corder_bt2_addr", ")", ";", "#", "endif", "/*", "QAK", "*/", "}", "/*", "end", "if", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2_name", "&&", "H5B2_close", "(", "bt2_name", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "name", "index\"", ")", "if", "(", "bt2_corder", "&&", "H5B2_close", "(", "bt2_corder", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Insert", "an", "attribute", "into", "dense", "storage", "structures", "for", "an", "object" ]

[ "'herr_t", "H5A_dense_insert", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "H5A_t", "*", "attr", ")", "{", "H5A_bt2_ud_ins_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "insertion", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "attributes", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5B2_t", "*", "bt2_name", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "name", "index", "*/", "H5B2_t", "*", "bt2_corder", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "creation", "order", "index", "*/", "H5WB_t", "*", "wb", "=", "NULL", ";", "/*", "Wrapped", "buffer", "for", "attribute", "data", "*/", "uint8_t", "attr_buf", "[", "H5A_ATTR_BUF_SIZE", "]", ";", "/*", "Buffer", "for", "serializing", "message", "*/", "unsigned", "mesg_flags", "=", "0", ";", "/*", "Flags", "for", "storing", "message", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "HDassert", "(", "attr", ")", ";", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "htri_t", "shared_mesg", ";", "/*", "Should", "this", "message", "be", "stored", "in", "the", "Shared", "Message", "table?", "*/", "/*", "Check", "if", "message", "is", "already", "shared", "*/", "if", "(", "(", "shared_mesg", "=", "H5O_msg_is_shared", "(", "H5O_ATTR_ID", ",", "attr", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"error", "determining", "if", "message", "is", "shared\"", ")", "<if", "type=\"elseif\">", "else", "if", "(", "shared_mesg", ">", "0", ")", "/*", "Mark", "the", "message", "as", "shared", "*/", "mesg_flags", "|=", "H5O_MSG_FLAG_SHARED", ";", "else", "{", "/*", "Should", "this", "attribute", "be", "written", "as", "a", "SOHM?", "*/", "if", "(", "H5SM_try_share", "(", "f", ",", "dxpl_id", ",", "NULL", ",", "0", ",", "H5O_ATTR_ID", ",", "attr", ",", "&", "mesg_flags", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_WRITEERROR", ",", "FAIL", ",", "\"error", "determining", "if", "message", "should", "be", "shared\"", ")", "/*", "Attributes", "can\\'t", "be", "\"unique", "be", "shareable\"", "yet", "*/", "HDassert", "(", "!", "(", "mesg_flags", "&", "H5O_MSG_FLAG_SHAREABLE", ")", ")", ";", "}", "/*", "end", "else", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Check", "for", "inserting", "shared", "attribute", "*/", "if", "(", "mesg_flags", "&", "H5O_MSG_FLAG_SHARED", ")", "{", "/*", "Sanity", "check", "*/", "HDassert", "(", "attr_sharable", ")", ";", "/*", "Use", "heap", "ID", "for", "shared", "message", "heap", "*/", "udata", ".", "id", "=", "attr", "->", "sh_loc", ".", "u", ".", "heap_id", ";", "}", "/*", "end", "if", "*/", "else", "{", "void", "*", "attr_ptr", ";", "/*", "Pointer", "to", "serialized", "message", "*/", "size_t", "attr_size", ";", "/*", "Size", "of", "serialized", "attribute", "in", "the", "heap", "*/", "/*", "Find", "out", "the", "size", "of", "buffer", "needed", "for", "serialized", "message", "*/", "if", "(", "(", "attr_size", "=", "H5O_msg_raw_size", "(", "f", ",", "H5O_ATTR_ID", ",", "FALSE", ",", "attr", ")", ")", "==", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGETSIZE", ",", "FAIL", ",", "\"can\\'t", "get", "message", "size\"", ")", "/*", "Wrap", "the", "local", "buffer", "for", "serialized", "attributes", "*/", "if", "(", "NULL", "==", "(", "wb", "=", "H5WB_wrap", "(", "attr_buf", ",", "sizeof", "(", "attr_buf", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"can\\'t", "wrap", "buffer\"", ")", "/*", "Get", "a", "pointer", "to", "a", "buffer", "that\\'s", "large", "enough", "for", "attribute", "*/", "if", "(", "NULL", "==", "(", "attr_ptr", "=", "H5WB_actual", "(", "wb", ",", "attr_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOSPACE", ",", "FAIL", ",", "\"can\\'t", "get", "actual", "buffer\"", ")", "/*", "Create", "serialized", "form", "of", "attribute", "or", "shared", "message", "*/", "if", "(", "H5O_msg_encode", "(", "f", ",", "H5O_ATTR_ID", ",", "FALSE", ",", "(", "unsigned", "char", "*", ")", "attr_ptr", ",", "attr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTENCODE", ",", "FAIL", ",", "\"can\\'t", "encode", "attribute\"", ")", "/*", "Insert", "the", "serialized", "attribute", "into", "the", "fractal", "heap", "*/", "/*", "(sets", "the", "heap", "ID", "in", "the", "user", "data)", "*/", "if", "(", "H5HF_insert", "(", "fheap", ",", "dxpl_id", ",", "attr_size", ",", "attr_ptr", ",", "&", "udata", ".", "id", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"unable", "to", "insert", "attribute", "into", "fractal", "heap\"", ")", "}", "/*", "end", "else", "*/", "/*", "Open", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_name", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "name_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "name", "index\"", ")", "/*", "Create", "the", "callback", "information", "for", "v2", "B-tree", "record", "insertion", "*/", "udata", ".", "common", ".", "f", "=", "f", ";", "udata", ".", "common", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "common", ".", "fheap", "=", "fheap", ";", "udata", ".", "common", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "common", ".", "name", "=", "attr", "->", "shared", "->", "name", ";", "udata", ".", "common", ".", "name_hash", "=", "H5_checksum_lookup3", "(", "attr", "->", "shared", "->", "name", ",", "HDstrlen", "(", "attr", "->", "shared", "->", "name", ")", ",", "0", ")", ";", "H5_CHECKED_ASSIGN", "(", "udata", ".", "common", ".", "flags", ",", "uint8_t", ",", "mesg_flags", ",", "unsigned", ")", ";", "udata", ".", "common", ".", "corder", "=", "attr", "->", "shared", "->", "crt_idx", ";", "udata", ".", "common", ".", "found_op", "=", "NULL", ";", "udata", ".", "common", ".", "found_op_data", "=", "NULL", ";", "/*", "udata.id", "already", "set", "*/", "/*", "Insert", "attribute", "into", "\\'name\\'", "tracking", "v2", "B-tree", "*/", "if", "(", "H5B2_insert", "(", "bt2_name", ",", "dxpl_id", ",", "&", "udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"unable", "to", "insert", "record", "into", "v2", "B-tree\"", ")", "/*", "Check", "if", "we", "should", "create", "a", "creation", "order", "index", "v2", "B-tree", "record", "*/", "if", "(", "ainfo", "->", "index_corder", ")", "{", "/*", "Open", "the", "creation", "order", "index", "v2", "B-tree", "*/", "HDassert", "(", "H5F_addr_defined", "(", "ainfo", "->", "corder_bt2_addr", ")", ")", ";", "if", "(", "NULL", "==", "(", "bt2_corder", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "corder_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "/*", "Insert", "the", "record", "into", "the", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "H5B2_insert", "(", "bt2_corder", ",", "dxpl_id", ",", "&", "udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"unable", "to", "insert", "record", "into", "v2", "B-tree\"", ")", "}", "/*", "end", "if", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2_name", "&&", "H5B2_close", "(", "bt2_name", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "name", "index\"", ")", "if", "(", "bt2_corder", "&&", "H5B2_close", "(", "bt2_corder", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "if", "(", "wb", "&&", "H5WB_unwrap", "(", "wb", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "wrapped", "buffer\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Iterate", "over", "attributes", "in", "dense", "storage", "structures", "for", "an", "object" ]

[ "'herr_t", "H5A_dense_iterate", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "hid_t", "loc_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "H5_index_t", "idx_type", ",", "H5_iter_order_t", "order", ",", "hsize_t", "skip", ",", "hsize_t", "*", "last_attr", ",", "const", "H5A_attr_iter_op_t", "*", "attr_op", ",", "void", "*", "op_data", ")", "{", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5A_attr_table_t", "atable", "=", "{", "0", ",", "NULL", "}", ";", "/*", "Table", "of", "attributes", "*/", "H5B2_t", "*", "bt2", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "index", "*/", "haddr_t", "bt2_addr", ";", "/*", "Address", "of", "v2", "B-tree", "to", "use", "for", "lookup", "*/", "herr_t", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "HDassert", "(", "H5F_addr_defined", "(", "ainfo", "->", "fheap_addr", ")", ")", ";", "HDassert", "(", "H5F_addr_defined", "(", "ainfo", "->", "name_bt2_addr", ")", ")", ";", "HDassert", "(", "attr_op", ")", ";", "/*", "Determine", "the", "address", "of", "the", "index", "to", "use", "*/", "if", "(", "idx_type", "==", "H5_INDEX_NAME", ")", "{", "/*", "Check", "if", "\"native\"", "order", "is", "OK", "-", "since", "names", "are", "hashed,", "getting", "them", "*", "in", "strictly", "increasing", "or", "decreasing", "order", "requires", "building", "a", "*", "table", "and", "sorting", "it.", "*/", "if", "(", "order", "==", "H5_ITER_NATIVE", ")", "{", "HDassert", "(", "H5F_addr_defined", "(", "ainfo", "->", "name_bt2_addr", ")", ")", ";", "bt2_addr", "=", "ainfo", "->", "name_bt2_addr", ";", "}", "/*", "end", "if", "*/", "else", "bt2_addr", "=", "HADDR_UNDEF", ";", "}", "/*", "end", "if", "*/", "else", "{", "HDassert", "(", "idx_type", "==", "H5_INDEX_CRT_ORDER", ")", ";", "/*", "This", "address", "may", "not", "be", "defined", "if", "creation", "order", "is", "tracked,", "but", "*", "there\\'s", "no", "index", "on", "it.", "If", "there\\'s", "no", "v2", "B-tree", "that", "indexes", "*", "the", "links,", "a", "table", "will", "be", "built.", "*/", "bt2_addr", "=", "ainfo", "->", "corder_bt2_addr", ";", "}", "/*", "end", "else", "*/", "/*", "Check", "on", "iteration", "order", "*/", "if", "(", "order", "==", "H5_ITER_NATIVE", "&&", "H5F_addr_defined", "(", "bt2_addr", ")", ")", "{", "H5A_bt2_ud_it_t", "udata", ";", "/*", "User", "data", "for", "iterator", "callback", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "index\"", ")", "/*", "Construct", "the", "user", "data", "for", "v2", "B-tree", "iterator", "callback", "*/", "udata", ".", "f", "=", "f", ";", "udata", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "fheap", "=", "fheap", ";", "udata", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "loc_id", "=", "loc_id", ";", "udata", ".", "skip", "=", "skip", ";", "udata", ".", "count", "=", "0", ";", "udata", ".", "attr_op", "=", "attr_op", ";", "udata", ".", "op_data", "=", "op_data", ";", "/*", "Iterate", "over", "the", "records", "in", "the", "v2", "B-tree\\'s", "\"native\"", "order", "*/", "/*", "(by", "hash", "of", "name)", "*/", "if", "(", "(", "ret_value", "=", "H5B2_iterate", "(", "bt2", ",", "dxpl_id", ",", "H5A__dense_iterate_bt2_cb", ",", "&", "udata", ")", ")", "<", "0", ")", "HERROR", "(", "H5E_ATTR", ",", "H5E_BADITER", ",", "\"attribute", "iteration", "failed\"", ")", ";", "/*", "Update", "the", "last", "attribute", "examined,", "if", "requested", "*/", "if", "(", "last_attr", ")", "*", "last_attr", "=", "udata", ".", "count", ";", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Build", "the", "table", "of", "attributes", "for", "this", "object", "*/", "/*", "(build", "table", "using", "the", "name", "index,", "but", "sort", "according", "to", "idx_type)", "*/", "if", "(", "H5A_dense_build_table", "(", "f", ",", "dxpl_id", ",", "ainfo", ",", "idx_type", ",", "order", ",", "&", "atable", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"error", "building", "table", "of", "attributes\"", ")", "/*", "Iterate", "over", "attributes", "in", "table", "*/", "if", "(", "(", "ret_value", "=", "H5A_attr_iterate_table", "(", "&", "atable", ",", "skip", ",", "last_attr", ",", "loc_id", ",", "attr_op", ",", "op_data", ")", ")", "<", "0", ")", "HERROR", "(", "H5E_ATTR", ",", "H5E_CANTNEXT", ",", "\"iteration", "operator", "failed\"", ")", ";", "}", "/*", "end", "else", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2", "&&", "H5B2_close", "(", "bt2", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "index\"", ")", "if", "(", "atable", ".", "attrs", "&&", "H5A_attr_release_table", "(", "&", "atable", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "release", "attribute", "table\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Rename", "an", "attribute", "in", "dense", "storage", "structures", "for", "an", "object" ]

[ "'herr_t", "H5A_dense_rename", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "const", "char", "*", "old_name", ",", "const", "char", "*", "new_name", ")", "{", "H5A_bt2_ud_common_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "modify", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5B2_t", "*", "bt2_name", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "name", "index", "*/", "H5B2_t", "*", "bt2_corder", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "creation", "order", "ndex", "*/", "H5A_t", "*", "attr_copy", "=", "NULL", ";", "/*", "Copy", "of", "attribute", "to", "rename", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "htri_t", "shared_mesg", ";", "/*", "Should", "this", "message", "be", "stored", "in", "the", "Shared", "Message", "table?", "*/", "htri_t", "attr_exists", ";", "/*", "Attribute", "exists", "in", "v2", "B-tree", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "HDassert", "(", "old_name", ")", ";", "HDassert", "(", "new_name", ")", ";", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Open", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_name", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "name_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "name", "index\"", ")", "/*", "Create", "the", "\"udata\"", "information", "for", "v2", "B-tree", "record", "modify", "*/", "udata", ".", "f", "=", "f", ";", "udata", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "fheap", "=", "fheap", ";", "udata", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "name", "=", "old_name", ";", "udata", ".", "name_hash", "=", "H5_checksum_lookup3", "(", "old_name", ",", "HDstrlen", "(", "old_name", ")", ",", "0", ")", ";", "udata", ".", "flags", "=", "0", ";", "udata", ".", "corder", "=", "0", ";", "udata", ".", "found_op", "=", "H5A__dense_fnd_cb", ";", "/*", "v2", "B-tree", "comparison", "callback", "*/", "udata", ".", "found_op_data", "=", "&", "attr_copy", ";", "/*", "Get", "copy", "of", "attribute", "through", "\\'name\\'", "tracking", "v2", "B-tree", "*/", "if", "(", "(", "attr_exists", "=", "H5B2_find", "(", "bt2_name", ",", "dxpl_id", ",", "&", "udata", ",", "NULL", ",", "NULL", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOTFOUND", ",", "FAIL", ",", "\"can\\'t", "search", "for", "attribute", "in", "name", "index\"", ")", "<if", "type=\"elseif\">", "else", "if", "(", "attr_exists", "==", "FALSE", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOTFOUND", ",", "FAIL", ",", "\"can\\'t", "locate", "attribute", "in", "name", "index\"", ")", "HDassert", "(", "attr_copy", ")", ";", "/*", "Check", "if", "message", "is", "already", "shared", "*/", "if", "(", "(", "shared_mesg", "=", "H5O_msg_is_shared", "(", "H5O_ATTR_ID", ",", "attr_copy", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"error", "determining", "if", "message", "is", "shared\"", ")", "<if", "type=\"elseif\">", "else", "if", "(", "shared_mesg", ">", "0", ")", "{", "/*", "Reset", "shared", "status", "of", "copy", "*/", "/*", "(so", "it", "will", "get", "shared", "again", "if", "necessary)", "*/", "attr_copy", "->", "sh_loc", ".", "type", "=", "H5O_SHARE_TYPE_UNSHARED", ";", "}", "/*", "end", "if", "*/", "/*", "Change", "name", "of", "attribute", "*/", "H5MM_xfree", "(", "attr_copy", "->", "shared", "->", "name", ")", ";", "attr_copy", "->", "shared", "->", "name", "=", "H5MM_xstrdup", "(", "new_name", ")", ";", "/*", "Recompute", "the", "version", "to", "encode", "the", "attribute", "with", "*/", "if", "(", "H5A_set_version", "(", "f", ",", "attr_copy", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"unable", "to", "update", "attribute", "version\"", ")", "/*", "Need", "to", "remove", "the", "attribute", "from", "the", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "ainfo", "->", "index_corder", ")", "{", "htri_t", "corder_attr_exists", ";", "/*", "Attribute", "exists", "in", "v2", "B-tree", "*/", "/*", "Open", "the", "creation", "order", "index", "v2", "B-tree", "*/", "HDassert", "(", "H5F_addr_defined", "(", "ainfo", "->", "corder_bt2_addr", ")", ")", ";", "if", "(", "NULL", "==", "(", "bt2_corder", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "corder_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "creation", "index\"", ")", "/*", "Set", "up", "the", "creation", "order", "to", "search", "for", "*/", "udata", ".", "corder", "=", "attr_copy", "->", "shared", "->", "crt_idx", ";", "if", "(", "(", "corder_attr_exists", "=", "H5B2_find", "(", "bt2_corder", ",", "dxpl_id", ",", "&", "udata", ",", "NULL", ",", "NULL", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOTFOUND", ",", "FAIL", ",", "\"can\\'t", "search", "for", "attribute", "in", "name", "index\"", ")", "if", "(", "corder_attr_exists", ")", "{", "H5A_bt2_ud_rm_t", "rm_udata", ";", "/*", "Set", "up", "the", "creation", "order", "in", "user", "data", "for", "the", "v2", "B-tree", "\\'record", "remove\\'", "callback", "*/", "rm_udata", ".", "common", ".", "corder", "=", "attr_copy", "->", "shared", "->", "crt_idx", ";", "/*", "Remove", "the", "record", "from", "the", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "H5B2_remove", "(", "bt2_corder", ",", "dxpl_id", ",", "&", "rm_udata", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTREMOVE", ",", "FAIL", ",", "\"unable", "to", "remove", "attribute", "from", "creation", "order", "index", "v2", "B-tree\"", ")", "}", "}", "/*", "Insert", "renamed", "attribute", "back", "into", "dense", "storage", "*/", "/*", "(Possibly", "making", "it", "shared)", "*/", "if", "(", "H5A_dense_insert", "(", "f", ",", "dxpl_id", ",", "ainfo", ",", "attr_copy", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"unable", "to", "add", "to", "dense", "storage\"", ")", "/*", "Was", "this", "attribute", "shared?", "*/", "if", "(", "(", "shared_mesg", "=", "H5O_msg_is_shared", "(", "H5O_ATTR_ID", ",", "attr_copy", ")", ")", ">", "0", ")", "{", "hsize_t", "attr_rc", ";", "/*", "Attribute\\'s", "ref", "count", "in", "shared", "message", "storage", "*/", "/*", "Retrieve", "ref", "count", "for", "shared", "attribute", "*/", "if", "(", "H5SM_get_refcount", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "attr_copy", "->", "sh_loc", ",", "&", "attr_rc", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "retrieve", "shared", "message", "ref", "count\"", ")", "/*", "If", "the", "newly", "shared", "attribute", "needs", "to", "share", "\"ownership\"", "of", "the", "shared", "*", "components", "(ie.", "its", "reference", "count", "is", "1),", "increment", "the", "reference", "*", "count", "on", "any", "shared", "components", "of", "the", "attribute,", "so", "that", "they", "won\\'t", "*", "be", "removed", "from", "the", "file.", "(Essentially", "a", "\"copy", "on", "write\"", "operation).", "*", "*", "*ick*", "-QAK,", "2007/01/08", "*/", "if", "(", "attr_rc", "==", "1", ")", "{", "/*", "Increment", "reference", "count", "on", "attribute", "components", "*/", "if", "(", "H5O_attr_link", "(", "f", ",", "dxpl_id", ",", "NULL", ",", "attr_copy", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_LINKCOUNT", ",", "FAIL", ",", "\"unable", "to", "adjust", "attribute", "link", "count\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "shared_mesg", "==", "0", ")", "{", "/*", "Increment", "reference", "count", "on", "attribute", "components", "*/", "/*", "(so", "that", "they", "aren\\'t", "deleted", "when", "the", "attribute", "is", "removed", "shortly)", "*/", "if", "(", "H5O_attr_link", "(", "f", ",", "dxpl_id", ",", "NULL", ",", "attr_copy", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_LINKCOUNT", ",", "FAIL", ",", "\"unable", "to", "adjust", "attribute", "link", "count\"", ")", "}", "/*", "end", "if", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "shared_mesg", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_WRITEERROR", ",", "FAIL", ",", "\"error", "determining", "if", "message", "should", "be", "shared\"", ")", "/*", "Delete", "old", "attribute", "from", "dense", "storage", "*/", "if", "(", "H5A_dense_remove", "(", "f", ",", "dxpl_id", ",", "ainfo", ",", "old_name", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "attribute", "in", "dense", "storage\"", ")", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2_name", "&&", "H5B2_close", "(", "bt2_name", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "name", "index\"", ")", "if", "(", "bt2_corder", "&&", "H5B2_close", "(", "bt2_corder", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "if", "(", "attr_copy", ")", "H5O_msg_free", "(", "H5O_ATTR_ID", ",", "attr_copy", ")", ";", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Callback", "for", "fractal", "heap", "operator,", "to", "make", "copy", "of", "attribute", "for", "calling", "routine" ]

[ "'static", "herr_t", "H5A__dense_copy_fh_cb", "(", "const", "void", "*", "obj", ",", "size_t", "obj_len", ",", "void", "*", "_udata", ")", "{", "H5A_fh_ud_cp_t", "*", "udata", "=", "(", "H5A_fh_ud_cp_t", "*", ")", "_udata", ";", "/*", "User", "data", "for", "fractal", "heap", "\\'op\\'", "callback", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "Decode", "attribute", "information", "&", "keep", "a", "copy", "*/", "/*", "(we", "make", "a", "copy", "instead", "of", "calling", "the", "user/library", "callback", "directly", "in", "*", "this", "routine", "because", "this", "fractal", "heap", "\\'op\\'", "callback", "routine", "is", "called", "*", "with", "the", "direct", "block", "protected", "and", "if", "the", "callback", "routine", "invokes", "an", "*", "HDF5", "routine,", "it", "could", "attempt", "to", "re-protect", "that", "direct", "block", "for", "the", "*", "heap,", "causing", "the", "HDF5", "routine", "called", "to", "fail)", "*/", "if", "(", "NULL", "==", "(", "udata", "->", "attr", "=", "(", "H5A_t", "*", ")", "H5O_msg_decode", "(", "udata", "->", "f", ",", "udata", "->", "dxpl_id", ",", "NULL", ",", "H5O_ATTR_ID", ",", "obj_len", ",", "(", "const", "unsigned", "char", "*", ")", "obj", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDECODE", ",", "FAIL", ",", "\"can\\'t", "decode", "attribute\"", ")", "/*", "Set", "the", "creation", "order", "index", "for", "the", "attribute", "*/", "udata", "->", "attr", "->", "shared", "->", "crt_idx", "=", "udata", "->", "record", "->", "corder", ";", "/*", "Check", "whether", "we", "should", "\"reconstitute\"", "the", "shared", "message", "info", "*/", "if", "(", "udata", "->", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", "H5SM_reconstitute", "(", "&", "(", "udata", "->", "attr", "->", "sh_loc", ")", ",", "udata", "->", "f", ",", "H5O_ATTR_ID", ",", "udata", "->", "record", "->", "id", ")", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Check", "if", "an", "attribute", "exists", "in", "dense", "storage", "structures", "for", "an", "object" ]

[ "'htri_t", "H5A_dense_exists", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "const", "char", "*", "name", ")", "{", "H5A_bt2_ud_common_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "modify", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5B2_t", "*", "bt2_name", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "name", "index", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "htri_t", "ret_value", "=", "TRUE", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "NULL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "HDassert", "(", "name", ")", ";", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_name", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "name_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "name", "index\"", ")", "/*", "Create", "the", "\"udata\"", "information", "for", "v2", "B-tree", "record", "\\'find\\'", "*/", "udata", ".", "f", "=", "f", ";", "udata", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "fheap", "=", "fheap", ";", "udata", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "name", "=", "name", ";", "udata", ".", "name_hash", "=", "H5_checksum_lookup3", "(", "name", ",", "HDstrlen", "(", "name", ")", ",", "0", ")", ";", "udata", ".", "flags", "=", "0", ";", "udata", ".", "corder", "=", "0", ";", "udata", ".", "found_op", "=", "NULL", ";", "/*", "v2", "B-tree", "comparison", "callback", "*/", "udata", ".", "found_op_data", "=", "NULL", ";", "/*", "Find", "the", "attribute", "in", "the", "\\'name\\'", "index", "*/", "if", "(", "(", "ret_value", "=", "H5B2_find", "(", "bt2_name", ",", "dxpl_id", ",", "&", "udata", ",", "NULL", ",", "NULL", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOTFOUND", ",", "FAIL", ",", "\"can\\'t", "search", "for", "attribute", "in", "name", "index\"", ")", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2_name", "&&", "H5B2_close", "(", "bt2_name", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "name", "index\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "v2", "Btree", "callback", "for", "dense", "attribute", "storage", "record", "removal", "by", "index" ]

[ "'static", "herr_t", "H5A__dense_remove_by_idx_bt2_cb", "(", "const", "void", "*", "_record", ",", "void", "*", "_bt2_udata", ")", "{", "H5HF_t", "*", "fheap", ";", "/*", "Fractal", "heap", "handle", "*/", "H5B2_t", "*", "bt2", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "index", "*/", "const", "H5A_dense_bt2_name_rec_t", "*", "record", "=", "(", "const", "H5A_dense_bt2_name_rec_t", "*", ")", "_record", ";", "/*", "v2", "B-tree", "record", "*/", "H5A_bt2_ud_rmbi_t", "*", "bt2_udata", "=", "(", "H5A_bt2_ud_rmbi_t", "*", ")", "_bt2_udata", ";", "/*", "User", "data", "for", "callback", "*/", "H5A_fh_ud_cp_t", "fh_udata", ";", "/*", "User", "data", "for", "fractal", "heap", "\\'op\\'", "callback", "*/", "H5O_shared_t", "sh_loc", ";", "/*", "Shared", "message", "info", "for", "attribute", "*/", "hbool_t", "use_sh_loc", ";", "/*", "Whether", "to", "use", "the", "attribute\\'s", "shared", "location", "or", "the", "separate", "one", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "Set", "up", "the", "user", "data", "for", "fractal", "heap", "\\'op\\'", "callback", "*/", "fh_udata", ".", "f", "=", "bt2_udata", "->", "f", ";", "fh_udata", ".", "dxpl_id", "=", "bt2_udata", "->", "dxpl_id", ";", "fh_udata", ".", "record", "=", "record", ";", "fh_udata", ".", "attr", "=", "NULL", ";", "/*", "Get", "correct", "fractal", "heap", "handle", "to", "use", "for", "operations", "*/", "if", "(", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", "fheap", "=", "bt2_udata", "->", "shared_fheap", ";", "else", "fheap", "=", "bt2_udata", "->", "fheap", ";", "/*", "Check", "whether", "to", "make", "a", "copy", "of", "the", "attribute", "or", "just", "need", "the", "shared", "location", "info", "*/", "if", "(", "H5F_addr_defined", "(", "bt2_udata", "->", "other_bt2_addr", ")", "||", "!", "(", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", ")", "{", "/*", "Call", "fractal", "heap", "\\'op\\'", "routine,", "to", "make", "copy", "of", "attribute", "to", "remove", "*/", "if", "(", "H5HF_op", "(", "fheap", ",", "bt2_udata", "->", "dxpl_id", ",", "&", "record", "->", "id", ",", "H5A__dense_copy_fh_cb", ",", "&", "fh_udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPERATE", ",", "FAIL", ",", "\"attribute", "removal", "callback", "failed\"", ")", "HDassert", "(", "fh_udata", ".", "attr", ")", ";", "/*", "Use", "the", "attribute\\'s", "shared", "location", "*/", "use_sh_loc", "=", "FALSE", ";", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Create", "a", "shared", "message", "location", "from", "the", "heap", "ID", "for", "this", "record", "*/", "H5SM_reconstitute", "(", "&", "sh_loc", ",", "bt2_udata", "->", "f", ",", "H5O_ATTR_ID", ",", "record", "->", "id", ")", ";", "/*", "Use", "the", "separate", "shared", "location", "*/", "use_sh_loc", "=", "TRUE", ";", "}", "/*", "end", "else", "*/", "/*", "Check", "for", "removing", "the", "link", "from", "the", "\"other\"", "index", "(creation", "order,", "when", "name", "used", "and", "vice", "versa)", "*/", "if", "(", "H5F_addr_defined", "(", "bt2_udata", "->", "other_bt2_addr", ")", ")", "{", "H5A_bt2_ud_common_t", "other_bt2_udata", ";", "/*", "Info", "for", "B-tree", "callbacks", "*/", "/*", "Determine", "the", "index", "being", "used", "*/", "if", "(", "bt2_udata", "->", "idx_type", "==", "H5_INDEX_NAME", ")", "{", "/*", "Set", "up", "the", "user", "data", "for", "the", "v2", "B-tree", "\\'record", "remove\\'", "callback", "*/", "other_bt2_udata", ".", "corder", "=", "fh_udata", ".", "attr", "->", "shared", "->", "crt_idx", ";", "}", "/*", "end", "if", "*/", "else", "{", "HDassert", "(", "bt2_udata", "->", "idx_type", "==", "H5_INDEX_CRT_ORDER", ")", ";", "/*", "Set", "up", "the", "user", "data", "for", "the", "v2", "B-tree", "\\'record", "remove\\'", "callback", "*/", "other_bt2_udata", ".", "f", "=", "bt2_udata", "->", "f", ";", "other_bt2_udata", ".", "dxpl_id", "=", "bt2_udata", "->", "dxpl_id", ";", "other_bt2_udata", ".", "fheap", "=", "bt2_udata", "->", "fheap", ";", "other_bt2_udata", ".", "shared_fheap", "=", "bt2_udata", "->", "shared_fheap", ";", "other_bt2_udata", ".", "name", "=", "fh_udata", ".", "attr", "->", "shared", "->", "name", ";", "other_bt2_udata", ".", "name_hash", "=", "H5_checksum_lookup3", "(", "fh_udata", ".", "attr", "->", "shared", "->", "name", ",", "HDstrlen", "(", "fh_udata", ".", "attr", "->", "shared", "->", "name", ")", ",", "0", ")", ";", "other_bt2_udata", ".", "found_op", "=", "NULL", ";", "other_bt2_udata", ".", "found_op_data", "=", "NULL", ";", "}", "/*", "end", "else", "*/", "/*", "Open", "the", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2", "=", "H5B2_open", "(", "bt2_udata", "->", "f", ",", "bt2_udata", "->", "dxpl_id", ",", "bt2_udata", "->", "other_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "index\"", ")", "/*", "Set", "the", "common", "information", "for", "the", "v2", "B-tree", "remove", "operation", "*/", "/*", "Remove", "the", "record", "from", "the", "\"other\"", "index", "v2", "B-tree", "*/", "if", "(", "H5B2_remove", "(", "bt2", ",", "bt2_udata", "->", "dxpl_id", ",", "&", "other_bt2_udata", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTREMOVE", ",", "FAIL", ",", "\"unable", "to", "remove", "record", "from", "\\'other\\'", "index", "v2", "B-tree\"", ")", "}", "/*", "end", "if", "*/", "/*", "Check", "for", "removing", "shared", "attribute", "*/", "if", "(", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", "{", "H5O_shared_t", "*", "sh_loc_ptr", ";", "/*", "Pointer", "to", "shared", "message", "info", "for", "attribute", "*/", "/*", "Set", "up", "pointer", "to", "correct", "shared", "location", "*/", "if", "(", "use_sh_loc", ")", "sh_loc_ptr", "=", "&", "sh_loc", ";", "else", "sh_loc_ptr", "=", "&", "(", "fh_udata", ".", "attr", "->", "sh_loc", ")", ";", "/*", "Decrement", "the", "reference", "count", "on", "the", "shared", "attribute", "message", "*/", "if", "(", "H5SM_delete", "(", "bt2_udata", "->", "f", ",", "bt2_udata", "->", "dxpl_id", ",", "NULL", ",", "sh_loc_ptr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "delete", "shared", "attribute\"", ")", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Perform", "the", "deletion", "action", "on", "the", "attribute", "*/", "/*", "(takes", "care", "of", "shared", "&", "committed", "datatype/dataspace", "components)", "*/", "if", "(", "H5O_attr_delete", "(", "bt2_udata", "->", "f", ",", "bt2_udata", "->", "dxpl_id", ",", "NULL", ",", "fh_udata", ".", "attr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "attribute\"", ")", "/*", "Remove", "record", "from", "fractal", "heap", "*/", "if", "(", "H5HF_remove", "(", "fheap", ",", "bt2_udata", "->", "dxpl_id", ",", "&", "record", "->", "id", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTREMOVE", ",", "FAIL", ",", "\"unable", "to", "remove", "attribute", "from", "fractal", "heap\"", ")", "}", "/*", "end", "else", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "bt2", "&&", "H5B2_close", "(", "bt2", ",", "bt2_udata", "->", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "index\"", ")", "if", "(", "fh_udata", ".", "attr", ")", "H5O_msg_free", "(", "H5O_ATTR_ID", ",", "fh_udata", ".", "attr", ")", ";", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Modify", "an", "attribute", "in", "dense", "storage", "structures", "for", "an", "object" ]

[ "'herr_t", "H5A_dense_write", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "H5A_t", "*", "attr", ")", "{", "H5A_bt2_ud_common_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "modify", "*/", "H5A_bt2_od_wrt_t", "op_data", ";", "/*", "\"Op", "data\"", "for", "v2", "B-tree", "modify", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5B2_t", "*", "bt2_name", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "name", "index", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "HDassert", "(", "H5F_addr_defined", "(", "ainfo", "->", "fheap_addr", ")", ")", ";", "HDassert", "(", "H5F_addr_defined", "(", "ainfo", "->", "name_bt2_addr", ")", ")", ";", "HDassert", "(", "attr", ")", ";", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Open", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_name", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "name_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "name", "index\"", ")", "/*", "Create", "the", "\"udata\"", "information", "for", "v2", "B-tree", "record", "modify", "*/", "udata", ".", "f", "=", "f", ";", "udata", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "fheap", "=", "fheap", ";", "udata", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "name", "=", "attr", "->", "shared", "->", "name", ";", "udata", ".", "name_hash", "=", "H5_checksum_lookup3", "(", "attr", "->", "shared", "->", "name", ",", "HDstrlen", "(", "attr", "->", "shared", "->", "name", ")", ",", "0", ")", ";", "udata", ".", "flags", "=", "0", ";", "udata", ".", "corder", "=", "0", ";", "udata", ".", "found_op", "=", "NULL", ";", "udata", ".", "found_op_data", "=", "NULL", ";", "/*", "Create", "the", "\"op_data\"", "for", "the", "v2", "B-tree", "record", "\\'modify\\'", "callback", "*/", "op_data", ".", "f", "=", "f", ";", "op_data", ".", "dxpl_id", "=", "dxpl_id", ";", "op_data", ".", "fheap", "=", "fheap", ";", "op_data", ".", "shared_fheap", "=", "shared_fheap", ";", "op_data", ".", "attr", "=", "attr", ";", "op_data", ".", "corder_bt2_addr", "=", "ainfo", "->", "corder_bt2_addr", ";", "/*", "Modify", "attribute", "through", "\\'name\\'", "tracking", "v2", "B-tree", "*/", "if", "(", "H5B2_modify", "(", "bt2_name", ",", "dxpl_id", ",", "&", "udata", ",", "H5A__dense_write_bt2_cb", ",", "&", "op_data", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"unable", "to", "modify", "record", "in", "v2", "B-tree\"", ")", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2_name", "&&", "H5B2_close", "(", "bt2_name", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "name", "index\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "v2", "Btree", "'modify'", "callback", "to", "update", "the", "record", "for", "a", "creation", "order", "index" ]

[ "'static", "herr_t", "H5A__dense_write_bt2_cb2", "(", "void", "*", "_record", ",", "void", "*", "_op_data", ",", "hbool_t", "*", "changed", ")", "{", "H5A_dense_bt2_corder_rec_t", "*", "record", "=", "(", "H5A_dense_bt2_corder_rec_t", "*", ")", "_record", ";", "/*", "Record", "from", "B-tree", "*/", "H5O_fheap_id_t", "*", "new_heap_id", "=", "(", "H5O_fheap_id_t", "*", ")", "_op_data", ";", "/*", "\"op", "data\"", "from", "v2", "B-tree", "modify", "*/", "FUNC_ENTER_STATIC_NOERR", "/*", "Check", "arguments", "*/", "HDassert", "(", "record", ")", ";", "HDassert", "(", "new_heap_id", ")", ";", "/*", "Update", "record\\'s", "heap", "ID", "*/", "record", "->", "id", "=", "*", "new_heap_id", ";", "/*", "Note", "that", "the", "record", "changed", "*/", "*", "changed", "=", "TRUE", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "v2", "Btree", "callback", "for", "dense", "attribute", "storage", "deletion" ]

[ "'static", "herr_t", "H5A__dense_delete_bt2_cb", "(", "const", "void", "*", "_record", ",", "void", "*", "_bt2_udata", ")", "{", "const", "H5A_dense_bt2_name_rec_t", "*", "record", "=", "(", "const", "H5A_dense_bt2_name_rec_t", "*", ")", "_record", ";", "/*", "Record", "from", "B-tree", "*/", "H5A_bt2_ud_common_t", "*", "bt2_udata", "=", "(", "H5A_bt2_ud_common_t", "*", ")", "_bt2_udata", ";", "/*", "User", "data", "for", "callback", "*/", "H5A_t", "*", "attr", "=", "NULL", ";", "/*", "Attribute", "being", "removed", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "Check", "for", "shared", "attribute", "*/", "if", "(", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", "{", "H5O_shared_t", "sh_mesg", ";", "/*", "Temporary", "shared", "message", "info", "*/", "/*", "\"reconstitute\"", "the", "shared", "message", "info", "for", "the", "attribute", "*/", "H5SM_reconstitute", "(", "&", "sh_mesg", ",", "bt2_udata", "->", "f", ",", "H5O_ATTR_ID", ",", "record", "->", "id", ")", ";", "/*", "Decrement", "the", "reference", "count", "on", "the", "shared", "attribute", "message", "*/", "if", "(", "H5SM_delete", "(", "bt2_udata", "->", "f", ",", "bt2_udata", "->", "dxpl_id", ",", "NULL", ",", "&", "sh_mesg", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "delete", "shared", "attribute\"", ")", "}", "/*", "end", "if", "*/", "else", "{", "H5A_fh_ud_cp_t", "fh_udata", ";", "/*", "User", "data", "for", "fractal", "heap", "\\'op\\'", "callback", "*/", "/*", "Prepare", "user", "data", "for", "callback", "*/", "/*", "down", "*/", "fh_udata", ".", "f", "=", "bt2_udata", "->", "f", ";", "fh_udata", ".", "dxpl_id", "=", "bt2_udata", "->", "dxpl_id", ";", "fh_udata", ".", "record", "=", "record", ";", "/*", "up", "*/", "fh_udata", ".", "attr", "=", "NULL", ";", "/*", "Call", "fractal", "heap", "\\'op\\'", "routine,", "to", "copy", "the", "attribute", "information", "*/", "if", "(", "H5HF_op", "(", "bt2_udata", "->", "fheap", ",", "bt2_udata", "->", "dxpl_id", ",", "&", "record", "->", "id", ",", "H5A__dense_copy_fh_cb", ",", "&", "fh_udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPERATE", ",", "FAIL", ",", "\"heap", "op", "callback", "failed\"", ")", "attr", "=", "fh_udata", ".", "attr", ";", "/*", "Perform", "the", "deletion", "action", "on", "the", "attribute", "*/", "/*", "(takes", "care", "of", "shared/committed", "datatype", "&", "dataspace", "components)", "*/", "if", "(", "H5O_attr_delete", "(", "bt2_udata", "->", "f", ",", "bt2_udata", "->", "dxpl_id", ",", "NULL", ",", "fh_udata", ".", "attr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "attribute\"", ")", "}", "/*", "end", "else", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "attr", ")", "H5O_msg_free_real", "(", "H5O_MSG_ATTR", ",", "attr", ")", ";", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "v2", "Btree", "callback", "for", "dense", "attribute", "storage", "iterator" ]

[ "'static", "herr_t", "H5A__dense_iterate_bt2_cb", "(", "const", "void", "*", "_record", ",", "void", "*", "_bt2_udata", ")", "{", "const", "H5A_dense_bt2_name_rec_t", "*", "record", "=", "(", "const", "H5A_dense_bt2_name_rec_t", "*", ")", "_record", ";", "/*", "Record", "from", "B-tree", "*/", "H5A_bt2_ud_it_t", "*", "bt2_udata", "=", "(", "H5A_bt2_ud_it_t", "*", ")", "_bt2_udata", ";", "/*", "User", "data", "for", "callback", "*/", "herr_t", "ret_value", "=", "H5_ITER_CONT", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "Check", "for", "skipping", "attributes", "*/", "if", "(", "bt2_udata", "->", "skip", ">", "0", ")", "--", "bt2_udata", "->", "skip", ";", "else", "{", "H5A_fh_ud_cp_t", "fh_udata", ";", "/*", "User", "data", "for", "fractal", "heap", "\\'op\\'", "callback", "*/", "H5HF_t", "*", "fheap", ";", "/*", "Fractal", "heap", "handle", "for", "attribute", "storage", "*/", "/*", "Check", "for", "iterating", "over", "shared", "attribute", "*/", "if", "(", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", "fheap", "=", "bt2_udata", "->", "shared_fheap", ";", "else", "fheap", "=", "bt2_udata", "->", "fheap", ";", "/*", "Prepare", "user", "data", "for", "callback", "*/", "/*", "down", "*/", "fh_udata", ".", "f", "=", "bt2_udata", "->", "f", ";", "fh_udata", ".", "dxpl_id", "=", "bt2_udata", "->", "dxpl_id", ";", "fh_udata", ".", "record", "=", "record", ";", "fh_udata", ".", "attr", "=", "NULL", ";", "/*", "Call", "fractal", "heap", "\\'op\\'", "routine,", "to", "copy", "the", "attribute", "information", "*/", "if", "(", "H5HF_op", "(", "fheap", ",", "bt2_udata", "->", "dxpl_id", ",", "&", "record", "->", "id", ",", "H5A__dense_copy_fh_cb", ",", "&", "fh_udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPERATE", ",", "H5_ITER_ERROR", ",", "\"heap", "op", "callback", "failed\"", ")", "/*", "Check", "which", "type", "of", "callback", "to", "make", "*/", "switch", "(", "bt2_udata", "->", "attr_op", "->", "op_type", ")", "{", "case", "H5A_ATTR_OP_APP2", ":", "{", "H5A_info_t", "ainfo", ";", "/*", "Info", "for", "attribute", "*/", "/*", "Get", "the", "attribute", "information", "*/", "if", "(", "H5A_get_info", "(", "fh_udata", ".", "attr", ",", "&", "ainfo", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "H5_ITER_ERROR", ",", "\"unable", "to", "get", "attribute", "info\"", ")", "/*", "Make", "the", "application", "callback", "*/", "ret_value", "=", "(", "bt2_udata", "->", "attr_op", "->", "u", ".", "app_op2", ")", "(", "bt2_udata", "->", "loc_id", ",", "fh_udata", ".", "attr", "->", "shared", "->", "name", ",", "&", "ainfo", ",", "bt2_udata", "->", "op_data", ")", ";", "break;", "}", "#", "ifndef", "H5_NO_DEPRECATED_SYMBOLS", "case", "H5A_ATTR_OP_APP", ":", "/*", "Make", "the", "application", "callback", "*/", "ret_value", "=", "(", "bt2_udata", "->", "attr_op", "->", "u", ".", "app_op", ")", "(", "bt2_udata", "->", "loc_id", ",", "fh_udata", ".", "attr", "->", "shared", "->", "name", ",", "bt2_udata", "->", "op_data", ")", ";", "break;", "#", "endif", "/*", "H5_NO_DEPRECATED_SYMBOLS", "*/", "case", "H5A_ATTR_OP_LIB", ":", "/*", "Call", "the", "library\\'s", "callback", "*/", "ret_value", "=", "(", "bt2_udata", "->", "attr_op", "->", "u", ".", "lib_op", ")", "(", "fh_udata", ".", "attr", ",", "bt2_udata", "->", "op_data", ")", ";", "break;", "default:", "HDassert", "(", "\"unknown", "attribute", "op", "type\"", "&&", "0", ")", ";", "#", "ifdef", "NDEBUG", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_UNSUPPORTED", ",", "FAIL", ",", "\"unsupported", "attribute", "op", "type\"", ")", "#", "endif", "/*", "NDEBUG", "*/", "}", "/*", "end", "switch", "*/", "/*", "Release", "the", "space", "allocated", "for", "the", "attribute", "*/", "H5O_msg_free", "(", "H5O_ATTR_ID", ",", "fh_udata", ".", "attr", ")", ";", "}", "/*", "end", "else", "*/", "/*", "Increment", "the", "number", "of", "attributes", "passed", "through", "*/", "/*", "(whether", "we", "skipped", "them", "or", "not)", "*/", "bt2_udata", "->", "count", "++", ";", "/*", "Check", "for", "callback", "failure", "and", "pass", "along", "return", "value", "*/", "if", "(", "ret_value", "<", "0", ")", "HERROR", "(", "H5E_ATTR", ",", "H5E_CANTNEXT", ",", "\"iteration", "operator", "failed\"", ")", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "v2", "Btree", "'modify'", "callback", "to", "update", "the", "data", "for", "an", "attribute" ]

[ "'static", "herr_t", "H5A__dense_write_bt2_cb", "(", "void", "*", "_record", ",", "void", "*", "_op_data", ",", "hbool_t", "*", "changed", ")", "{", "H5A_dense_bt2_name_rec_t", "*", "record", "=", "(", "H5A_dense_bt2_name_rec_t", "*", ")", "_record", ";", "/*", "Record", "from", "B-tree", "*/", "H5A_bt2_od_wrt_t", "*", "op_data", "=", "(", "H5A_bt2_od_wrt_t", "*", ")", "_op_data", ";", "/*", "\"op", "data\"", "from", "v2", "B-tree", "modify", "*/", "H5B2_t", "*", "bt2_corder", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "creation", "order", "index", "*/", "H5WB_t", "*", "wb", "=", "NULL", ";", "/*", "Wrapped", "buffer", "for", "attribute", "data", "*/", "uint8_t", "attr_buf", "[", "H5A_ATTR_BUF_SIZE", "]", ";", "/*", "Buffer", "for", "serializing", "attribute", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "Check", "arguments", "*/", "HDassert", "(", "record", ")", ";", "HDassert", "(", "op_data", ")", ";", "/*", "Check", "for", "modifying", "shared", "attribute", "*/", "if", "(", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", "{", "/*", "Update", "the", "shared", "attribute", "in", "the", "SOHM", "info", "*/", "if", "(", "H5O_attr_update_shared", "(", "op_data", "->", "f", ",", "op_data", "->", "dxpl_id", ",", "NULL", ",", "op_data", "->", "attr", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTUPDATE", ",", "FAIL", ",", "\"unable", "to", "update", "attribute", "in", "shared", "storage\"", ")", "/*", "Update", "record\\'s", "heap", "ID", "*/", "record", "->", "id", "=", "op_data", "->", "attr", "->", "sh_loc", ".", "u", ".", "heap_id", ";", "/*", "Check", "if", "we", "need", "to", "modify", "the", "creation", "order", "index", "with", "new", "heap", "ID", "*/", "if", "(", "H5F_addr_defined", "(", "op_data", "->", "corder_bt2_addr", ")", ")", "{", "H5A_bt2_ud_common_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "modify", "*/", "/*", "Open", "the", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_corder", "=", "H5B2_open", "(", "op_data", "->", "f", ",", "op_data", "->", "dxpl_id", ",", "op_data", "->", "corder_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "/*", "Create", "the", "\"udata\"", "information", "for", "v2", "B-tree", "record", "modify", "*/", "udata", ".", "f", "=", "op_data", "->", "f", ";", "udata", ".", "dxpl_id", "=", "op_data", "->", "dxpl_id", ";", "udata", ".", "fheap", "=", "NULL", ";", "udata", ".", "shared_fheap", "=", "NULL", ";", "udata", ".", "name", "=", "NULL", ";", "udata", ".", "name_hash", "=", "0", ";", "udata", ".", "flags", "=", "0", ";", "udata", ".", "corder", "=", "op_data", "->", "attr", "->", "shared", "->", "crt_idx", ";", "udata", ".", "found_op", "=", "NULL", ";", "udata", ".", "found_op_data", "=", "NULL", ";", "/*", "Modify", "record", "for", "creation", "order", "index", "*/", "if", "(", "H5B2_modify", "(", "bt2_corder", ",", "op_data", "->", "dxpl_id", ",", "&", "udata", ",", "H5A__dense_write_bt2_cb2", ",", "&", "op_data", "->", "attr", "->", "sh_loc", ".", "u", ".", "heap_id", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINSERT", ",", "FAIL", ",", "\"unable", "to", "modify", "record", "in", "v2", "B-tree\"", ")", "}", "/*", "end", "if", "*/", "/*", "Note", "that", "the", "record", "changed", "*/", "*", "changed", "=", "TRUE", ";", "}", "/*", "end", "if", "*/", "else", "{", "void", "*", "attr_ptr", ";", "/*", "Pointer", "to", "serialized", "message", "*/", "size_t", "attr_size", ";", "/*", "Size", "of", "serialized", "attribute", "in", "the", "heap", "*/", "/*", "Find", "out", "the", "size", "of", "buffer", "needed", "for", "serialized", "attribute", "*/", "if", "(", "(", "attr_size", "=", "H5O_msg_raw_size", "(", "op_data", "->", "f", ",", "H5O_ATTR_ID", ",", "FALSE", ",", "op_data", "->", "attr", ")", ")", "==", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGETSIZE", ",", "FAIL", ",", "\"can\\'t", "get", "attribute", "size\"", ")", "/*", "Wrap", "the", "local", "buffer", "for", "serialized", "attributes", "*/", "if", "(", "NULL", "==", "(", "wb", "=", "H5WB_wrap", "(", "attr_buf", ",", "sizeof", "(", "attr_buf", ")", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTINIT", ",", "FAIL", ",", "\"can\\'t", "wrap", "buffer\"", ")", "/*", "Get", "a", "pointer", "to", "a", "buffer", "that\\'s", "large", "enough", "for", "attribute", "*/", "if", "(", "NULL", "==", "(", "attr_ptr", "=", "H5WB_actual", "(", "wb", ",", "attr_size", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOSPACE", ",", "FAIL", ",", "\"can\\'t", "get", "actual", "buffer\"", ")", "/*", "Create", "serialized", "form", "of", "attribute", "*/", "if", "(", "H5O_msg_encode", "(", "op_data", "->", "f", ",", "H5O_ATTR_ID", ",", "FALSE", ",", "(", "unsigned", "char", "*", ")", "attr_ptr", ",", "op_data", "->", "attr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTENCODE", ",", "FAIL", ",", "\"can\\'t", "encode", "attribute\"", ")", "/*", "Sanity", "check", "*/", "#", "ifndef", "NDEBUG", "{", "size_t", "obj_len", ";", "/*", "Length", "of", "existing", "encoded", "attribute", "*/", "if", "(", "H5HF_get_obj_len", "(", "op_data", "->", "fheap", ",", "op_data", "->", "dxpl_id", ",", "&", "record", "->", "id", ",", "&", "obj_len", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGETSIZE", ",", "FAIL", ",", "\"can\\'t", "get", "object", "size\"", ")", "HDassert", "(", "obj_len", "==", "attr_size", ")", ";", "}", "#", "endif", "/*", "NDEBUG", "*/", "/*", "Update", "existing", "attribute", "in", "heap", "*/", "/*", "(might", "be", "more", "efficient", "as", "fractal", "heap", "\\'op\\'", "callback,", "but", "leave", "that", "for", "later", "-QAK)", "*/", "if", "(", "H5HF_write", "(", "op_data", "->", "fheap", ",", "op_data", "->", "dxpl_id", ",", "&", "record", "->", "id", ",", "changed", ",", "attr_ptr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTUPDATE", ",", "FAIL", ",", "\"unable", "to", "update", "attribute", "in", "heap\"", ")", "}", "/*", "end", "else", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "bt2_corder", "&&", "H5B2_close", "(", "bt2_corder", ",", "op_data", "->", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "if", "(", "wb", "&&", "H5WB_unwrap", "(", "wb", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "wrapped", "buffer\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Delete", "all", "dense", "storage", "structures", "for", "attributes", "on", "an", "object" ]

[ "'herr_t", "H5A_dense_delete", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "H5O_ainfo_t", "*", "ainfo", ")", "{", "H5A_bt2_ud_common_t", "udata", ";", "/*", "v2", "B-tree", "user", "data", "for", "deleting", "attributes", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Create", "the", "\"udata\"", "information", "for", "v2", "B-tree", "\\'delete\\'", "*/", "udata", ".", "f", "=", "f", ";", "udata", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "fheap", "=", "fheap", ";", "udata", ".", "shared_fheap", "=", "NULL", ";", "udata", ".", "name", "=", "NULL", ";", "udata", ".", "name_hash", "=", "0", ";", "udata", ".", "flags", "=", "0", ";", "udata", ".", "found_op", "=", "NULL", ";", "/*", "v2", "B-tree", "comparison", "callback", "*/", "udata", ".", "found_op_data", "=", "NULL", ";", "/*", "Delete", "name", "index", "v2", "B-tree", "*/", "if", "(", "H5B2_delete", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "name_bt2_addr", ",", "NULL", ",", "H5A__dense_delete_bt2_cb", ",", "&", "udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "v2", "B-tree", "for", "name", "index\"", ")", "ainfo", "->", "name_bt2_addr", "=", "HADDR_UNDEF", ";", "/*", "Release", "resources", "*/", "if", "(", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "fheap", "=", "NULL", ";", "/*", "Check", "if", "we", "should", "delete", "the", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "H5F_addr_defined", "(", "ainfo", "->", "corder_bt2_addr", ")", ")", "{", "/*", "Delete", "the", "creation", "order", "index,", "without", "adjusting", "the", "ref.", "count", "on", "the", "attributes", "*/", "if", "(", "H5B2_delete", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "corder_bt2_addr", ",", "NULL", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "ainfo", "->", "corder_bt2_addr", "=", "HADDR_UNDEF", ";", "}", "/*", "end", "if", "*/", "/*", "Delete", "fractal", "heap", "*/", "if", "(", "H5HF_delete", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "fractal", "heap\"", ")", "ainfo", "->", "fheap_addr", "=", "HADDR_UNDEF", ";", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Callback", "when", "an", "attribute", "is", "located", "in", "an", "index" ]

[ "'static", "herr_t", "H5A__dense_fnd_cb", "(", "const", "H5A_t", "*", "attr", ",", "hbool_t", "*", "took_ownership", ",", "void", "*", "_user_attr", ")", "{", "H5A_t", "const", "*", "*", "user_attr", "=", "(", "H5A_t", "const", "*", "*", ")", "_user_attr", ";", "/*", "User", "data", "from", "v2", "B-tree", "attribute", "lookup", "*/", "FUNC_ENTER_STATIC_NOERR", "/*", "*", "Check", "arguments.", "*/", "HDassert", "(", "attr", ")", ";", "HDassert", "(", "user_attr", ")", ";", "/*", "Take", "over", "attribute", "ownership", "*/", "*", "user_attr", "=", "attr", ";", "*", "took_ownership", "=", "TRUE", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "v2", "Btree", "callback", "for", "dense", "attribute", "storage", "record", "removal" ]

[ "'static", "herr_t", "H5A__dense_remove_bt2_cb", "(", "const", "void", "*", "_record", ",", "void", "*", "_udata", ")", "{", "const", "H5A_dense_bt2_name_rec_t", "*", "record", "=", "(", "const", "H5A_dense_bt2_name_rec_t", "*", ")", "_record", ";", "H5A_bt2_ud_rm_t", "*", "udata", "=", "(", "H5A_bt2_ud_rm_t", "*", ")", "_udata", ";", "/*", "User", "data", "for", "callback", "*/", "H5A_t", "*", "attr", "=", "*", "(", "H5A_t", "*", "*", ")", "udata", "->", "common", ".", "found_op_data", ";", "/*", "Pointer", "to", "attribute", "to", "remove", "*/", "H5B2_t", "*", "bt2_corder", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "creation", "order", "index", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "Check", "for", "removing", "the", "link", "from", "the", "creation", "order", "index", "*/", "if", "(", "H5F_addr_defined", "(", "udata", "->", "corder_bt2_addr", ")", ")", "{", "/*", "Open", "the", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_corder", "=", "H5B2_open", "(", "udata", "->", "common", ".", "f", ",", "udata", "->", "common", ".", "dxpl_id", ",", "udata", "->", "corder_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "/*", "Set", "up", "the", "user", "data", "for", "the", "v2", "B-tree", "\\'record", "remove\\'", "callback", "*/", "udata", "->", "common", ".", "corder", "=", "attr", "->", "shared", "->", "crt_idx", ";", "/*", "Remove", "the", "record", "from", "the", "creation", "order", "index", "v2", "B-tree", "*/", "if", "(", "H5B2_remove", "(", "bt2_corder", ",", "udata", "->", "common", ".", "dxpl_id", ",", "udata", ",", "NULL", ",", "NULL", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTREMOVE", ",", "FAIL", ",", "\"unable", "to", "remove", "attribute", "from", "creation", "order", "index", "v2", "B-tree\"", ")", "}", "/*", "end", "if", "*/", "/*", "Check", "for", "removing", "shared", "attribute", "*/", "if", "(", "record", "->", "flags", "&", "H5O_MSG_FLAG_SHARED", ")", "{", "/*", "Decrement", "the", "reference", "count", "on", "the", "shared", "attribute", "message", "*/", "if", "(", "H5SM_delete", "(", "udata", "->", "common", ".", "f", ",", "udata", "->", "common", ".", "dxpl_id", ",", "NULL", ",", "&", "(", "attr", "->", "sh_loc", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "delete", "shared", "attribute\"", ")", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Perform", "the", "deletion", "action", "on", "the", "attribute", "*/", "/*", "(takes", "care", "of", "shared", "&", "committed", "datatype/dataspace", "components)", "*/", "if", "(", "H5O_attr_delete", "(", "udata", "->", "common", ".", "f", ",", "udata", "->", "common", ".", "dxpl_id", ",", "NULL", ",", "attr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "attribute\"", ")", "/*", "Remove", "record", "from", "fractal", "heap", "*/", "if", "(", "H5HF_remove", "(", "udata", "->", "common", ".", "fheap", ",", "udata", "->", "common", ".", "dxpl_id", ",", "&", "record", "->", "id", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTREMOVE", ",", "FAIL", ",", "\"unable", "to", "remove", "attribute", "from", "fractal", "heap\"", ")", "}", "/*", "end", "else", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "bt2_corder", "&&", "H5B2_close", "(", "bt2_corder", ",", "udata", "->", "common", ".", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "creation", "order", "index\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Remove", "an", "attribute", "from", "the", "dense", "storage", "of", "an", "object,", "according", "to", "the", "order", "within", "an", "index" ]

[ "'herr_t", "H5A_dense_remove_by_idx", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "H5_index_t", "idx_type", ",", "H5_iter_order_t", "order", ",", "hsize_t", "n", ")", "{", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5A_attr_table_t", "atable", "=", "{", "0", ",", "NULL", "}", ";", "/*", "Table", "of", "attributes", "*/", "H5B2_t", "*", "bt2", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "index", "*/", "haddr_t", "bt2_addr", ";", "/*", "Address", "of", "v2", "B-tree", "to", "use", "for", "operation", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "/*", "Determine", "the", "address", "of", "the", "index", "to", "use", "*/", "if", "(", "idx_type", "==", "H5_INDEX_NAME", ")", "{", "/*", "Check", "if", "\"native\"", "order", "is", "OK", "-", "since", "names", "are", "hashed,", "getting", "them", "*", "in", "strictly", "increasing", "or", "decreasing", "order", "requires", "building", "a", "*", "table", "and", "sorting", "it.", "*/", "if", "(", "order", "==", "H5_ITER_NATIVE", ")", "{", "bt2_addr", "=", "ainfo", "->", "name_bt2_addr", ";", "HDassert", "(", "H5F_addr_defined", "(", "bt2_addr", ")", ")", ";", "}", "/*", "end", "if", "*/", "else", "bt2_addr", "=", "HADDR_UNDEF", ";", "}", "/*", "end", "if", "*/", "else", "{", "HDassert", "(", "idx_type", "==", "H5_INDEX_CRT_ORDER", ")", ";", "/*", "This", "address", "may", "not", "be", "defined", "if", "creation", "order", "is", "tracked,", "but", "*", "there\\'s", "no", "index", "on", "it.", "If", "there\\'s", "no", "v2", "B-tree", "that", "indexes", "*", "the", "links,", "a", "table", "will", "be", "built.", "*/", "bt2_addr", "=", "ainfo", "->", "corder_bt2_addr", ";", "}", "/*", "end", "else", "*/", "/*", "If", "there", "is", "an", "index", "defined", "for", "the", "field,", "use", "it", "*/", "if", "(", "H5F_addr_defined", "(", "bt2_addr", ")", ")", "{", "H5A_bt2_ud_rmbi_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "record", "removal", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "index\"", ")", "/*", "Set", "up", "the", "user", "data", "for", "the", "v2", "B-tree", "\\'record", "remove\\'", "callback", "*/", "udata", ".", "f", "=", "f", ";", "udata", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "fheap", "=", "fheap", ";", "udata", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "idx_type", "=", "idx_type", ";", "udata", ".", "other_bt2_addr", "=", "idx_type", "==", "H5_INDEX_NAME", "?", "ainfo", "->", "corder_bt2_addr", ":", "ainfo", "->", "name_bt2_addr", ";", "/*", "Remove", "the", "record", "from", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "H5B2_remove_by_idx", "(", "bt2", ",", "dxpl_id", ",", "order", ",", "n", ",", "H5A__dense_remove_by_idx_bt2_cb", ",", "&", "udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTREMOVE", ",", "FAIL", ",", "\"unable", "to", "remove", "attribute", "from", "v2", "B-tree", "index\"", ")", "}", "/*", "end", "if", "*/", "else", "{", "/*", "Build", "the", "table", "of", "attributes", "for", "this", "object", "*/", "/*", "(build", "table", "using", "the", "name", "index,", "but", "sort", "according", "to", "idx_type)", "*/", "if", "(", "H5A_dense_build_table", "(", "f", ",", "dxpl_id", ",", "ainfo", ",", "idx_type", ",", "order", ",", "&", "atable", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"error", "building", "table", "of", "attributes\"", ")", "/*", "Check", "for", "skipping", "too", "many", "attributes", "*/", "if", "(", "n", ">=", "atable", ".", "nattrs", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"invalid", "index", "specified\"", ")", "/*", "Delete", "appropriate", "attribute", "from", "dense", "storage", "*/", "if", "(", "H5A_dense_remove", "(", "f", ",", "dxpl_id", ",", "ainfo", ",", "(", "(", "atable", ".", "attrs", "[", "n", "]", ")", "->", "shared", ")", "->", "name", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTDELETE", ",", "FAIL", ",", "\"unable", "to", "delete", "attribute", "in", "dense", "storage\"", ")", "}", "/*", "end", "else", "*/", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2", "&&", "H5B2_close", "(", "bt2", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "index\"", ")", "if", "(", "atable", ".", "attrs", "&&", "H5A_attr_release_table", "(", "&", "atable", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTFREE", ",", "FAIL", ",", "\"unable", "to", "release", "attribute", "table\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Open", "an", "attribute", "in", "dense", "storage", "structures", "for", "an", "object" ]

[ "'H5A_t", "*", "H5A_dense_open", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "const", "char", "*", "name", ")", "{", "H5A_bt2_ud_common_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "modify", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5B2_t", "*", "bt2_name", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "name", "index", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "htri_t", "attr_exists", ";", "/*", "Attribute", "exists", "in", "v2", "B-tree", "*/", "H5A_t", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "NULL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "HDassert", "(", "name", ")", ";", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "NULL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "NULL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "NULL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "NULL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_name", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "name_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "NULL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "name", "index\"", ")", "/*", "Create", "the", "\"udata\"", "information", "for", "v2", "B-tree", "record", "find", "*/", "udata", ".", "f", "=", "f", ";", "udata", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "fheap", "=", "fheap", ";", "udata", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "name", "=", "name", ";", "udata", ".", "name_hash", "=", "H5_checksum_lookup3", "(", "name", ",", "HDstrlen", "(", "name", ")", ",", "0", ")", ";", "udata", ".", "flags", "=", "0", ";", "udata", ".", "corder", "=", "0", ";", "udata", ".", "found_op", "=", "H5A__dense_fnd_cb", ";", "/*", "v2", "B-tree", "comparison", "callback", "*/", "udata", ".", "found_op_data", "=", "&", "ret_value", ";", "/*", "Find", "&", "copy", "the", "attribute", "in", "the", "\\'name\\'", "index", "*/", "if", "(", "(", "attr_exists", "=", "H5B2_find", "(", "bt2_name", ",", "dxpl_id", ",", "&", "udata", ",", "NULL", ",", "NULL", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOTFOUND", ",", "NULL", ",", "\"can\\'t", "search", "for", "attribute", "in", "name", "index\"", ")", "<if", "type=\"elseif\">", "else", "if", "(", "attr_exists", "==", "FALSE", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_NOTFOUND", ",", "NULL", ",", "\"can\\'t", "locate", "attribute", "in", "name", "index\"", ")", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2_name", "&&", "H5B2_close", "(", "bt2_name", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "NULL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "name", "index\"", ")", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Remove", "an", "attribute", "from", "the", "dense", "storage", "of", "an", "object" ]

[ "'herr_t", "H5A_dense_remove", "(", "H5F_t", "*", "f", ",", "hid_t", "dxpl_id", ",", "const", "H5O_ainfo_t", "*", "ainfo", ",", "const", "char", "*", "name", ")", "{", "H5A_bt2_ud_rm_t", "udata", ";", "/*", "User", "data", "for", "v2", "B-tree", "record", "removal", "*/", "H5HF_t", "*", "fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "*/", "H5HF_t", "*", "shared_fheap", "=", "NULL", ";", "/*", "Fractal", "heap", "handle", "for", "shared", "header", "messages", "*/", "H5B2_t", "*", "bt2_name", "=", "NULL", ";", "/*", "v2", "B-tree", "handle", "for", "name", "index", "*/", "H5A_t", "*", "attr_copy", "=", "NULL", ";", "/*", "Copy", "of", "attribute", "to", "remove", "*/", "htri_t", "attr_sharable", ";", "/*", "Flag", "indicating", "attributes", "are", "sharable", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI", "(", "FAIL", ")", "/*", "Check", "arguments", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "ainfo", ")", ";", "HDassert", "(", "name", "&&", "*", "name", ")", ";", "/*", "Open", "the", "fractal", "heap", "*/", "if", "(", "NULL", "==", "(", "fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "/*", "Check", "if", "attributes", "are", "shared", "in", "this", "file", "*/", "if", "(", "(", "attr_sharable", "=", "H5SM_type_shared", "(", "f", ",", "H5O_ATTR_ID", ",", "dxpl_id", ")", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "determine", "if", "attributes", "are", "shared\"", ")", "/*", "Get", "handle", "for", "shared", "message", "heap,", "if", "attributes", "are", "sharable", "*/", "if", "(", "attr_sharable", ")", "{", "haddr_t", "shared_fheap_addr", ";", "/*", "Address", "of", "fractal", "heap", "to", "use", "*/", "/*", "Retrieve", "the", "address", "of", "the", "shared", "message\\'s", "fractal", "heap", "*/", "if", "(", "H5SM_get_fheap_addr", "(", "f", ",", "dxpl_id", ",", "H5O_ATTR_ID", ",", "&", "shared_fheap_addr", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "shared", "message", "heap", "address\"", ")", "/*", "Check", "if", "there", "are", "any", "shared", "messages", "currently", "*/", "if", "(", "H5F_addr_defined", "(", "shared_fheap_addr", ")", ")", "{", "/*", "Open", "the", "fractal", "heap", "for", "shared", "header", "messages", "*/", "if", "(", "NULL", "==", "(", "shared_fheap", "=", "H5HF_open", "(", "f", ",", "dxpl_id", ",", "shared_fheap_addr", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "fractal", "heap\"", ")", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "/*", "Open", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "NULL", "==", "(", "bt2_name", "=", "H5B2_open", "(", "f", ",", "dxpl_id", ",", "ainfo", "->", "name_bt2_addr", ",", "NULL", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTOPENOBJ", ",", "FAIL", ",", "\"unable", "to", "open", "v2", "B-tree", "for", "name", "index\"", ")", "/*", "Set", "up", "the", "user", "data", "for", "the", "v2", "B-tree", "\\'record", "remove\\'", "callback", "*/", "udata", ".", "common", ".", "f", "=", "f", ";", "udata", ".", "common", ".", "dxpl_id", "=", "dxpl_id", ";", "udata", ".", "common", ".", "fheap", "=", "fheap", ";", "udata", ".", "common", ".", "shared_fheap", "=", "shared_fheap", ";", "udata", ".", "common", ".", "name", "=", "name", ";", "udata", ".", "common", ".", "name_hash", "=", "H5_checksum_lookup3", "(", "name", ",", "HDstrlen", "(", "name", ")", ",", "0", ")", ";", "udata", ".", "common", ".", "found_op", "=", "H5A__dense_fnd_cb", ";", "/*", "v2", "B-tree", "comparison", "callback", "*/", "udata", ".", "common", ".", "found_op_data", "=", "&", "attr_copy", ";", "udata", ".", "corder_bt2_addr", "=", "ainfo", "->", "corder_bt2_addr", ";", "/*", "Remove", "the", "record", "from", "the", "name", "index", "v2", "B-tree", "*/", "if", "(", "H5B2_remove", "(", "bt2_name", ",", "dxpl_id", ",", "&", "udata", ",", "H5A__dense_remove_bt2_cb", ",", "&", "udata", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_ATTR", ",", "H5E_CANTREMOVE", ",", "FAIL", ",", "\"unable", "to", "remove", "attribute", "from", "name", "index", "v2", "B-tree\"", ")", "done", ":", "/*", "Release", "resources", "*/", "if", "(", "shared_fheap", "&&", "H5HF_close", "(", "shared_fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "fheap", "&&", "H5HF_close", "(", "fheap", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "fractal", "heap\"", ")", "if", "(", "bt2_name", "&&", "H5B2_close", "(", "bt2_name", ",", "dxpl_id", ")", "<", "0", ")", "HDONE_ERROR", "(", "H5E_ATTR", ",", "H5E_CLOSEERROR", ",", "FAIL", ",", "\"can\\'t", "close", "v2", "B-tree", "for", "name", "index\"", ")", "if", "(", "attr_copy", ")", "H5O_msg_free_real", "(", "H5O_MSG_ATTR", ",", "attr_copy", ")", ";", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Select", "specified", "widget", "in", "it's", "owner" ]

[ "'void", "widget_select", "(", "Widget", "*", "w", ")", "{", "WGroup", "*", "g", ";", "if", "(", "!", "widget_get_options", "(", "w", ",", "WOP_SELECTABLE", ")", ")", "return", ";", "g", "=", "GROUP", "(", "w", "->", "owner", ")", ";", "if", "(", "g", "!=", "NULL", ")", "{", "if", "(", "widget_get_options", "(", "w", ",", "WOP_TOP_SELECT", ")", ")", "{", "GList", "*", "l", ";", "l", "=", "widget_find", "(", "WIDGET", "(", "g", ")", ",", "w", ")", ";", "widget_reorder", "(", "l", ",", "TRUE", ")", ";", "}", "widget_focus", "(", "w", ")", ";", "}", "}'" ]

[ "Apply", "new", "options", "to", "widget" ]

[ "'void", "widget_set_options", "(", "Widget", "*", "w", ",", "widget_options_t", "options", ",", "gboolean", "enable", ")", "{", "if", "(", "enable", ")", "w", "->", "options", "|=", "options", ";", "else", "w", "->", "options", "&=", "~", "options", ";", "}'" ]

[ "Default", "callback", "function", "to", "modify", "state", "of", "widget" ]

[ "'cb_ret_t", "widget_default_set_state", "(", "Widget", "*", "w", ",", "widget_state_t", "state", ",", "gboolean", "enable", ")", "{", "gboolean", "ret", "=", "MSG_HANDLED", ";", "if", "(", "enable", ")", "w", "->", "state", "|=", "state", ";", "else", "w", "->", "state", "&=", "~", "state", ";", "if", "(", "enable", ")", "{", "/*", "exclusive", "bits", "*/", "if", "(", "(", "state", "&", "WST_CONSTRUCT", ")", "!=", "0", ")", "w", "->", "state", "&=", "~", "(", "WST_ACTIVE", "|", "WST_SUSPENDED", "|", "WST_CLOSED", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "(", "state", "&", "WST_ACTIVE", ")", "!=", "0", ")", "w", "->", "state", "&=", "~", "(", "WST_CONSTRUCT", "|", "WST_SUSPENDED", "|", "WST_CLOSED", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "(", "state", "&", "WST_SUSPENDED", ")", "!=", "0", ")", "w", "->", "state", "&=", "~", "(", "WST_CONSTRUCT", "|", "WST_ACTIVE", "|", "WST_CLOSED", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "(", "state", "&", "WST_CLOSED", ")", "!=", "0", ")", "w", "->", "state", "&=", "~", "(", "WST_CONSTRUCT", "|", "WST_ACTIVE", "|", "WST_SUSPENDED", ")", ";", "}", "if", "(", "w", "->", "owner", "==", "NULL", ")", "return", "MSG_NOT_HANDLED", ";", "switch", "(", "state", ")", "{", "case", "WST_DISABLED", ":", "ret", "=", "send_message", "(", "w", ",", "NULL", ",", "enable", "?", "MSG_DISABLE", ":", "MSG_ENABLE", ",", "0", ",", "NULL", ")", ";", "if", "(", "ret", "==", "MSG_HANDLED", "&&", "widget_get_state", "(", "WIDGET", "(", "w", "->", "owner", ")", ",", "WST_ACTIVE", ")", ")", "ret", "=", "widget_draw", "(", "w", ")", ";", "break;", "case", "WST_FOCUSED", ":", "{", "widget_msg_t", "msg", ";", "msg", "=", "enable", "?", "MSG_FOCUS", ":", "MSG_UNFOCUS", ";", "ret", "=", "send_message", "(", "w", ",", "NULL", ",", "msg", ",", "0", ",", "NULL", ")", ";", "if", "(", "ret", "==", "MSG_HANDLED", "&&", "widget_get_state", "(", "WIDGET", "(", "w", "->", "owner", ")", ",", "WST_ACTIVE", ")", ")", "{", "widget_draw", "(", "w", ")", ";", "/*", "Notify", "owner", "that", "focus", "was", "moved", "from", "one", "widget", "to", "another", "*/", "send_message", "(", "w", "->", "owner", ",", "w", ",", "MSG_CHANGED_FOCUS", ",", "0", ",", "NULL", ")", ";", "}", "}", "break;", "default:", "break;", "}", "return", "ret", ";", "}'" ]

[ "Change", "widget", "position", "and", "size" ]

[ "'void", "widget_set_size", "(", "Widget", "*", "w", ",", "int", "y", ",", "int", "x", ",", "int", "lines", ",", "int", "cols", ")", "{", "WRect", "r", "=", "{", "y", ",", "x", ",", "lines", ",", "cols", "}", ";", "send_message", "(", "w", ",", "NULL", ",", "MSG_RESIZE", ",", "0", ",", "&", "r", ")", ";", "if", "(", "w", "->", "owner", "!=", "NULL", "&&", "widget_get_state", "(", "WIDGET", "(", "w", "->", "owner", ")", ",", "WST_ACTIVE", ")", ")", "widget_draw", "(", "w", ")", ";", "}'" ]

[ "Replace", "widget", "in", "the", "dialog" ]

[ "\"void", "widget_replace", "(", "Widget", "*", "old_w", ",", "Widget", "*", "new_w", ")", "{", "WGroup", "*", "g", "=", "old_w", "->", "owner", ";", "gboolean", "should_focus", "=", "FALSE", ";", "GList", "*", "holder", ";", "if", "(", "g", "->", "widgets", "==", "NULL", ")", "return", ";", "if", "(", "g", "->", "current", "==", "NULL", ")", "g", "->", "current", "=", "g", "->", "widgets", ";", "/*", "locate", "widget", "position", "in", "the", "list", "*/", "if", "(", "old_w", "==", "g", "->", "current", "->", "data", ")", "holder", "=", "g", "->", "current", ";", "else", "holder", "=", "g_list_find", "(", "g", "->", "widgets", ",", "old_w", ")", ";", "/*", "if", "old", "widget", "is", "focused,", "we", "should", "focus", "the", "new", "one...", "*/", "if", "(", "widget_get_state", "(", "old_w", ",", "WST_FOCUSED", ")", ")", "should_focus", "=", "TRUE", ";", "/*", "...but", "if", "new", "widget", "isn't", "selectable,", "we", "cannot", "focus", "it", "*/", "if", "(", "!", "widget_get_options", "(", "new_w", ",", "WOP_SELECTABLE", ")", ")", "should_focus", "=", "FALSE", ";", "/*", "if", "new", "widget", "isn't", "selectable,", "select", "other", "widget", "before", "replace", "*/", "if", "(", "!", "should_focus", ")", "{", "GList", "*", "l", ";", "for", "(", "l", "=", "group_get_widget_next_of", "(", "holder", ")", ";", "!", "widget_get_options", "(", "WIDGET", "(", "l", "->", "data", ")", ",", "WOP_SELECTABLE", ")", "&&", "!", "widget_get_state", "(", "WIDGET", "(", "l", "->", "data", ")", ",", "WST_DISABLED", ")", ";", "l", "=", "group_get_widget_next_of", "(", "l", ")", ")", ";", "widget_select", "(", "WIDGET", "(", "l", "->", "data", ")", ")", ";", "}", "/*", "replace", "widget", "*/", "new_w", "->", "owner", "=", "g", ";", "new_w", "->", "id", "=", "old_w", "->", "id", ";", "holder", "->", "data", "=", "new_w", ";", "send_message", "(", "old_w", ",", "NULL", ",", "MSG_DESTROY", ",", "0", ",", "NULL", ")", ";", "send_message", "(", "new_w", ",", "NULL", ",", "MSG_INIT", ",", "0", ",", "NULL", ")", ";", "if", "(", "should_focus", ")", "widget_select", "(", "new_w", ")", ";", "else", "widget_draw", "(", "new_w", ")", ";", "}\"" ]

[ "Focus", "specified", "widget", "in", "it's", "owner" ]

[ "'static", "void", "widget_focus", "(", "Widget", "*", "w", ")", "{", "WGroup", "*", "g", "=", "w", "->", "owner", ";", "if", "(", "g", "==", "NULL", ")", "return", ";", "if", "(", "WIDGET", "(", "g", "->", "current", "->", "data", ")", "!=", "w", ")", "{", "widget_do_focus", "(", "WIDGET", "(", "g", "->", "current", "->", "data", ")", ",", "FALSE", ")", ";", "/*", "Test", "if", "focus", "lost", "was", "allowed", "and", "focus", "has", "really", "been", "loose", "*/", "if", "(", "g", "->", "current", "==", "NULL", "||", "!", "widget_get_state", "(", "WIDGET", "(", "g", "->", "current", "->", "data", ")", ",", "WST_FOCUSED", ")", ")", "{", "widget_do_focus", "(", "w", ",", "TRUE", ")", ";", "g", "->", "current", "=", "widget_find", "(", "WIDGET", "(", "g", ")", ",", "w", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "widget_get_state", "(", "w", ",", "WST_FOCUSED", ")", ")", "widget_do_focus", "(", "w", ",", "TRUE", ")", ";", "}'" ]

[ "Default", "callback", "function", "to", "find", "widget" ]

[ "'GList", "*", "widget_default_find", "(", "const", "Widget", "*", "w", ",", "const", "Widget", "*", "what", ")", "{", "return", "(", "w", "!=", "what", "||", "w", "->", "owner", "==", "NULL", ")", "?", "NULL", ":", "g_list_find", "(", "CONST_GROUP", "(", "w", "->", "owner", ")", "->", "widgets", ",", "what", ")", ";", "}'" ]

[ "Look", "up", "key", "event", "of", "widget", "and", "translate", "it", "to", "command", "ID" ]

[ "'long", "widget_lookup_key", "(", "Widget", "*", "w", ",", "int", "key", ")", "{", "if", "(", "w", "->", "ext_mode", ")", "{", "w", "->", "ext_mode", "=", "FALSE", ";", "return", "keybind_lookup_keymap_command", "(", "w", "->", "ext_keymap", ",", "key", ")", ";", "}", "return", "keybind_lookup_keymap_command", "(", "w", "->", "keymap", ",", "key", ")", ";", "}'" ]

[ "Default", "callback", "function", "to", "find", "widget", "by", "widget", "ID" ]

[ "'Widget", "*", "widget_default_find_by_id", "(", "const", "Widget", "*", "w", ",", "unsigned", "long", "id", ")", "{", "return", "(", "w", "->", "id", "==", "id", "?", "WIDGET", "(", "w", ")", ":", "NULL", ")", ";", "}'" ]

[ "Check", "whether", "widget", "is", "active", "or", "not" ]

[ "'gboolean", "widget_is_active", "(", "const", "void", "*", "w", ")", "{", "const", "WGroup", "*", "owner", ";", "/*", "Is", "group", "top?", "*/", "if", "(", "w", "==", "top_dlg", "->", "data", ")", "return", "TRUE", ";", "owner", "=", "CONST_WIDGET", "(", "w", ")", "->", "owner", ";", "/*", "Is", "widget", "in", "any", "group?", "*/", "if", "(", "owner", "==", "NULL", ")", "return", "FALSE", ";", "if", "(", "w", "!=", "owner", "->", "current", "->", "data", ")", "return", "FALSE", ";", "return", "widget_is_active", "(", "owner", ")", ";", "}'" ]

[ "apply", "optimization", "passes", "to", "instructions", "captured", "in", "vEmulateAndCapture" ]

[ "'void", "runOptsOnCaptured", "(", "RContext", "*", "c", ")", "{", "Rewriter", "*", "r", "=", "c", "->", "r", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "r", "->", "capBBCount", ";", "i", "++", ")", "{", "CBB", "*", "cbb", "=", "r", "->", "capBB", "+", "i", ";", "optPass", "(", "c", ",", "cbb", ")", ";", "if", "(", "c", "->", "e", ")", "return", ";", "}", "}'" ]

[ "assumes", "heights", "is", "allocated", "with", "hmm>M", "floats" ]

[ "'int", "hmmlogo_IndelValues", "(", "P7_HMM", "*", "hmm", ",", "float", "*", "insert_P", ",", "float", "*", "insert_expL", ",", "float", "*", "occupancy", ")", "{", "int", "i", ";", "if", "(", "insert_P", "!=", "NULL", ")", "insert_P", "[", "1", "]", "=", "hmm", "->", "t", "[", "1", "]", "[", "p7H_MI", "]", ";", "//probability", "of", "inserting", "after", "this", "match", "if", "(", "insert_expL", "!=", "NULL", ")", "insert_expL", "[", "1", "]", "=", "1", "/", "(", "1", "-", "hmm", "->", "t", "[", "1", "]", "[", "p7H_II", "]", ")", ";", "//expected", "length", "of", "the", "insert,", "if", "it", "happens", "//", "if", "(delete_P", "!=", "NULL)", "delete_P[1]", "=", "0.0;", "//1st", "match", "state", "never", "deleted", "for", "(", "i", "=", "2", ";", "i", "<", "hmm", "->", "M", ";", "i", "++", ")", "{", "if", "(", "insert_P", "!=", "NULL", ")", "insert_P", "[", "i", "]", "=", "hmm", "->", "t", "[", "i", "]", "[", "p7H_MI", "]", ";", "//probability", "of", "inserting", "after", "this", "match", "if", "(", "insert_expL", "!=", "NULL", ")", "insert_expL", "[", "i", "]", "=", "1", "/", "(", "1", "-", "hmm", "->", "t", "[", "i", "]", "[", "p7H_II", "]", ")", ";", "//expected", "length", "of", "the", "insert,", "if", "it", "happens", "//", "if", "(delete_P", "!=", "NULL)", "delete_P[i]", "=", "(", "(1.0-delete_P[i-1])", "*", "hmm->t[i-1][p7H_MD]", ")", "+", "(", "delete_P[i-1]", "*", "hmm->t[i-1][p7H_DD])", ";", "//probability", "of", "missing", "this", "state,", "either", "due", "to", "DD", "or", "MD", "from", "previous", "position", "}", "if", "(", "insert_P", "!=", "NULL", ")", "insert_P", "[", "hmm", "->", "M", "]", "=", "0.0", ";", "//no", "inserts", "after", "final", "position", "if", "(", "insert_expL", "!=", "NULL", ")", "insert_expL", "[", "hmm", "->", "M", "]", "=", "0.0", ";", "//no", "inserts", "after", "final", "position", "//", "if", "(delete_P", "!=", "NULL)", "delete_P[hmm->M]", "=", "(", "(1.0-delete_P[hmm->M-1])", "*", "hmm->t[hmm->M-1][p7H_MD]", ")", "+", "(", "delete_P[hmm->M-1]", "*", "hmm->t[hmm->M-1][p7H_DD])", ";", "//probability", "of", "missing", "this", "state,", "either", "due", "to", "DD", "or", "MD", "from", "previous", "position", "if", "(", "occupancy", "!=", "NULL", ")", "p7_hmm_CalculateOccupancy", "(", "hmm", ",", "occupancy", ",", "NULL", ")", ";", "return", "eslOK", ";", "}'" ]