Datasets:

AISE-TUDelft

/

Capybara

like 2

Follow

AISE research lab at TU Delft 43

[ "assumes", "rel_ents", "is", "allocated", "with", "abc>K", "floats,", "and", "heights", "with", "hmm>Mabc>K", "floats" ]

[ "'int", "hmmlogo_RelativeEntropy_all", "(", "P7_HMM", "*", "hmm", ",", "P7_BG", "*", "bg", ",", "float", "*", "rel_ents", ",", "float", "*", "*", "probs", ",", "float", "*", "*", "heights", ")", "{", "int", "K", "=", "hmm", "->", "abc", "->", "K", ";", "int", "M", "=", "hmm", "->", "M", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "float", "logodds", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "M", ";", "i", "++", ")", "{", "//", "height", "of", "column,", "to", "be", "split", "among", "the", "residues", "rel_ents", "[", "i", "]", "=", "0", ";", "for", "(", "j", "=", "0", ";", "j", "<", "K", ";", "j", "++", ")", "{", "probs", "[", "i", "]", "[", "j", "]", "=", "hmm", "->", "mat", "[", "i", "]", "[", "j", "]", ";", "if", "(", "probs", "[", "i", "]", "[", "j", "]", ">", "0", ")", "{", "logodds", "=", "eslCONST_LOG2R", "*", "log", "(", "probs", "[", "i", "]", "[", "j", "]", "/", "bg", "->", "f", "[", "j", "]", ")", ";", "//bits", "rel_ents", "[", "i", "]", "+=", "probs", "[", "i", "]", "[", "j", "]", "*", "logodds", ";", "}", "}", "//", "height", "of", "residues", "for", "(", "j", "=", "0", ";", "j", "<", "K", ";", "j", "++", ")", "{", "heights", "[", "i", "]", "[", "j", "]", "=", "rel_ents", "[", "i", "]", "*", "probs", "[", "i", "]", "[", "j", "]", ";", "}", "}", "return", "eslOK", ";", "}'" ]

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

[ "'int", "hmmlogo_ScoreHeights", "(", "P7_HMM", "*", "hmm", ",", "P7_BG", "*", "bg", ",", "float", "*", "*", "heights", ")", "{", "int", "K", "=", "hmm", "->", "abc", "->", "K", ";", "int", "M", "=", "hmm", "->", "M", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "float", "p", ";", "float", "logodds", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "M", ";", "i", "++", ")", "{", "//", "height", "of", "column,", "to", "be", "split", "among", "the", "residues;", "also", "sum", "of", "of", "positive", "scores", "for", "(", "j", "=", "0", ";", "j", "<", "K", ";", "j", "++", ")", "{", "p", "=", "hmm", "->", "mat", "[", "i", "]", "[", "j", "]", ";", "logodds", "=", "eslCONST_LOG2R", "*", "log", "(", "p", "/", "bg", "->", "f", "[", "j", "]", ")", ";", "//bits", "heights", "[", "i", "]", "[", "j", "]", "=", "logodds", ";", "}", "}", "return", "eslOK", ";", "}'" ]

[ "assumes", "rel_ents", "is", "allocated", "with", "abc>K", "floats,", "and", "heights", "with", "hmm>Mabc>K", "floats" ]

[ "'int", "hmmlogo_RelativeEntropy_above_bg", "(", "P7_HMM", "*", "hmm", ",", "P7_BG", "*", "bg", ",", "float", "*", "rel_ents", ",", "float", "*", "*", "probs", ",", "float", "*", "*", "heights", ")", "{", "int", "K", "=", "hmm", "->", "abc", "->", "K", ";", "int", "M", "=", "hmm", "->", "M", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "float", "logodds", ";", "float", "abovebg_prob_sum", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "M", ";", "i", "++", ")", "{", "//", "height", "of", "column,", "to", "be", "split", "among", "the", "residues;", "also", "sum", "of", "of", "positive", "scores", "rel_ents", "[", "i", "]", "=", "0", ";", "abovebg_prob_sum", "=", "0.0", ";", "for", "(", "j", "=", "0", ";", "j", "<", "K", ";", "j", "++", ")", "{", "probs", "[", "i", "]", "[", "j", "]", "=", "hmm", "->", "mat", "[", "i", "]", "[", "j", "]", ";", "if", "(", "probs", "[", "i", "]", "[", "j", "]", ">", "0", ")", "{", "logodds", "=", "eslCONST_LOG2R", "*", "log", "(", "probs", "[", "i", "]", "[", "j", "]", "/", "bg", "->", "f", "[", "j", "]", ")", ";", "//bits", "rel_ents", "[", "i", "]", "+=", "probs", "[", "i", "]", "[", "j", "]", "*", "logodds", ";", "if", "(", "logodds", ">", "0", ")", "abovebg_prob_sum", "+=", "probs", "[", "i", "]", "[", "j", "]", ";", "}", "}", "//height", "of", "residues", "for", "(", "j", "=", "0", ";", "j", "<", "K", ";", "j", "++", ")", "{", "heights", "[", "i", "]", "[", "j", "]", "=", "0.0", ";", "if", "(", "probs", "[", "i", "]", "[", "j", "]", ">", "0", ")", "{", "logodds", "=", "eslCONST_LOG2R", "*", "log", "(", "probs", "[", "i", "]", "[", "j", "]", "/", "bg", "->", "f", "[", "j", "]", ")", ";", "//bits", "heights", "[", "i", "]", "[", "j", "]", "=", "logodds", "<=", "0", "?", "0.0", ":", "(", "rel_ents", "[", "i", "]", "*", "probs", "[", "i", "]", "[", "j", "]", "/", "abovebg_prob_sum", ")", ";", "}", "}", "}", "return", "eslOK", ";", "}'" ]

[ "Nonblocking", "version", "of", "ADIOI_GEN_WriteStridedColl()" ]

[ "'void", "ADIOI_GEN_IwriteStridedColl", "(", "ADIO_File", "fd", ",", "const", "void", "*", "buf", ",", "int", "count", ",", "MPI_Datatype", "datatype", ",", "int", "file_ptr_type", ",", "ADIO_Offset", "offset", ",", "MPI_Request", "*", "request", ",", "int", "*", "error_code", ")", "{", "/*", "Uses", "a", "generalized", "version", "of", "the", "extended", "two-phase", "method", "described", "*", "in", "\"An", "Extended", "Two-Phase", "Method", "for", "Accessing", "Sections", "of", "*", "Out-of-Core", "Arrays\",", "Rajeev", "Thakur", "and", "Alok", "Choudhary,", "*", "Scientific", "Programming,", "(5)4:301--317,", "Winter", "1996.", "*", "http://www.mcs.anl.gov/home/thakur/ext2ph.ps", "*/", "ADIOI_NBC_Request", "*", "nbc_req", "=", "NULL", ";", "ADIOI_GEN_IwriteStridedColl_vars", "*", "vars", "=", "NULL", ";", "int", "nprocs", ",", "<type", "ref=\"prev\"/>", "myrank", ";", "#", "if", "0", "/*", "FIXME:", "need", "an", "implementation", "of", "ADIOI_IOIstridedColl", "*/", "if", "(fd->hints->cb_pfr", "!=", "ADIOI_HINT_DISABLE)", "{", "/*", "Cast", "away", "const\\'ness", "as", "the", "below", "function", "is", "used", "for", "read", "*", "and", "write", "*/", "ADIOI_IOIstridedColl(fd,", "(char", "*)", "buf,", "count,", "ADIOI_WRITE,", "datatype,", "file_ptr_type,", "offset,", "request,", "error_code);", "return", ";", "}", "#", "endif", "/*", "top-level", "struct", "keeping", "the", "status", "of", "function", "progress", "*/", "nbc_req", "=", "(", "ADIOI_NBC_Request", "*", ")", "ADIOI_Calloc", "(", "1", ",", "sizeof", "(", "ADIOI_NBC_Request", ")", ")", ";", "nbc_req", "->", "rdwr", "=", "ADIOI_WRITE", ";", "/*", "create", "a", "generalized", "request", "*/", "if", "(", "ADIOI_GEN_greq_class", "==", "0", ")", "{", "MPIX_Grequest_class_create", "(", "ADIOI_GEN_iwc_query_fn", ",", "ADIOI_GEN_iwc_free_fn", ",", "MPIU_Greq_cancel_fn", ",", "ADIOI_GEN_iwc_poll_fn", ",", "ADIOI_GEN_iwc_wait_fn", ",", "&", "ADIOI_GEN_greq_class", ")", ";", "}", "MPIX_Grequest_class_allocate", "(", "ADIOI_GEN_greq_class", ",", "nbc_req", ",", "request", ")", ";", "memcpy", "(", "&", "nbc_req", "->", "req", ",", "request", ",", "sizeof", "(", "MPI_Request", ")", ")", ";", "/*", "create", "a", "struct", "for", "parameters", "and", "variables", "*/", "vars", "=", "(", "ADIOI_GEN_IwriteStridedColl_vars", "*", ")", "ADIOI_Calloc", "(", "1", ",", "sizeof", "(", "ADIOI_GEN_IwriteStridedColl_vars", ")", ")", ";", "nbc_req", "->", "data", ".", "wr", ".", "wsc_vars", "=", "vars", ";", "/*", "save", "the", "parameters", "*/", "vars", "->", "fd", "=", "fd", ";", "vars", "->", "buf", "=", "buf", ";", "vars", "->", "count", "=", "count", ";", "vars", "->", "datatype", "=", "datatype", ";", "vars", "->", "file_ptr_type", "=", "file_ptr_type", ";", "vars", "->", "offset", "=", "offset", ";", "MPI_Comm_size", "(", "fd", "->", "comm", ",", "&", "nprocs", ")", ";", "MPI_Comm_rank", "(", "fd", "->", "comm", ",", "&", "myrank", ")", ";", "vars", "->", "nprocs", "=", "nprocs", ";", "vars", "->", "myrank", "=", "myrank", ";", "/*", "the", "number", "of", "processes", "that", "actually", "perform", "I/O,", "nprocs_for_coll,", "*", "is", "stored", "in", "the", "hints", "off", "the", "ADIO_File", "structure", "*/", "vars", "->", "nprocs_for_coll", "=", "fd", "->", "hints", "->", "cb_nodes", ";", "vars", "->", "orig_fp", "=", "fd", "->", "fp_ind", ";", "/*", "only", "check", "for", "interleaving", "if", "cb_write", "isn\\'t", "disabled", "*/", "if", "(", "fd", "->", "hints", "->", "cb_write", "!=", "ADIOI_HINT_DISABLE", ")", "{", "/*", "For", "this", "process\\'s", "request,", "calculate", "the", "list", "of", "offsets", "and", "*", "lengths", "in", "the", "file", "and", "determine", "the", "start", "and", "end", "offsets.", "*/", "/*", "Note:", "end_offset", "points", "to", "the", "last", "byte-offset", "that", "will", "be", "accessed.", "*", "e.g.,", "if", "start_offset=0", "and", "100", "bytes", "to", "be", "read,", "end_offset=99", "*/", "ADIOI_Calc_my_off_len", "(", "fd", ",", "count", ",", "datatype", ",", "file_ptr_type", ",", "offset", ",", "&", "vars", "->", "offset_list", ",", "&", "vars", "->", "len_list", ",", "&", "vars", "->", "start_offset", ",", "&", "vars", "->", "end_offset", ",", "&", "vars", "->", "contig_access_count", ")", ";", "/*", "each", "process", "communicates", "its", "start", "and", "end", "offsets", "to", "other", "*", "processes.", "The", "result", "is", "an", "array", "each", "of", "start", "and", "end", "offsets", "*", "stored", "in", "order", "of", "process", "rank.", "*/", "vars", "->", "st_offsets", "=", "(", "ADIO_Offset", "*", ")", "ADIOI_Malloc", "(", "nprocs", "*", "2", "*", "sizeof", "(", "ADIO_Offset", ")", ")", ";", "vars", "->", "end_offsets", "=", "vars", "->", "st_offsets", "+", "nprocs", ";", "*", "error_code", "=", "MPI_Iallgather", "(", "&", "vars", "->", "start_offset", ",", "1", ",", "ADIO_OFFSET", ",", "vars", "->", "st_offsets", ",", "1", ",", "ADIO_OFFSET", ",", "fd", "->", "comm", ",", "&", "vars", "->", "req_offset", "[", "0", "]", ")", ";", "if", "(", "*", "error_code", "!=", "MPI_SUCCESS", ")", "return", ";", "*", "error_code", "=", "MPI_Iallgather", "(", "&", "vars", "->", "end_offset", ",", "1", ",", "ADIO_OFFSET", ",", "vars", "->", "end_offsets", ",", "1", ",", "ADIO_OFFSET", ",", "fd", "->", "comm", ",", "&", "vars", "->", "req_offset", "[", "1", "]", ")", ";", "nbc_req", "->", "data", ".", "wr", ".", "state", "=", "ADIOI_IWC_STATE_GEN_IWRITESTRIDEDCOLL", ";", "return", ";", "}", "ADIOI_GEN_IwriteStridedColl_indio", "(", "nbc_req", ",", "error_code", ")", ";", "}'" ]

[ "Functions", "with", "Error", "Codes" ]

[ "'int", "gsl_sf_lambert_W0_e", "(", "double", "x", ",", "gsl_sf_result", "*", "result", ")", "{", "const", "double", "one_over_E", "=", "1.0", "/", "M_E", ";", "const", "double", "q", "=", "x", "+", "one_over_E", ";", "if", "(", "x", "==", "0.0", ")", "{", "result", "->", "val", "=", "0.0", ";", "result", "->", "err", "=", "0.0", ";", "return", "GSL_SUCCESS", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "q", "<", "0.0", ")", "{", "/*", "Strictly", "speaking", "this", "is", "an", "error.", "But", "because", "of", "the", "*", "arithmetic", "operation", "connecting", "x", "and", "q,", "I", "am", "a", "little", "*", "lenient", "in", "case", "of", "some", "epsilon", "overshoot.", "The", "following", "*", "answer", "is", "quite", "accurate", "in", "that", "case.", "Anyway,", "we", "have", "*", "to", "return", "GSL_EDOM.", "*/", "result", "->", "val", "=", "-", "1.0", ";", "result", "->", "err", "=", "sqrt", "(", "-", "q", ")", ";", "return", "GSL_EDOM", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "q", "==", "0.0", ")", "{", "result", "->", "val", "=", "-", "1.0", ";", "result", "->", "err", "=", "GSL_DBL_EPSILON", ";", "/*", "cannot", "error", "is", "zero,", "maybe", "q", "==", "0", "by", "\"accident\"", "*/", "return", "GSL_SUCCESS", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "q", "<", "1.0e-03", ")", "{", "/*", "series", "near", "-1/E", "in", "sqrt(q)", "*/", "const", "double", "r", "=", "sqrt", "(", "q", ")", ";", "result", "->", "val", "=", "series_eval", "(", "r", ")", ";", "result", "->", "err", "=", "2.0", "*", "GSL_DBL_EPSILON", "*", "fabs", "(", "result", "->", "val", ")", ";", "return", "GSL_SUCCESS", ";", "}", "else", "{", "static", "const", "unsigned", "int", "MAX_ITERS", "=", "10", ";", "double", "w", ";", "if", "(", "x", "<", "1.0", ")", "{", "/*", "obtain", "initial", "approximation", "from", "series", "near", "x=0;", "*", "no", "need", "for", "extra", "care,", "since", "the", "Halley", "iteration", "*", "converges", "nicely", "on", "this", "branch", "*/", "const", "double", "p", "=", "sqrt", "(", "2.0", "*", "M_E", "*", "q", ")", ";", "w", "=", "-", "1.0", "+", "p", "*", "(", "1.0", "+", "p", "*", "(", "-", "1.0", "/", "3.0", "+", "p", "*", "11.0", "/", "72.0", ")", ")", ";", "}", "else", "{", "/*", "obtain", "initial", "approximation", "from", "rough", "asymptotic", "*/", "w", "=", "log", "(", "x", ")", ";", "if", "(", "x", ">", "3.0", ")", "w", "-=", "log", "(", "w", ")", ";", "}", "return", "halley_iteration", "(", "x", ",", "w", ",", "MAX_ITERS", ",", "result", ")", ";", "}", "}'" ]

[ "Functions", "related", "to", "ASYNC", "via", "script", "functions" ]

[ "'int", "register_async_script_handlers", "(", "async_script_start_function", "*", "f1", ",", "async_script_resume_function", "*", "f2", ")", "{", "if", "(", "async_script_start_f", ")", "{", "LM_ERR", "(", "\"aync", "script", "handlers", "already", "registered\\\"", ")", ";", "return", "-", "1", ";", "}", "async_script_start_f", "=", "f1", ";", "async_script_resume_f", "=", "f2", ";", "return", "0", ";", "}'" ]

[ "Functions", "related", "to", "internal", "ASYNC", "support" ]

[ "'int", "register_async_fd", "(", "int", "fd", ",", "async_resume_fd", "*", "f", ",", "void", "*", "resume_param", ")", "{", "async_ctx", "*", "ctx", "=", "NULL", ";", "if", "(", "(", "ctx", "=", "shm_malloc", "(", "sizeof", "(", "async_ctx", ")", ")", ")", "==", "NULL", ")", "{", "LM_ERR", "(", "\"failed", "to", "allocate", "new", "async_ctx\\\"", ")", ";", "return", "-", "1", ";", "}", "ctx", "->", "resume_f", "=", "f", ";", "ctx", "->", "resume_param", "=", "resume_param", ";", "/*", "place", "the", "FD", "+", "resume", "function", "(as", "param)", "into", "reactor", "*/", "if", "(", "reactor_add_reader", "(", "fd", ",", "F_FD_ASYNC", ",", "RCT_PRIO_ASYNC", ",", "(", "void", "*", ")", "ctx", ")", "<", "0", ")", "{", "LM_ERR", "(", "\"failed", "to", "add", "async", "FD", "to", "reactor\\\"", ")", ";", "shm_free", "(", "ctx", ")", ";", "return", "-", "1", ";", "}", "return", "0", ";", "}'" ]

[ "dh_cb", "is", "identical", "to", "dsa_cb", "in", "apps", "dsaparam" ]

[ "\"static", "int", "MS_CALLBACK", "dh_cb", "(", "int", "p", ",", "int", "n", ",", "BN_GENCB", "*", "cb", ")", "{", "char", "c", "=", "'*'", ";", "if", "(", "p", "==", "0", ")", "c", "=", "'.'", ";", "if", "(", "p", "==", "1", ")", "c", "=", "'+'", ";", "if", "(", "p", "==", "2", ")", "c", "=", "'*'", ";", "if", "(", "p", "==", "3", ")", "c", "=", "'\\'", ";", "BIO_write", "(", "cb", "->", "arg", ",", "&", "c", ",", "1", ")", ";", "(", "void", ")", "BIO_flush", "(", "cb", "->", "arg", ")", ";", "#", "ifdef", "LINT", "p", "=", "n", ";", "#", "endif", "return", "1", ";", "}\"" ]

[ "Prints", "debugging", "info", "for", "the", "message" ]

[ "'static", "herr_t", "H5O__mtime_debug", "(", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "const", "void", "*", "_mesg", ",", "FILE", "*", "stream", ",", "int", "indent", ",", "int", "fwidth", ")", "{", "const", "time_t", "*", "mesg", "=", "(", "const", "time_t", "*", ")", "_mesg", ";", "struct", "tm", "*", "tm", ";", "char", "buf", "[", "128", "]", ";", "FUNC_ENTER_STATIC_NOERR", "/*", "check", "args", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "mesg", ")", ";", "HDassert", "(", "stream", ")", ";", "HDassert", "(", "indent", ">=", "0", ")", ";", "HDassert", "(", "fwidth", ">=", "0", ")", ";", "/*", "debug", "*/", "tm", "=", "HDlocaltime", "(", "mesg", ")", ";", "HDstrftime", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"%Y-%m-%d", "%H:%M:%S", "%Z\"", ",", "tm", ")", ";", "HDfprintf", "(", "stream", ",", "\"%*s%-*s", "%s\\\"", ",", "indent", ",", "\"\"", ",", "fwidth", ",", "\"Time:\"", ",", "buf", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Decode", "a", "new", "modification", "time", "message", "and", "return", "a", "pointer", "to", "a", "new", "time_t", "value" ]

[ "'static", "void", "*", "H5O__mtime_new_decode", "(", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "H5O_t", "H5_ATTR_UNUSED", "*", "open_oh", ",", "unsigned", "H5_ATTR_UNUSED", "mesg_flags", ",", "unsigned", "H5_ATTR_UNUSED", "*", "ioflags", ",", "size_t", "H5_ATTR_UNUSED", "p_size", ",", "const", "uint8_t", "*", "p", ")", "{", "time_t", "*", "mesg", ";", "uint32_t", "tmp_time", ";", "/*", "Temporary", "copy", "of", "the", "time", "*/", "void", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "check", "args", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "p", ")", ";", "/*", "decode", "*/", "if", "(", "*", "p", "++", "!=", "H5O_MTIME_VERSION", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTLOAD", ",", "NULL", ",", "\"bad", "version", "number", "for", "mtime", "message\"", ")", ";", "/*", "Skip", "reserved", "bytes", "*/", "p", "+=", "3", ";", "/*", "Get", "the", "time_t", "from", "the", "file", "*/", "UINT32DECODE", "(", "p", ",", "tmp_time", ")", ";", "/*", "The", "return", "value", "*/", "if", "(", "NULL", "==", "(", "mesg", "=", "H5FL_MALLOC", "(", "time_t", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "NULL", ",", "\"memory", "allocation", "failed\"", ")", ";", "*", "mesg", "=", "(", "time_t", ")", "tmp_time", ";", "/*", "Set", "return", "value", "*/", "ret_value", "=", "mesg", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Returns", "the", "size", "of", "the", "raw", "message", "in", "bytes", "not", "counting", "the", "message", "type", "or", "size", "fields,", "but", "only", "the", "data", "fields" ]

[ "'static", "size_t", "H5O_mtime_new_size", "(", "const", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "hbool_t", "H5_ATTR_UNUSED", "disable_shared", ",", "const", "void", "H5_ATTR_UNUSED", "*", "mesg", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "/*", "check", "args", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "mesg", ")", ";", "FUNC_LEAVE_NOAPI", "(", "8", ")", "}'" ]

[ "Returns", "the", "size", "of", "the", "raw", "message", "in", "bytes", "not", "counting", "the", "message", "type", "or", "size", "fields,", "but", "only", "the", "data", "fields" ]

[ "'static", "size_t", "H5O_mtime_size", "(", "const", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "hbool_t", "H5_ATTR_UNUSED", "disable_shared", ",", "const", "void", "H5_ATTR_UNUSED", "*", "mesg", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "/*", "check", "args", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "mesg", ")", ";", "FUNC_LEAVE_NOAPI", "(", "16", ")", "}'" ]

[ "Encodes", "a", "modification", "time", "message" ]

[ "'static", "herr_t", "H5O_mtime_encode", "(", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "hbool_t", "H5_ATTR_UNUSED", "disable_shared", ",", "uint8_t", "*", "p", ",", "const", "void", "*", "_mesg", ")", "{", "const", "time_t", "*", "mesg", "=", "(", "const", "time_t", "*", ")", "_mesg", ";", "struct", "tm", "*", "tm", ";", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "/*", "check", "args", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "p", ")", ";", "HDassert", "(", "mesg", ")", ";", "/*", "encode", "*/", "tm", "=", "HDgmtime", "(", "mesg", ")", ";", "HDsprintf", "(", "(", "char", "*", ")", "p", ",", "\"%04d%02d%02d%02d%02d%02d\"", ",", "1900", "+", "tm", "->", "tm_year", ",", "1", "+", "tm", "->", "tm_mon", ",", "tm", "->", "tm_mday", ",", "tm", "->", "tm_hour", ",", "tm", "->", "tm_min", ",", "tm", "->", "tm_sec", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Copies", "a", "message", "from", "_MESG", "to", "_DEST,", "allocating", "_DEST", "if", "necessary" ]

[ "'static", "void", "*", "H5O_mtime_copy", "(", "const", "void", "*", "_mesg", ",", "void", "*", "_dest", ")", "{", "const", "time_t", "*", "mesg", "=", "(", "const", "time_t", "*", ")", "_mesg", ";", "time_t", "*", "dest", "=", "(", "time_t", "*", ")", "_dest", ";", "void", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_NOAPI_NOINIT", "/*", "check", "args", "*/", "HDassert", "(", "mesg", ")", ";", "if", "(", "!", "dest", "&&", "NULL", "==", "(", "dest", "=", "H5FL_MALLOC", "(", "time_t", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "NULL", ",", "\"memory", "allocation", "failed\"", ")", ";", "/*", "copy", "*/", "*", "dest", "=", "*", "mesg", ";", "/*", "Set", "return", "value", "*/", "ret_value", "=", "dest", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "Decode", "a", "modification", "time", "message", "and", "return", "a", "pointer", "to", "a", "new", "time_t", "value" ]

[ "'static", "void", "*", "H5O__mtime_decode", "(", "H5F_t", "H5_ATTR_UNUSED", "*", "f", ",", "H5O_t", "H5_ATTR_UNUSED", "*", "open_oh", ",", "unsigned", "H5_ATTR_UNUSED", "mesg_flags", ",", "unsigned", "H5_ATTR_UNUSED", "*", "ioflags", ",", "size_t", "H5_ATTR_UNUSED", "p_size", ",", "const", "uint8_t", "*", "p", ")", "{", "time_t", "*", "mesg", ",", "<type", "ref=\"prev\"/>", "the_time", ";", "struct", "tm", "tm", ";", "int", "i", ";", "/*", "Local", "index", "variable", "*/", "void", "*", "ret_value", "=", "NULL", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_STATIC", "/*", "check", "args", "*/", "HDassert", "(", "f", ")", ";", "HDassert", "(", "p", ")", ";", "/*", "decode", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "14", ";", "i", "++", ")", "if", "(", "!", "HDisdigit", "(", "p", "[", "i", "]", ")", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTINIT", ",", "NULL", ",", "\"badly", "formatted", "modification", "time", "message\"", ")", "/*", "Convert", "YYYYMMDDhhmmss", "UTC", "to", "a", "time_t.", "*/", "HDmemset", "(", "&", "tm", ",", "0", ",", "sizeof", "tm", ")", ";", "tm", ".", "tm_year", "=", "(", "p", "[", "0", "]", "-", "\\'0\\'", ")", "*", "1000", "+", "(", "p", "[", "1", "]", "-", "\\'0\\'", ")", "*", "100", "+", "(", "p", "[", "2", "]", "-", "\\'0\\'", ")", "*", "10", "+", "(", "p", "[", "3", "]", "-", "\\'0\\'", ")", "-", "1900", ";", "tm", ".", "tm_mon", "=", "(", "p", "[", "4", "]", "-", "\\'0\\'", ")", "*", "10", "+", "(", "p", "[", "5", "]", "-", "\\'0\\'", ")", "-", "1", ";", "tm", ".", "tm_mday", "=", "(", "p", "[", "6", "]", "-", "\\'0\\'", ")", "*", "10", "+", "(", "p", "[", "7", "]", "-", "\\'0\\'", ")", ";", "tm", ".", "tm_hour", "=", "(", "p", "[", "8", "]", "-", "\\'0\\'", ")", "*", "10", "+", "(", "p", "[", "9", "]", "-", "\\'0\\'", ")", ";", "tm", ".", "tm_min", "=", "(", "p", "[", "10", "]", "-", "\\'0\\'", ")", "*", "10", "+", "(", "p", "[", "11", "]", "-", "\\'0\\'", ")", ";", "tm", ".", "tm_sec", "=", "(", "p", "[", "12", "]", "-", "\\'0\\'", ")", "*", "10", "+", "(", "p", "[", "13", "]", "-", "\\'0\\'", ")", ";", "tm", ".", "tm_isdst", "=", "-", "1", ";", "/*", "(figure", "it", "out)", "*/", "if", "(", "(", "time_t", ")", "-", "1", "==", "(", "the_time", "=", "H5_make_time", "(", "&", "tm", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_OHDR", ",", "H5E_CANTINIT", ",", "NULL", ",", "\"can\\'t", "construct", "time", "info\"", ")", "/*", "The", "return", "value", "*/", "if", "(", "NULL", "==", "(", "mesg", "=", "H5FL_MALLOC", "(", "time_t", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_RESOURCE", ",", "H5E_NOSPACE", ",", "NULL", ",", "\"memory", "allocation", "failed\"", ")", "*", "mesg", "=", "the_time", ";", "/*", "Set", "return", "value", "*/", "ret_value", "=", "mesg", ";", "done", ":", "FUNC_LEAVE_NOAPI", "(", "ret_value", ")", "}'" ]

[ "RCC", "Disable", "Peripheral", "Clocks" ]

[ "'void", "rcc_peripheral_disable_clock", "(", "volatile", "uint32_t", "*", "reg", ",", "uint32_t", "en", ")", "{", "*", "reg", "&=", "~", "en", ";", "}'" ]

[ "RCC", "Enable", "Peripheral", "Clocks" ]

[ "'void", "rcc_peripheral_enable_clock", "(", "volatile", "uint32_t", "*", "reg", ",", "uint32_t", "en", ")", "{", "*", "reg", "|=", "en", ";", "}'" ]

[ "RCC", "Remove", "Reset", "on", "Peripherals" ]

[ "'void", "rcc_peripheral_clear_reset", "(", "volatile", "uint32_t", "*", "reg", ",", "uint32_t", "clear_reset", ")", "{", "*", "reg", "&=", "~", "clear_reset", ";", "}'" ]

[ "VICE", "code:", "Store", "number", "as", "little", "endian" ]

[ "'static", "void", "le_store", "(", "uint8_t", "*", "buf", ",", "uint32_t", "val", ",", "int", "len", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "buf", "[", "i", "]", "=", "(", "uint8_t", ")", "(", "val", "&", "0xff", ")", ";", "val", ">>=", "8", ";", "}", "}'" ]

[ "free", "memorymapped", "stack", "storage" ]

[ "'void", "stack_free", "(", "void", "*", "p", ",", "int", "size", ")", "{", "size_t", "sp", "=", "(", "size_t", ")", "p", "-", "size", ";", "#", "ifdef", "DEBUG", "memset", "(", "(", "void", "*", ")", "sp", ",", "0xcd", ",", "size", ")", ";", "#", "endif", "munmap", "(", "(", "void", "*", ")", "sp", ",", "size", ")", ";", "#", "if", "STACK_OVERFLOW_PROTECT", "sp", "=", "sp", "-", "PAGE_SIZE", ";", "munmap", "(", "(", "void", "*", ")", "sp", ",", "PAGE_SIZE", ")", ";", "#", "endif", "}'" ]

[ "Write", "a", "structured", "index", "to", "a", "file" ]

[ "'int", "write_index_file", "(", "opj_codestream_info_t", "*", "cstr_info", ",", "char", "*", "index", ")", "{", "int", "tileno", ",", "<type", "ref=\"prev\"/>", "compno", ",", "<type", "ref=\"prev\"/>", "layno", ",", "<type", "ref=\"prev\"/>", "resno", ",", "<type", "ref=\"prev\"/>", "precno", ",", "<type", "ref=\"prev\"/>", "pack_nb", ",", "<type", "ref=\"prev\"/>", "x", ",", "<type", "ref=\"prev\"/>", "y", ";", "FILE", "*", "stream", "=", "NULL", ";", "double", "total_disto", "=", "0", ";", "/*", "UniPG>>", "*/", "int", "tilepartno", ";", "char", "disto_on", ",", "<type", "ref=\"prev\"/>", "numpix_on", ";", "#", "ifdef", "USE_JPWL", "if", "(", "!", "strcmp", "(", "index", ",", "JPWL_PRIVATEINDEX_NAME", ")", ")", "{", "return", "0", ";", "}", "#", "endif", "/*", "USE_JPWL", "*/", "/*", "<<UniPG", "*/", "if", "(", "!", "cstr_info", ")", "{", "return", "1", ";", "}", "stream", "=", "fopen", "(", "index", ",", "\"w\"", ")", ";", "if", "(", "!", "stream", ")", "{", "fprintf", "(", "stderr", ",", "\"failed", "to", "open", "index", "file", "[%s]", "for", "writing\\\"", ",", "index", ")", ";", "return", "1", ";", "}", "if", "(", "cstr_info", "->", "tile", "[", "0", "]", ".", "distotile", ">", "0.0", ")", "{", "disto_on", "=", "1", ";", "}", "else", "{", "disto_on", "=", "0", ";", "}", "if", "(", "cstr_info", "->", "tile", "[", "0", "]", ".", "numpix", ")", "{", "numpix_on", "=", "1", ";", "}", "else", "{", "numpix_on", "=", "0", ";", "}", "fprintf", "(", "stream", ",", "\"%d", "%d\\\"", ",", "cstr_info", "->", "image_w", ",", "cstr_info", "->", "image_h", ")", ";", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "prog", ")", ";", "fprintf", "(", "stream", ",", "\"%d", "%d\\\"", ",", "cstr_info", "->", "tile_x", ",", "cstr_info", "->", "tile_y", ")", ";", "fprintf", "(", "stream", ",", "\"%d", "%d\\\"", ",", "cstr_info", "->", "tw", ",", "cstr_info", "->", "th", ")", ";", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "numcomps", ")", ";", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "numlayers", ")", ";", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "numdecompos", "[", "0", "]", ")", ";", "/*", "based", "on", "component", "0", "*/", "for", "(", "resno", "=", "cstr_info", "->", "numdecompos", "[", "0", "]", ";", "resno", ">=", "0", ";", "resno", "--", ")", "{", "fprintf", "(", "stream", ",", "\"[%d,%d]", "\"", ",", "(", "1", "<<", "cstr_info", "->", "tile", "[", "0", "]", ".", "pdx", "[", "resno", "]", ")", ",", "(", "1", "<<", "cstr_info", "->", "tile", "[", "0", "]", ".", "pdx", "[", "resno", "]", ")", ")", ";", "/*", "based", "on", "tile", "0", "and", "component", "0", "*/", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "/*", "UniPG>>", "*/", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "main_head_start", ")", ";", "/*", "<<UniPG", "*/", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "main_head_end", ")", ";", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "codestream_size", ")", ";", "fprintf", "(", "stream", ",", "\"\\INFO", "ON", "TILES\\\"", ")", ";", "fprintf", "(", "stream", ",", "\"tileno", "start_pos", "end_hd", "end_tile", "nbparts\"", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "disto\"", ")", ";", "}", "if", "(", "numpix_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "nbpix\"", ")", ";", "}", "if", "(", "disto_on", "&&", "numpix_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "disto/nbpix\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "for", "(", "tileno", "=", "0", ";", "tileno", "<", "cstr_info", "->", "tw", "*", "cstr_info", "->", "th", ";", "tileno", "++", ")", "{", "fprintf", "(", "stream", ",", "\"%4d", "%9d", "%9d", "%9d", "%9d\"", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "tileno", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "start_pos", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "end_header", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "end_pos", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "num_tps", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%9e\"", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "distotile", ")", ";", "}", "if", "(", "numpix_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%9d\"", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "numpix", ")", ";", "}", "if", "(", "disto_on", "&&", "numpix_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%9e\"", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "distotile", "/", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "numpix", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "}", "for", "(", "tileno", "=", "0", ";", "tileno", "<", "cstr_info", "->", "tw", "*", "cstr_info", "->", "th", ";", "tileno", "++", ")", "{", "OPJ_OFF_T", "start_pos", ",", "<type", "ref=\"prev\"/>", "end_ph_pos", ",", "<type", "ref=\"prev\"/>", "end_pos", ";", "double", "disto", "=", "0", ";", "int", "max_numdecompos", "=", "0", ";", "pack_nb", "=", "0", ";", "for", "(", "compno", "=", "0", ";", "compno", "<", "cstr_info", "->", "numcomps", ";", "compno", "++", ")", "{", "if", "(", "max_numdecompos", "<", "cstr_info", "->", "numdecompos", "[", "compno", "]", ")", "{", "max_numdecompos", "=", "cstr_info", "->", "numdecompos", "[", "compno", "]", ";", "}", "}", "fprintf", "(", "stream", ",", "\"\\TILE", "%d", "DETAILS\\\"", ",", "tileno", ")", ";", "fprintf", "(", "stream", ",", "\"part_nb", "tileno", "start_pack", "num_packs", "start_pos", "end_tph_pos", "end_pos\\\"", ")", ";", "for", "(", "tilepartno", "=", "0", ";", "tilepartno", "<", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "num_tps", ";", "tilepartno", "++", ")", "fprintf", "(", "stream", ",", "\"%4d", "%9d", "%9d", "%9d", "%9d", "%11d", "%9d\\\"", ",", "tilepartno", ",", "tileno", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "tp", "[", "tilepartno", "]", ".", "tp_start_pack", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "tp", "[", "tilepartno", "]", ".", "tp_numpacks", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "tp", "[", "tilepartno", "]", ".", "tp_start_pos", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "tp", "[", "tilepartno", "]", ".", "tp_end_header", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "tp", "[", "tilepartno", "]", ".", "tp_end_pos", ")", ";", "if", "(", "cstr_info", "->", "prog", "==", "OPJ_LRCP", ")", "{", "/*", "LRCP", "*/", "fprintf", "(", "stream", ",", "\"LRCP\\pack_nb", "tileno", "layno", "resno", "compno", "precno", "start_pos", "end_ph_pos", "end_pos\"", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "disto\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "for", "(", "layno", "=", "0", ";", "layno", "<", "cstr_info", "->", "numlayers", ";", "layno", "++", ")", "{", "for", "(", "resno", "=", "0", ";", "resno", "<", "max_numdecompos", "+", "1", ";", "resno", "++", ")", "{", "for", "(", "compno", "=", "0", ";", "compno", "<", "cstr_info", "->", "numcomps", ";", "compno", "++", ")", "{", "int", "prec_max", ";", "if", "(", "resno", ">", "cstr_info", "->", "numdecompos", "[", "compno", "]", ")", "{", "break;", "}", "prec_max", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", "*", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "ph", "[", "resno", "]", ";", "for", "(", "precno", "=", "0", ";", "precno", "<", "prec_max", ";", "precno", "++", ")", "{", "start_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "start_pos", ";", "end_ph_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_ph_pos", ";", "end_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_pos", ";", "disto", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "disto", ";", "fprintf", "(", "stream", ",", "\"%4d", "%6d", "%7d", "%5d", "%6d", "%6d", "%6\"", "PRId64", "\"", "%6\"", "PRId64", "\"", "%7\"", "PRId64", ",", "pack_nb", ",", "tileno", ",", "layno", ",", "resno", ",", "compno", ",", "precno", ",", "start_pos", ",", "end_ph_pos", ",", "end_pos", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%8e\"", ",", "disto", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "total_disto", "+=", "disto", ";", "pack_nb", "++", ";", "}", "}", "}", "}", "}", "/*", "LRCP", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "cstr_info", "->", "prog", "==", "OPJ_RLCP", ")", "{", "/*", "RLCP", "*/", "fprintf", "(", "stream", ",", "\"RLCP\\pack_nb", "tileno", "resno", "layno", "compno", "precno", "start_pos", "end_ph_pos", "end_pos\\\"", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "disto\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "for", "(", "resno", "=", "0", ";", "resno", "<", "max_numdecompos", "+", "1", ";", "resno", "++", ")", "{", "for", "(", "layno", "=", "0", ";", "layno", "<", "cstr_info", "->", "numlayers", ";", "layno", "++", ")", "{", "for", "(", "compno", "=", "0", ";", "compno", "<", "cstr_info", "->", "numcomps", ";", "compno", "++", ")", "{", "int", "prec_max", ";", "if", "(", "resno", ">", "cstr_info", "->", "numdecompos", "[", "compno", "]", ")", "{", "break;", "}", "prec_max", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", "*", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "ph", "[", "resno", "]", ";", "for", "(", "precno", "=", "0", ";", "precno", "<", "prec_max", ";", "precno", "++", ")", "{", "start_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "start_pos", ";", "end_ph_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_ph_pos", ";", "end_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_pos", ";", "disto", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "disto", ";", "fprintf", "(", "stream", ",", "\"%4d", "%6d", "%5d", "%7d", "%6d", "%6d", "%9\"", "PRId64", "\"", "%9\"", "PRId64", "\"", "%7\"", "PRId64", ",", "pack_nb", ",", "tileno", ",", "resno", ",", "layno", ",", "compno", ",", "precno", ",", "start_pos", ",", "end_ph_pos", ",", "end_pos", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%8e\"", ",", "disto", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "total_disto", "+=", "disto", ";", "pack_nb", "++", ";", "}", "}", "}", "}", "}", "/*", "RLCP", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "cstr_info", "->", "prog", "==", "OPJ_RPCL", ")", "{", "/*", "RPCL", "*/", "fprintf", "(", "stream", ",", "\"RPCL\\pack_nb", "tileno", "resno", "precno", "compno", "layno", "start_pos", "end_ph_pos", "end_pos\"", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "disto\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "for", "(", "resno", "=", "0", ";", "resno", "<", "max_numdecompos", "+", "1", ";", "resno", "++", ")", "{", "int", "numprec", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", "*", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "ph", "[", "resno", "]", ";", "for", "(", "precno", "=", "0", ";", "precno", "<", "numprec", ";", "precno", "++", ")", "{", "/*", "I", "suppose", "components", "have", "same", "XRsiz,", "YRsiz", "*/", "int", "x0", "=", "cstr_info", "->", "tile_Ox", "+", "tileno", "-", "(", "int", ")", "floor", "(", "(", "float", ")", "tileno", "/", "(", "float", ")", "cstr_info", "->", "tw", ")", "*", "cstr_info", "->", "tw", "*", "cstr_info", "->", "tile_x", ";", "int", "y0", "=", "cstr_info", "->", "tile_Ox", "+", "(", "int", ")", "floor", "(", "(", "float", ")", "tileno", "/", "(", "float", ")", "cstr_info", "->", "tw", ")", "*", "cstr_info", "->", "tile_y", ";", "int", "x1", "=", "x0", "+", "cstr_info", "->", "tile_x", ";", "int", "y1", "=", "y0", "+", "cstr_info", "->", "tile_y", ";", "for", "(", "compno", "=", "0", ";", "compno", "<", "cstr_info", "->", "numcomps", ";", "compno", "++", ")", "{", "int", "pcnx", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", ";", "int", "pcx", "=", "(", "int", ")", "pow", "(", "2", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pdx", "[", "resno", "]", "+", "cstr_info", "->", "numdecompos", "[", "compno", "]", "-", "resno", ")", ";", "int", "pcy", "=", "(", "int", ")", "pow", "(", "2", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pdy", "[", "resno", "]", "+", "cstr_info", "->", "numdecompos", "[", "compno", "]", "-", "resno", ")", ";", "int", "precno_x", "=", "precno", "-", "(", "int", ")", "floor", "(", "(", "float", ")", "precno", "/", "(", "float", ")", "pcnx", ")", "*", "pcnx", ";", "int", "precno_y", "=", "(", "int", ")", "floor", "(", "(", "float", ")", "precno", "/", "(", "float", ")", "pcnx", ")", ";", "if", "(", "resno", ">", "cstr_info", "->", "numdecompos", "[", "compno", "]", ")", "{", "break;", "}", "for", "(", "y", "=", "y0", ";", "y", "<", "y1", ";", "y", "++", ")", "{", "if", "(", "precno_y", "*", "pcy", "==", "y", ")", "{", "for", "(", "x", "=", "x0", ";", "x", "<", "x1", ";", "x", "++", ")", "{", "if", "(", "precno_x", "*", "pcx", "==", "x", ")", "{", "for", "(", "layno", "=", "0", ";", "layno", "<", "cstr_info", "->", "numlayers", ";", "layno", "++", ")", "{", "start_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "start_pos", ";", "end_ph_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_ph_pos", ";", "end_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_pos", ";", "disto", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "disto", ";", "fprintf", "(", "stream", ",", "\"%4d", "%6d", "%5d", "%6d", "%6d", "%7d", "%9\"", "PRId64", "\"", "%9\"", "PRId64", "\"", "%7\"", "PRId64", ",", "pack_nb", ",", "tileno", ",", "resno", ",", "precno", ",", "compno", ",", "layno", ",", "start_pos", ",", "end_ph_pos", ",", "end_pos", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%8e\"", ",", "disto", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "total_disto", "+=", "disto", ";", "pack_nb", "++", ";", "}", "}", "}", "/*", "x", "=", "x0..x1", "*/", "}", "}", "/*", "y", "=", "y0..y1", "*/", "}", "/*", "precno", "*/", "}", "/*", "compno", "*/", "}", "/*", "resno", "*/", "}", "/*", "RPCL", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "cstr_info", "->", "prog", "==", "OPJ_PCRL", ")", "{", "/*", "PCRL", "*/", "/*", "I", "suppose", "components", "have", "same", "XRsiz,", "YRsiz", "*/", "int", "x0", "=", "cstr_info", "->", "tile_Ox", "+", "tileno", "-", "(", "int", ")", "floor", "(", "(", "float", ")", "tileno", "/", "(", "float", ")", "cstr_info", "->", "tw", ")", "*", "cstr_info", "->", "tw", "*", "cstr_info", "->", "tile_x", ";", "int", "y0", "=", "cstr_info", "->", "tile_Ox", "+", "(", "int", ")", "floor", "(", "(", "float", ")", "tileno", "/", "(", "float", ")", "cstr_info", "->", "tw", ")", "*", "cstr_info", "->", "tile_y", ";", "int", "x1", "=", "x0", "+", "cstr_info", "->", "tile_x", ";", "int", "y1", "=", "y0", "+", "cstr_info", "->", "tile_y", ";", "/*", "Count", "the", "maximum", "number", "of", "precincts", "*/", "int", "max_numprec", "=", "0", ";", "for", "(", "resno", "=", "0", ";", "resno", "<", "max_numdecompos", "+", "1", ";", "resno", "++", ")", "{", "int", "numprec", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", "*", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "ph", "[", "resno", "]", ";", "if", "(", "numprec", ">", "max_numprec", ")", "{", "max_numprec", "=", "numprec", ";", "}", "}", "fprintf", "(", "stream", ",", "\"PCRL\\pack_nb", "tileno", "precno", "compno", "resno", "layno", "start_pos", "end_ph_pos", "end_pos\"", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "disto\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "for", "(", "precno", "=", "0", ";", "precno", "<", "max_numprec", ";", "precno", "++", ")", "{", "for", "(", "compno", "=", "0", ";", "compno", "<", "cstr_info", "->", "numcomps", ";", "compno", "++", ")", "{", "for", "(", "resno", "=", "0", ";", "resno", "<", "cstr_info", "->", "numdecompos", "[", "compno", "]", "+", "1", ";", "resno", "++", ")", "{", "int", "numprec", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", "*", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "ph", "[", "resno", "]", ";", "int", "pcnx", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", ";", "int", "pcx", "=", "(", "int", ")", "pow", "(", "2", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pdx", "[", "resno", "]", "+", "cstr_info", "->", "numdecompos", "[", "compno", "]", "-", "resno", ")", ";", "int", "pcy", "=", "(", "int", ")", "pow", "(", "2", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pdy", "[", "resno", "]", "+", "cstr_info", "->", "numdecompos", "[", "compno", "]", "-", "resno", ")", ";", "int", "precno_x", "=", "precno", "-", "(", "int", ")", "floor", "(", "(", "float", ")", "precno", "/", "(", "float", ")", "pcnx", ")", "*", "pcnx", ";", "int", "precno_y", "=", "(", "int", ")", "floor", "(", "(", "float", ")", "precno", "/", "(", "float", ")", "pcnx", ")", ";", "if", "(", "precno", ">=", "numprec", ")", "{", "continue;", "}", "for", "(", "y", "=", "y0", ";", "y", "<", "y1", ";", "y", "++", ")", "{", "if", "(", "precno_y", "*", "pcy", "==", "y", ")", "{", "for", "(", "x", "=", "x0", ";", "x", "<", "x1", ";", "x", "++", ")", "{", "if", "(", "precno_x", "*", "pcx", "==", "x", ")", "{", "for", "(", "layno", "=", "0", ";", "layno", "<", "cstr_info", "->", "numlayers", ";", "layno", "++", ")", "{", "start_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "start_pos", ";", "end_ph_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_ph_pos", ";", "end_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_pos", ";", "disto", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "disto", ";", "fprintf", "(", "stream", ",", "\"%4d", "%6d", "%6d", "%6d", "%5d", "%7d", "%9\"", "PRId64", "\"", "%9\"", "PRId64", "\"", "%7\"", "PRId64", ",", "pack_nb", ",", "tileno", ",", "precno", ",", "compno", ",", "resno", ",", "layno", ",", "start_pos", ",", "end_ph_pos", ",", "end_pos", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%8e\"", ",", "disto", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "total_disto", "+=", "disto", ";", "pack_nb", "++", ";", "}", "}", "}", "/*", "x", "=", "x0..x1", "*/", "}", "}", "/*", "y", "=", "y0..y1", "*/", "}", "/*", "resno", "*/", "}", "/*", "compno", "*/", "}", "/*", "precno", "*/", "}", "/*", "PCRL", "*/", "else", "{", "/*", "CPRL", "*/", "/*", "Count", "the", "maximum", "number", "of", "precincts", "*/", "int", "max_numprec", "=", "0", ";", "for", "(", "resno", "=", "0", ";", "resno", "<", "max_numdecompos", "+", "1", ";", "resno", "++", ")", "{", "int", "numprec", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", "*", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "ph", "[", "resno", "]", ";", "if", "(", "numprec", ">", "max_numprec", ")", "{", "max_numprec", "=", "numprec", ";", "}", "}", "fprintf", "(", "stream", ",", "\"CPRL\\pack_nb", "tileno", "compno", "precno", "resno", "layno", "start_pos", "end_ph_pos", "end_pos\"", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "disto\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "for", "(", "compno", "=", "0", ";", "compno", "<", "cstr_info", "->", "numcomps", ";", "compno", "++", ")", "{", "/*", "I", "suppose", "components", "have", "same", "XRsiz,", "YRsiz", "*/", "int", "x0", "=", "cstr_info", "->", "tile_Ox", "+", "tileno", "-", "(", "int", ")", "floor", "(", "(", "float", ")", "tileno", "/", "(", "float", ")", "cstr_info", "->", "tw", ")", "*", "cstr_info", "->", "tw", "*", "cstr_info", "->", "tile_x", ";", "int", "y0", "=", "cstr_info", "->", "tile_Ox", "+", "(", "int", ")", "floor", "(", "(", "float", ")", "tileno", "/", "(", "float", ")", "cstr_info", "->", "tw", ")", "*", "cstr_info", "->", "tile_y", ";", "int", "x1", "=", "x0", "+", "cstr_info", "->", "tile_x", ";", "int", "y1", "=", "y0", "+", "cstr_info", "->", "tile_y", ";", "for", "(", "precno", "=", "0", ";", "precno", "<", "max_numprec", ";", "precno", "++", ")", "{", "for", "(", "resno", "=", "0", ";", "resno", "<", "cstr_info", "->", "numdecompos", "[", "compno", "]", "+", "1", ";", "resno", "++", ")", "{", "int", "numprec", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", "*", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "ph", "[", "resno", "]", ";", "int", "pcnx", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pw", "[", "resno", "]", ";", "int", "pcx", "=", "(", "int", ")", "pow", "(", "2", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pdx", "[", "resno", "]", "+", "cstr_info", "->", "numdecompos", "[", "compno", "]", "-", "resno", ")", ";", "int", "pcy", "=", "(", "int", ")", "pow", "(", "2", ",", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "pdy", "[", "resno", "]", "+", "cstr_info", "->", "numdecompos", "[", "compno", "]", "-", "resno", ")", ";", "int", "precno_x", "=", "precno", "-", "(", "int", ")", "floor", "(", "(", "float", ")", "precno", "/", "(", "float", ")", "pcnx", ")", "*", "pcnx", ";", "int", "precno_y", "=", "(", "int", ")", "floor", "(", "(", "float", ")", "precno", "/", "(", "float", ")", "pcnx", ")", ";", "if", "(", "precno", ">=", "numprec", ")", "{", "continue;", "}", "for", "(", "y", "=", "y0", ";", "y", "<", "y1", ";", "y", "++", ")", "{", "if", "(", "precno_y", "*", "pcy", "==", "y", ")", "{", "for", "(", "x", "=", "x0", ";", "x", "<", "x1", ";", "x", "++", ")", "{", "if", "(", "precno_x", "*", "pcx", "==", "x", ")", "{", "for", "(", "layno", "=", "0", ";", "layno", "<", "cstr_info", "->", "numlayers", ";", "layno", "++", ")", "{", "start_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "start_pos", ";", "end_ph_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_ph_pos", ";", "end_pos", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "end_pos", ";", "disto", "=", "cstr_info", "->", "tile", "[", "tileno", "]", ".", "packet", "[", "pack_nb", "]", ".", "disto", ";", "fprintf", "(", "stream", ",", "\"%4d", "%6d", "%6d", "%6d", "%5d", "%7d", "%9\"", "PRId64", "\"", "%9\"", "PRId64", "\"", "%7\"", "PRId64", ",", "pack_nb", ",", "tileno", ",", "compno", ",", "precno", ",", "resno", ",", "layno", ",", "start_pos", ",", "end_ph_pos", ",", "end_pos", ")", ";", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"", "%8e\"", ",", "disto", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\\"", ")", ";", "total_disto", "+=", "disto", ";", "pack_nb", "++", ";", "}", "}", "}", "/*", "x", "=", "x0..x1", "*/", "}", "}", "/*", "y", "=", "y0..y1", "*/", "}", "/*", "resno", "*/", "}", "/*", "precno", "*/", "}", "/*", "compno", "*/", "}", "/*", "CPRL", "*/", "}", "/*", "tileno", "*/", "if", "(", "disto_on", ")", "{", "fprintf", "(", "stream", ",", "\"%8e\\\"", ",", "cstr_info", "->", "D_max", ")", ";", "/*", "SE", "max", "*/", "fprintf", "(", "stream", ",", "\"%.8e\\\"", ",", "total_disto", ")", ";", "/*", "SE", "totale", "*/", "}", "/*", "UniPG>>", "*/", "/*", "print", "the", "markers\\'", "list", "*/", "if", "(", "cstr_info", "->", "marknum", ")", "{", "fprintf", "(", "stream", ",", "\"\\MARKER", "LIST\\\"", ")", ";", "fprintf", "(", "stream", ",", "\"%d\\\"", ",", "cstr_info", "->", "marknum", ")", ";", "fprintf", "(", "stream", ",", "\"type\\\\tstart_pos", "length\\\"", ")", ";", "for", "(", "x", "=", "0", ";", "x", "<", "cstr_info", "->", "marknum", ";", "x", "++", ")", "{", "fprintf", "(", "stream", ",", "\"%X\\\\t%9\"", "PRId64", "\"", "%9d\\\"", ",", "cstr_info", "->", "marker", "[", "x", "]", ".", "type", ",", "cstr_info", "->", "marker", "[", "x", "]", ".", "pos", ",", "cstr_info", "->", "marker", "[", "x", "]", ".", "len", ")", ";", "}", "}", "/*", "<<UniPG", "*/", "fclose", "(", "stream", ")", ";", "fprintf", "(", "stderr", ",", "\"Generated", "index", "file", "%s\\\"", ",", "index", ")", ";", "return", "0", ";", "}'" ]

[ "updates", "the", "prop", "state", "as", "appropriate" ]

[ "'static", "instr_t", "*", "update_prop_state", "(", "prop_state_t", "*", "state", ",", "instr_t", "*", "inst", ",", "bool", "intrace", ")", "{", "int", "opcode", "=", "instr_get_opcode", "(", "inst", ")", ";", "int", "num_dst", "=", "instr_num_dsts", "(", "inst", ")", ";", "bool", "is_zeroing", "=", "is_zeroing_instr", "(", "inst", ")", ";", "dcontext_t", "*", "dcontext", "=", "state", "->", "dcontext", ";", "instr_t", "*", "backup", ";", "opnd_t", "opnd", ";", "int", "val", ",", "<type", "ref=\"prev\"/>", "i", ";", "reg_id_t", "reg", ";", "if", "(", "is_zeroing", "||", "(", "(", "opcode", "==", "OP_mov_imm", "||", "opcode", "==", "OP_mov_st", ")", "&&", "opnd_is_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ")", ")", "{", "if", "(", "is_zeroing", ")", "val", "=", "0", ";", "else", "val", "=", "(", "int", ")", "opnd_get_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ";", "opnd", "=", "instr_get_dst", "(", "inst", ",", "0", ")", ";", "if", "(", "opnd_is_reg", "(", "opnd", ")", ")", "{", "reg", "=", "opnd_get_reg", "(", "opnd", ")", "-", "REG_START_32", ";", "if", "(", "reg", "<", "8", "/*", "rules", "out", "underflow", "*/", ")", "{", "/*", "if", "resetting", "to", "same", "value", "then", "just", "nop", "the", "instruction", "*/", "if", "(", "intrace", "&&", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "&&", "state", "->", "reg_vals", "[", "reg", "]", "==", "val", ")", "{", "inst", "=", "make_to_nop", "(", "state", ",", "inst", ",", "\"", "register", "already", "set", "to", "val,", "simplify", "\"", ",", "\"", "to", "\"", ",", "\"", "register", "already", "set", "to", "val,", "but", "unable", "to", "\"", "\"simplify", "due", "to", "eflags\"", ")", ";", "}", "else", "{", "state", "->", "reg_state", "[", "reg", "]", "=", "PS_VALID_VAL", ";", "state", "->", "reg_vals", "[", "reg", "]", "=", "val", ";", "}", "}", "else", "{", "reg", "=", "opnd_get_reg", "(", "opnd", ")", "-", "REG_START_16", ";", "if", "(", "reg", "<", "8", "/*", "rules", "out", "underflow", "*/", ")", "{", "/*", "if", "resetting", "to", "same", "value", "then", "just", "nop", "the", "instruction", "*/", "if", "(", "intrace", "&&", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "||", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_LVALID_VAL", ")", "!=", "0", "&&", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_HVALID_VAL", ")", "!=", "0", ")", ")", "&&", "(", "state", "->", "reg_vals", "[", "reg", "]", "&", "0x0000ffff", ")", "==", "(", "val", "&", "0x0000ffff", ")", ")", "{", "inst", "=", "make_to_nop", "(", "state", ",", "inst", ",", "\"", "register", "already", "set", "to", "val,", "simplify", "\"", ",", "\"", "to", "\"", ",", "\"", "register", "already", "set", "to", "val,", "but", "unable", "to", "\"", "\"simplify", "due", "to", "eflags\"", ")", ";", "}", "else", "{", "state", "->", "reg_state", "[", "reg", "]", "|=", "PS_LVALID_VAL", "|", "PS_HVALID_VAL", ";", "state", "->", "reg_vals", "[", "reg", "]", "=", "(", "state", "->", "reg_vals", "[", "reg", "]", "&", "0xffff0000", ")", "|", "(", "val", "&", "0x0000ffff", ")", ";", "}", "}", "else", "{", "reg", "=", "opnd_get_reg", "(", "opnd", ")", "-", "REG_START_8", ";", "if", "(", "reg", "<", "4", "/*", "rules", "out", "underflow", "*/", ")", "{", "/*", "if", "resetting", "to", "same", "value", "then", "just", "nop", "the", "instruction", "*/", "if", "(", "intrace", "&&", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "||", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_LVALID_VAL", ")", "!=", "0", ")", "&&", "(", "state", "->", "reg_vals", "[", "reg", "]", "&", "0x000000ff", ")", "==", "(", "val", "&", "0x000000ff", ")", ")", "{", "inst", "=", "make_to_nop", "(", "state", ",", "inst", ",", "\"", "register", "already", "set", "to", "val,", "simplify", "\"", ",", "\"", "to", "\"", ",", "\"", "register", "already", "set", "to", "val,", "but", "unable", "\"", "\"to", "simplify", "due", "to", "eflags\"", ")", ";", "}", "else", "{", "state", "->", "reg_state", "[", "reg", "]", "|=", "PS_LVALID_VAL", ";", "state", "->", "reg_vals", "[", "reg", "]", "=", "(", "state", "->", "reg_vals", "[", "reg", "]", "&", "0xffffff00", ")", "|", "(", "val", "&", "0x000000ff", ")", ";", "}", "}", "else", "{", "reg", "-=", "4", ";", "if", "(", "reg", "<", "4", "/*", "rules", "out", "underflow", "*/", ")", "{", "/*", "if", "resetting", "to", "same", "value", "then", "just", "nop", "the", "instruction", "*/", "if", "(", "intrace", "&&", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "||", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_HVALID_VAL", ")", "!=", "0", ")", "&&", "(", "state", "->", "reg_vals", "[", "reg", "]", "&", "0x0000ff00", ")", "==", "(", "(", "val", "<<", "8", ")", "&", "0x0000ff00", ")", ")", "{", "inst", "=", "make_to_nop", "(", "state", ",", "inst", ",", "\"", "register", "already", "set", "to", "val,", "simplify", "\"", ",", "\"", "to", "\"", ",", "\"", "register", "already", "set", "to", "val,", "but", "unable", "to", "\"", "\"simplify", "due", "to", "eflags\"", ")", ";", "}", "else", "{", "state", "->", "reg_state", "[", "reg", "]", "|=", "PS_HVALID_VAL", ";", "state", "->", "reg_vals", "[", "reg", "]", "=", "(", "state", "->", "reg_vals", "[", "reg", "]", "&", "0xffff00ff", ")", "|", "(", "(", "val", "<<", "8", ")", "&", "0x0000ff00", ")", ";", "}", "}", "else", "{", "/*", "just", "in", "case", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "{", "if", "(", "instr_writes_to_reg", "(", "inst", ",", "REG_START_32", "+", "(", "reg_id_t", ")", "i", ",", "DR_QUERY_DEFAULT", ")", ")", "{", "state", "->", "reg_state", "[", "i", "]", "=", "0", ";", "}", "}", "}", "}", "}", "}", "}", "else", "{", "//", "do", "constant", "addresses", "if", "(", "opnd_is_constant_address", "(", "opnd", ")", "&&", "cp_global_aggr", ">", "0", ")", "{", "int", "disp", "=", "opnd_get_disp", "(", "opnd", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_CONSTANT_ADDRESS", ";", "i", "++", ")", "{", "if", "(", "state", "->", "addresses", "[", "i", "]", "==", "disp", "&&", "state", "->", "address_vals", "[", "i", "]", "==", "val", "&&", "(", "state", "->", "address_state", "[", "i", "]", "&", "PS_VALID_VAL", ")", "!=", "0", ")", "{", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"", "mem", "location", "already", "set", "to", "val,", "simplify", "\"", ")", ";", "backup", "=", "INSTR_CREATE_nop", "(", "dcontext", ")", ";", "replace_inst", "(", "dcontext", ",", "state", "->", "trace", ",", "inst", ",", "backup", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "backup", ",", "\"", "to", "\"", ")", ";", "inst", "=", "backup", ";", "}", "}", "update_address_val", "(", "state", ",", "disp", ",", "val", ")", ";", "}", "//", "do", "stack", "vals", "if", "(", "opnd_is_stack_address", "(", "opnd", ")", "&&", "cp_local_aggr", ">", "0", ")", "{", "int", "disp", "=", "opnd_get_disp", "(", "opnd", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_STACK_SLOTS", ";", "i", "++", ")", "{", "if", "(", "state", "->", "stack_offsets_ebp", "[", "i", "]", "==", "disp", "&&", "state", "->", "stack_vals", "[", "i", "]", "==", "val", "&&", "(", "state", "->", "stack_address_state", "[", "i", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "&&", "state", "->", "stack_scope", "[", "i", "]", "==", "state", "->", "cur_scope", ")", "{", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"", "mem", "location", "already", "set", "to", "val,", "simplify", "\"", ")", ";", "backup", "=", "INSTR_CREATE_nop", "(", "dcontext", ")", ";", "replace_inst", "(", "dcontext", ",", "state", "->", "trace", ",", "inst", ",", "backup", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "backup", ",", "\"", "to", "\"", ")", ";", "inst", "=", "backup", ";", "}", "}", "update_stack_val", "(", "state", ",", "disp", ",", "val", ")", ";", "}", "}", "}", "else", "{", "//", "call", "and", "int", "if", "(", "instr_is_interrupt", "(", "inst", ")", "||", "instr_is_call", "(", "inst", ")", ")", "{", "//", "can", "assume", "mem", "addresses", "not", "touched??", "//", "shouldn\\'t", "be", "going", "to", "app", "code", "for", "call", "at", "least", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "state", "->", "reg_state", "[", "i", "]", "=", "0", ";", "}", "//", "update", "for", "regs", "written", "to,", "actually", "if", "xh", "then", "don\\'t", "need", "to", "//", "invalidate", "xl", "and", "vice", "versa,", "but", "to", "much", "work", "to", "check", "for", "that", "probably", "//", "unlikely", "occurrence", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "{", "if", "(", "instr_writes_to_reg", "(", "inst", ",", "REG_START_32", "+", "(", "reg_id_t", ")", "i", ",", "DR_QUERY_DEFAULT", ")", ")", "{", "state", "->", "reg_state", "[", "i", "]", "=", "0", ";", "}", "}", "//", "update", "mem", "caches", "for", "(", "i", "=", "0", ";", "i", "<", "num_dst", ";", "i", "++", ")", "{", "opnd", "=", "instr_get_dst", "(", "inst", ",", "i", ")", ";", "if", "(", "opnd_is_constant_address", "(", "opnd", ")", "&&", "cp_global_aggr", ">", "0", ")", "{", "clear_address_val", "(", "state", ",", "opnd_get_disp", "(", "opnd", ")", ")", ";", "}", "}", "//", "update", "stack", "cahes", "for", "(", "i", "=", "0", ";", "i", "<", "num_dst", ";", "i", "++", ")", "{", "opnd", "=", "instr_get_dst", "(", "inst", ",", "i", ")", ";", "if", "(", "opnd_is_stack_address", "(", "opnd", ")", "&&", "cp_local_aggr", ">", "0", ")", "{", "clear_stack_val", "(", "state", ",", "opnd_get_disp", "(", "opnd", ")", ")", ";", "}", "}", "}", "return", "inst", ";", "}'" ]

[ "initializes", "all", "the", "trace", "constant", "stuff", "and", "add" ]

[ "'static", "void", "get_trace_constant", "(", "prop_state_t", "*", "state", ")", "{", "/*", "can", "add", "all", "dynamo", "addresses", "here,", "they", "are", "never", "aliased", "so", "always", "*/", "/*", "safe", "to", "optimize,", "but", "takes", "up", "space", "in", "our", "cache,", "with", "new", "jump", "code", "*/", "/*", "probably", "only", "use", "exc", "so", "just", "put", "it", "in,", "and", "maby", "eax", "to", "since", "is", "fav", "*/", "/*", "when", "need", "to", "store", "flags/pass", "arg,", "can", "always", "add", "more", "location", "later", "*/", "/*", "probably", "cleaner", "way", "of", "getting", "addresses", "but", "who", "cares", "for", "now", "*/", "set_address_val", "(", "state", ",", "opnd_get_disp", "(", "opnd_create_dcontext_field", "(", "state", "->", "dcontext", ",", "XCX_OFFSET", ")", ")", ",", "0", ",", "PS_KEEP", ")", ";", "set_address_val", "(", "state", ",", "opnd_get_disp", "(", "opnd_create_dcontext_field", "(", "state", "->", "dcontext", ",", "XAX_OFFSET", ")", ")", ",", "0", ",", "PS_KEEP", ")", ";", "}'" ]

[ "removes", "the", "address", "from", "the", "constant", "address", "cache" ]

[ "'static", "void", "clear_address_val", "(", "prop_state_t", "*", "state", ",", "int", "address", ")", "{", "#", "ifdef", "DEBUG", "dcontext_t", "*", "dcontext", "=", "state", "->", "dcontext", ";", "#", "endif", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_CONSTANT_ADDRESS", ";", "i", "++", ")", "{", "if", "(", "state", "->", "addresses", "[", "i", "]", "==", "address", ")", "{", "state", "->", "address_state", "[", "i", "]", "&=", "PS_KEEP", ";", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"", "load", "constant", "cache", "cleared:", "\"", "PFX", "\"\\\"", ",", "address", ")", ";", "}", "}", "}'" ]

[ "attempts", "to", "simplify", "the", "opnd", "with", "propagated", "information" ]

[ "'static", "opnd_t", "propagate_opnd", "(", "opnd_t", "old", ",", "prop_state_t", "*", "state", ",", "bool", "prefix_data", ")", "{", "reg_id_t", "reg", ";", "int", "immed", ",", "<type", "ref=\"prev\"/>", "disp", ",", "<type", "ref=\"prev\"/>", "i", ";", "opnd_size_t", "size", "=", "OPSZ_NA", ";", "#", "ifdef", "DEBUG", "dcontext_t", "*", "dcontext", "=", "state", "->", "dcontext", ";", "#", "endif", "if", "(", "opnd_is_reg", "(", "old", ")", ")", "{", "reg", "=", "opnd_get_reg", "(", "old", ")", "-", "REG_START_32", ";", "if", "(", "reg", "<", "8", "/*", "rules", "out", "underflow", "*/", ")", "{", "if", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", ")", "{", "immed", "=", "state", "->", "reg_vals", "[", "reg", "]", ";", "return", "opnd_create_immed_int", "(", "immed", ",", "OPSZ_4", ")", ";", "}", "else", "return", "old", ";", "}", "reg", "=", "opnd_get_reg", "(", "old", ")", "-", "REG_START_16", ";", "if", "(", "reg", "<", "8", "/*", "rules", "out", "underflow", "*/", ")", "{", "if", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "||", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_LVALID_VAL", ")", "!=", "0", "&&", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_HVALID_VAL", ")", "!=", "0", ")", ")", "{", "/*", "mask", "out", "top", "part", "of", "register", "*/", "immed", "=", "state", "->", "reg_vals", "[", "reg", "]", "&", "0x0000ffff", ";", "/*", "sign", "extend", "if", "negative", "*/", "if", "(", "(", "immed", "&", "0x00008000", ")", "!=", "0", ")", "immed", "|=", "0xffff0000", ";", "return", "opnd_create_immed_int", "(", "immed", ",", "OPSZ_2", ")", ";", "}", "else", "return", "old", ";", "}", "reg", "=", "opnd_get_reg", "(", "old", ")", "-", "REG_START_8", ";", "if", "(", "reg", "<", "4", "/*", "rules", "out", "underflow", "*/", "&&", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "||", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_LVALID_VAL", ")", "!=", "0", ")", ")", "{", "/*", "is", "low", "part", "*/", "/*", "mask", "out", "top", "part", "of", "register", "*/", "immed", "=", "state", "->", "reg_vals", "[", "reg", "]", "&", "0x000000ff", ";", "/*", "sign", "extend", "if", "negative", "*/", "if", "(", "(", "immed", "&", "0x00000080", ")", "!=", "0", ")", "immed", "|=", "0xffffff00", ";", "return", "opnd_create_immed_int", "(", "immed", ",", "OPSZ_1", ")", ";", "}", "reg", "-=", "4", ";", "if", "(", "reg", "<", "4", "/*", "rules", "out", "underflow", "*/", "&&", "(", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_VALID_VAL", ")", "!=", "0", "||", "(", "state", "->", "reg_state", "[", "reg", "]", "&", "PS_HVALID_VAL", ")", "!=", "0", ")", ")", "{", "/*", "is", "high", "part", "*/", "/*", "mask", "out", "part", "of", "register", "*/", "immed", "=", "state", "->", "reg_vals", "[", "reg", "]", "&", "0x0000ff00", ";", "/*", "shift", "*/", "immed", "=", "immed", ">>", "8", ";", "/*", "sign", "extend", "if", "negative", "*/", "if", "(", "(", "immed", "&", "0x00000080", ")", "!=", "0", ")", "immed", "|=", "0xffffff00", ";", "return", "opnd_create_immed_int", "(", "immed", ",", "OPSZ_1", ")", ";", "}", "return", "old", ";", "}", "old", "=", "propagate_address", "(", "old", ",", "state", ")", ";", "/*", "if", "address,", "get", "size", "*/", "if", "(", "opnd_is_memory_reference", "(", "old", ")", ")", "{", "size", "=", "opnd_get_size", "(", "old", ")", ";", "/*", "handle", "variable", "size", "*/", "if", "(", "size", "==", "OPSZ_4_short2", ")", "{", "if", "(", "prefix_data", ")", "size", "=", "OPSZ_2", ";", "else", "size", "=", "OPSZ_4", ";", "}", "}", "if", "(", "opnd_is_stack_address", "(", "old", ")", "&&", "cp_local_aggr", ">", "0", ")", "{", "//", "check", "stack", "value", "disp", "=", "opnd_get_disp", "(", "old", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_STACK_SLOTS", ";", "i", "++", ")", "{", "if", "(", "state", "->", "stack_offsets_ebp", "[", "i", "]", "==", "disp", "&&", "state", "->", "cur_scope", "==", "state", "->", "stack_scope", "[", "i", "]", "&&", "(", "state", "->", "stack_address_state", "[", "i", "]", "&", "PS_VALID_VAL", ")", "!=", "0", ")", "{", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"", "at", "stack", "depth", "%d", "\"", ",", "state", "->", "cur_scope", ")", ";", "d_r_logopnd", "(", "state", "->", "dcontext", ",", "3", ",", "old", ",", "\"", "found", "cached", "stack", "address\"", ")", ";", "immed", "=", "state", "->", "stack_vals", "[", "i", "]", ";", "return", "opnd_create_immed_int", "(", "immed", ",", "size", ")", ";", "}", "}", "}", "if", "(", "opnd_is_constant_address", "(", "old", ")", "&&", "cp_global_aggr", ">", "0", ")", "{", "if", "(", "const_address_const_mem", "(", "old", ",", "state", ",", "prefix_data", ")", ")", "{", "#", "ifdef", "DEBUG", "d_r_logopnd", "(", "state", "->", "dcontext", ",", "2", ",", "old", ",", "\"", "found", "const", "address", "const", "mem\\\"", ")", ";", "opt_stats_t", ".", "num_const_add_const_mem", "++", ";", "#", "endif", "immed", "=", "get_immutable_value", "(", "old", ",", "state", ",", "size", ")", ";", "return", "opnd_create_immed_int", "(", "immed", ",", "size", ")", ";", "}", "else", "{", "//", "check", "for", "constant", "address", "disp", "=", "opnd_get_disp", "(", "old", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_CONSTANT_ADDRESS", ";", "i", "++", ")", "{", "if", "(", "state", "->", "addresses", "[", "i", "]", "==", "disp", "&&", "(", "state", "->", "address_state", "[", "i", "]", "&", "PS_VALID_VAL", ")", "!=", "0", ")", "{", "d_r_logopnd", "(", "state", "->", "dcontext", ",", "3", ",", "old", ",", "\"", "found", "cached", "constant", "address\\\"", ")", ";", "immed", "=", "state", "->", "address_vals", "[", "i", "]", ";", "return", "opnd_create_immed_int", "(", "immed", ",", "size", ")", ";", "}", "}", "}", "}", "return", "old", ";", "}'" ]

[ "replaces", "inst", "with", "a", "mov", "imm", "of", "value", "to", "the", "same", "dst" ]

[ "'static", "instr_t", "*", "make_to_imm_store", "(", "instr_t", "*", "inst", ",", "int", "value", ",", "prop_state_t", "*", "state", ")", "{", "instr_t", "*", "replacement", ";", "opnd_t", "dst", "=", "instr_get_dst", "(", "inst", ",", "0", ")", ";", "dcontext_t", "*", "dcontext", "=", "state", "->", "dcontext", ";", "if", "(", "value", "==", "0", "&&", "opnd_is_reg", "(", "dst", ")", ")", "{", "replacement", "=", "INSTR_CREATE_xor", "(", "dcontext", ",", "dst", ",", "dst", ")", ";", "if", "(", "instr_get_prefix_flag", "(", "inst", ",", "PREFIX_DATA", ")", ")", "{", "instr_set_prefix_flag", "(", "replacement", ",", "PREFIX_DATA", ")", ";", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"carrying", "data", "prefix", "over", "%d\\\"", ",", "instr_get_prefixes", "(", "inst", ")", ")", ";", "}", "if", "(", "do_forward_check_eflags", "(", "inst", ",", "0", ",", "0", ",", "EFLAGS_WRITE_TO_READ", "(", "instr_get_eflags", "(", "replacement", ",", "DR_QUERY_DEFAULT", ")", ")", ",", "state", ")", ")", "{", "/*", "check", "size", "prefixes,", "ignore", "lock", "and", "addr", "prefix", "*/", "replace_inst", "(", "dcontext", ",", "state", "->", "trace", ",", "inst", ",", "replacement", ")", ";", "return", "replacement", ";", "}", "else", "{", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"", "unable", "to", "simplify", "move", "zero", "to", "xor,", "e-flags", "check", "failed", "\"", ")", ";", "instr_destroy", "(", "dcontext", ",", "replacement", ")", ";", "}", "}", "/*", "is", "always", "creating", "the", "right", "sized", "imm?", "*/", "replacement", "=", "INSTR_CREATE_mov_st", "(", "state", "->", "dcontext", ",", "dst", ",", "opnd_create_immed_int", "(", "value", ",", "opnd_get_size", "(", "dst", ")", ")", ")", ";", "/*", "handle", "prefixes,", "imm->reg", "(data)", "imm->mem", "(data", "&", "addr)", "*/", "if", "(", "instr_get_prefix_flag", "(", "inst", ",", "PREFIX_DATA", ")", ")", "{", "instr_set_prefix_flag", "(", "replacement", ",", "PREFIX_DATA", ")", ";", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"carrying", "data", "prefix", "over", "%d\\\"", ",", "instr_get_prefixes", "(", "inst", ")", ")", ";", "}", "if", "(", "instr_get_prefix_flag", "(", "inst", ",", "PREFIX_ADDR", ")", "&&", "opnd_is_memory_reference", "(", "dst", ")", ")", "{", "instr_set_prefix_flag", "(", "replacement", ",", "PREFIX_ADDR", ")", ";", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"carrying", "addr", "prefix", "over", "%d\\\"", ",", "instr_get_prefixes", "(", "inst", ")", ")", ";", "}", "replace_inst", "(", "dcontext", ",", "state", "->", "trace", ",", "inst", ",", "replacement", ")", ";", "return", "replacement", ";", "}'" ]

[ "removes", "the", "return", "code,", "pattern", "matches", "on", "our", "return", "macro" ]

[ "'static", "instr_t", "*", "remove_return", "(", "dcontext_t", "*", "dcontext", ",", "instrlist_t", "*", "trace", ",", "instr_t", "*", "inst", ")", "{", "if", "(", "!", "INTERNAL_OPTION", "(", "unsafe_ignore_eflags_trace", ")", ")", "{", "instr_t", "*", "inst2", ";", "int", "to_pop", "=", "4", ";", "opnd_t", "replacement", ";", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_returns_removed", "++", ";", "opt_stats_t", ".", "num_return_instrs_removed", "+=", "6", ";", "#", "endif", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_mov_st", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_pop", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "if", "(", "instr_get_opcode", "(", "inst2", ")", "==", "OP_lea", ")", "{", "/*", "this", "popping", "of", "the", "stack,", "lea", "*/", "to_pop", "+=", "opnd_get_disp", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_return_instrs_removed", "++", ";", "#", "endif", "}", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_lea", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_jecxz", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_lea", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_jmp", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_mov_ld", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "/*", "check", "for", "add", "here,", "is", "not", "uncommon", "to", "pop", "off", "the", "args", "after", "a", "return,", "*", "if", "so", "can", "save", "an", "instruction", "*/", "if", "(", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_add", ")", "&&", "opnd_is_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "&&", "(", "opnd_get_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "==", "REG_ESP", ")", "&&", "opnd_is_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ")", "{", "to_pop", "+=", "(", "int", ")", "opnd_get_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ";", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_return_instrs_removed", "++", ";", "#", "endif", "if", "(", "to_pop", "==", "0", ")", "{", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_return_instrs_removed", "++", ";", "#", "endif", "return", "inst", ";", "}", "if", "(", "(", "to_pop", "<=", "127", ")", "&&", "(", "to_pop", ">=", "-", "128", ")", ")", "{", "replacement", "=", "OPND_CREATE_INT8", "(", "to_pop", ")", ";", "}", "else", "{", "replacement", "=", "OPND_CREATE_INT32", "(", "to_pop", ")", ";", "}", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"", "updating", "stack", "adjustment", ":\"", ")", ";", "instr_set_src", "(", "inst", ",", "0", ",", "replacement", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"", "to", ":\"", ")", ";", "return", "inst", ";", "}", "if", "(", "check_eflags_cr", "(", "inst", ")", ")", "{", "if", "(", "(", "to_pop", "<=", "127", ")", "&&", "(", "to_pop", ">=", "-", "128", ")", ")", "{", "replacement", "=", "OPND_CREATE_INT8", "(", "to_pop", ")", ";", "}", "else", "{", "replacement", "=", "OPND_CREATE_INT32", "(", "to_pop", ")", ";", "}", "inst2", "=", "INSTR_CREATE_add", "(", "dcontext", ",", "opnd_create_reg", "(", "REG_ESP", ")", ",", "replacement", ")", ";", "}", "else", "{", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"Forward", "eflags", "check", "failed", "using", "lea", "to", "adjust", "stack", "instead", "of", "add\"", ")", ";", "inst2", "=", "INSTR_CREATE_lea", "(", "dcontext", ",", "opnd_create_reg", "(", "REG_ESP", ")", ",", "opnd_create_base_disp", "(", "REG_ESP", ",", "REG_NULL", ",", "0", ",", "to_pop", ",", "OPSZ_lea", ")", ")", ";", "}", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst2", ",", "\"adjusting", "stack\"", ")", ";", "instrlist_preinsert", "(", "trace", ",", "inst", ",", "inst2", ")", ";", "return", "inst2", ";", "}", "else", "return", "remove_return_no_save_eflags", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "}'" ]

[ "removes", "the", "return", "code,", "pattern", "matches", "on", "our", "return", "macro" ]

[ "'static", "instr_t", "*", "remove_return_no_save_eflags", "(", "dcontext_t", "*", "dcontext", ",", "instrlist_t", "*", "trace", ",", "instr_t", "*", "inst", ")", "{", "instr_t", "*", "inst2", ";", "int", "to_pop", "=", "4", ";", "opnd_t", "replacement", ";", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_returns_removed", "++", ";", "opt_stats_t", ".", "num_return_instrs_removed", "+=", "4", ";", "#", "endif", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_mov_st", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_pop", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_lea", ")", "{", "/*", "this", "popping", "of", "the", "stack,", "lea", "*/", "to_pop", "+=", "opnd_get_disp", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_return_instrs_removed", "++", ";", "#", "endif", "}", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_cmp", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_jne", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "inst2", "=", "instr_get_next", "(", "inst", ")", ";", "ASSERT", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_mov_ld", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"removing\"", ")", ";", "remove_inst", "(", "dcontext", ",", "trace", ",", "inst", ")", ";", "inst", "=", "inst2", ";", "/*", "check", "for", "add", "here,", "is", "not", "uncommon", "to", "pop", "off", "the", "args", "after", "a", "return,", "if", "so", "*/", "/*", "can", "save", "an", "instruction", "*/", "if", "(", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_add", ")", "&&", "opnd_is_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "&&", "(", "opnd_get_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "==", "REG_ESP", ")", "&&", "opnd_is_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ")", "{", "to_pop", "+=", "(", "int", ")", "opnd_get_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ";", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_return_instrs_removed", "++", ";", "#", "endif", "if", "(", "to_pop", "==", "0", ")", "{", "#", "ifdef", "DEBUG", "opt_stats_t", ".", "num_return_instrs_removed", "++", ";", "#", "endif", "return", "inst", ";", "}", "if", "(", "(", "to_pop", "<=", "127", ")", "&&", "(", "to_pop", ">=", "-", "128", ")", ")", "{", "replacement", "=", "OPND_CREATE_INT8", "(", "to_pop", ")", ";", "}", "else", "{", "replacement", "=", "OPND_CREATE_INT32", "(", "to_pop", ")", ";", "}", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"", "updating", "stack", "adjustment", ":\"", ")", ";", "instr_set_src", "(", "inst", ",", "0", ",", "replacement", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst", ",", "\"", "to", ":\"", ")", ";", "return", "inst", ";", "}", "if", "(", "(", "to_pop", "<=", "127", ")", "&&", "(", "to_pop", ">=", "-", "128", ")", ")", "{", "replacement", "=", "OPND_CREATE_INT8", "(", "to_pop", ")", ";", "}", "else", "{", "replacement", "=", "OPND_CREATE_INT32", "(", "to_pop", ")", ";", "}", "inst2", "=", "INSTR_CREATE_add", "(", "dcontext", ",", "opnd_create_reg", "(", "REG_ESP", ")", ",", "replacement", ")", ";", "d_r_loginst", "(", "dcontext", ",", "3", ",", "inst2", ",", "\"adjusting", "stack\"", ")", ";", "instrlist_preinsert", "(", "trace", ",", "inst", ",", "inst2", ")", ";", "return", "inst2", ";", "}'" ]

[ "adds", "an", "address", "value", "pair", "to", "the", "constant", "address", "cache" ]

[ "'static", "void", "set_address_val", "(", "prop_state_t", "*", "state", ",", "int", "address", ",", "int", "val", ",", "byte", "flags", ")", "{", "#", "ifdef", "DEBUG", "dcontext_t", "*", "dcontext", "=", "state", "->", "dcontext", ";", "#", "endif", "bool", "cont", "=", "true", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "(", "i", "<", "NUM_CONSTANT_ADDRESS", ")", "&&", "cont", ";", "i", "++", ")", "{", "if", "(", "state", "->", "address_state", "[", "i", "]", "==", "0", ")", "{", "state", "->", "addresses", "[", "i", "]", "=", "address", ";", "state", "->", "address_vals", "[", "i", "]", "=", "val", ";", "state", "->", "address_state", "[", "i", "]", "=", "flags", ";", "cont", "=", "false", ";", "}", "}", "if", "(", "cont", ")", "{", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"constant", "address", "cache", "overflow\\\"", ")", ";", "i", "=", "address", "%", "NUM_CONSTANT_ADDRESS", ";", "ASSERT", "(", "i", ">", "0", "&&", "i", "<", "NUM_CONSTANT_ADDRESS", ")", ";", "state", "->", "addresses", "[", "i", "]", "=", "address", ";", "state", "->", "address_vals", "[", "i", "]", "=", "val", ";", "state", "->", "address_state", "[", "i", "]", "=", "flags", ";", "}", "LOG", "(", "THREAD", ",", "LOG_OPTS", ",", "3", ",", "\"", "load", "const", "cache", "add:", "\"", "PFX", "\"", "val", "\"", "PFX", "\"", "flags", "0x%02x\\\"", ",", "address", ",", "val", ",", "flags", ")", ";", "}'" ]

[ "Remove", "any", "fallthru", "edge", "from", "EV" ]

[ "'static", "bool", "remove_fallthru_edge", "(", "vec", "<argument_list", "type=\"generic\">", "<", "edge", ",", "va_gc", ">", "*", "ev", ")", "{", "edge_iterator", "ei", ";", "edge", "e", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "ev", ")", "if", "(", "(", "e", "->", "flags", "&", "EDGE_FALLTHRU", ")", "!=", "0", ")", "{", "remove_edge_and_dominated_blocks", "(", "e", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}'" ]

[ "Cleanup", "cfg", "and", "repair", "loop", "structures" ]

[ "'bool", "cleanup_tree_cfg", "(", "void", ")", "{", "bool", "changed", "=", "cleanup_tree_cfg_noloop", "()", ";", "if", "(", "current_loops", "!=", "NULL", "&&", "loops_state_satisfies_p", "(", "LOOPS_NEED_FIXUP", ")", ")", "repair_loop_structures", "()", ";", "return", "changed", ";", "}'" ]

[ "Find", "UNDI", "ROM", "for", "PCI", "device" ]

[ "'struct", "undi_rom", "*", "undirom_find_pci", "(", "unsigned", "int", "vendor_id", ",", "unsigned", "int", "device_id", ",", "unsigned", "int", "rombase", ")", "{", "struct", "undi_rom", "*", "undirom", ";", "undirom_probe_all_roms", "()", ";", "list_for_each_entry", "(", "undirom", ",", "&undiroms", ",", "list", ")", "{", "if", "(", "undirom", "->", "bus_type", "!=", "PCI_NIC", ")", "continue;", "if", "(", "undirom", "->", "bus_id", ".", "pci", ".", "vendor_id", "!=", "vendor_id", ")", "continue;", "if", "(", "undirom", "->", "bus_id", ".", "pci", ".", "device_id", "!=", "device_id", ")", "continue;", "if", "(", "rombase", "&&", "(", "(", "undirom", "->", "rom_segment", "<<", "4", ")", "!=", "rombase", ")", ")", "continue;", "DBGC", "(", "undirom", ",", "\"UNDIROM", "%p", "matched", "PCI", "%04x:%04x", "(%08x)\\\"", ",", "undirom", ",", "vendor_id", ",", "device_id", ",", "rombase", ")", ";", "return", "undirom", ";", "}", "DBG", "(", "\"No", "UNDI", "ROM", "matched", "PCI", "%04x:%04x", "(%08x)\\\"", ",", "vendor_id", ",", "device_id", ",", "rombase", ")", ";", "return", "NULL", ";", "}'" ]

[ "Return", "`nbytes`,", "`cbytes`", "and", "`blocksize`", "from", "a", "compressed", "buffer" ]

[ "'void", "blosc_cbuffer_sizes", "(", "const", "void", "*", "cbuffer", ",", "size_t", "*", "nbytes", ",", "size_t", "*", "cbytes", ",", "size_t", "*", "blocksize", ")", "{", "uint8_t", "*", "_src", "=", "(", "uint8_t", "*", ")", "(", "cbuffer", ")", ";", "/*", "current", "pos", "for", "source", "buffer", "*/", "uint8_t", "version", "=", "_src", "[", "0", "]", ";", "/*", "version", "of", "header", "*/", "if", "(", "version", "!=", "BLOSC_VERSION_FORMAT", ")", "{", "*", "nbytes", "=", "*", "blocksize", "=", "*", "cbytes", "=", "0", ";", "return", ";", "}", "/*", "Read", "the", "interesting", "values", "*/", "*", "nbytes", "=", "(", "size_t", ")", "sw32_", "(", "_src", "+", "4", ")", ";", "/*", "uncompressed", "buffer", "size", "*/", "*", "blocksize", "=", "(", "size_t", ")", "sw32_", "(", "_src", "+", "8", ")", ";", "/*", "block", "size", "*/", "*", "cbytes", "=", "(", "size_t", ")", "sw32_", "(", "_src", "+", "12", ")", ";", "/*", "compressed", "buffer", "size", "*/", "}'" ]

[ "The", "public", "routine", "for", "compression" ]

[ "'int", "blosc_compress", "(", "int", "clevel", ",", "int", "doshuffle", ",", "size_t", "typesize", ",", "size_t", "nbytes", ",", "const", "void", "*", "src", ",", "void", "*", "dest", ",", "size_t", "destsize", ")", "{", "int", "error", ";", "int", "result", ";", "char", "*", "envvar", ";", "/*", "Check", "if", "should", "initialize", "*/", "if", "(", "!", "g_initlib", ")", "blosc_init", "()", ";", "/*", "Check", "for", "a", "BLOSC_CLEVEL", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_CLEVEL\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "long", "value", ";", "value", "=", "strtol", "(", "envvar", ",", "NULL", ",", "10", ")", ";", "if", "(", "(", "value", "!=", "EINVAL", ")", "&&", "(", "value", ">=", "0", ")", ")", "{", "clevel", "=", "(", "int", ")", "value", ";", "}", "}", "/*", "Check", "for", "a", "BLOSC_SHUFFLE", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_SHUFFLE\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "if", "(", "strcmp", "(", "envvar", ",", "\"NOSHUFFLE\"", ")", "==", "0", ")", "{", "doshuffle", "=", "BLOSC_NOSHUFFLE", ";", "}", "if", "(", "strcmp", "(", "envvar", ",", "\"SHUFFLE\"", ")", "==", "0", ")", "{", "doshuffle", "=", "BLOSC_SHUFFLE", ";", "}", "if", "(", "strcmp", "(", "envvar", ",", "\"BITSHUFFLE\"", ")", "==", "0", ")", "{", "doshuffle", "=", "BLOSC_BITSHUFFLE", ";", "}", "}", "/*", "Check", "for", "a", "BLOSC_TYPESIZE", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_TYPESIZE\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "long", "value", ";", "value", "=", "strtol", "(", "envvar", ",", "NULL", ",", "10", ")", ";", "if", "(", "(", "value", "!=", "EINVAL", ")", "&&", "(", "value", ">", "0", ")", ")", "{", "typesize", "=", "(", "int", ")", "value", ";", "}", "}", "/*", "Check", "for", "a", "BLOSC_COMPRESSOR", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_COMPRESSOR\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "result", "=", "blosc_set_compressor", "(", "envvar", ")", ";", "if", "(", "result", "<", "0", ")", "{", "return", "result", ";", "}", "}", "/*", "Check", "for", "a", "BLOSC_COMPRESSOR", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_BLOCKSIZE\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "long", "blocksize", ";", "blocksize", "=", "strtol", "(", "envvar", ",", "NULL", ",", "10", ")", ";", "if", "(", "(", "blocksize", "!=", "EINVAL", ")", "&&", "(", "blocksize", ">", "0", ")", ")", "{", "blosc_set_blocksize", "(", "(", "size_t", ")", "blocksize", ")", ";", "}", "}", "/*", "Check", "for", "a", "BLOSC_NTHREADS", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_NTHREADS\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "long", "nthreads", ";", "nthreads", "=", "strtol", "(", "envvar", ",", "NULL", ",", "10", ")", ";", "if", "(", "(", "nthreads", "!=", "EINVAL", ")", "&&", "(", "nthreads", ">", "0", ")", ")", "{", "result", "=", "blosc_set_nthreads", "(", "(", "int", ")", "nthreads", ")", ";", "if", "(", "result", "<", "0", ")", "{", "return", "result", ";", "}", "}", "}", "/*", "Check", "for", "a", "BLOSC_SPLITMODE", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_SPLITMODE\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "if", "(", "strcmp", "(", "envvar", ",", "\"FORWARD_COMPAT\"", ")", "==", "0", ")", "{", "blosc_set_splitmode", "(", "BLOSC_FORWARD_COMPAT_SPLIT", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "envvar", ",", "\"AUTO\"", ")", "==", "0", ")", "{", "blosc_set_splitmode", "(", "BLOSC_AUTO_SPLIT", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "envvar", ",", "\"ALWAYS\"", ")", "==", "0", ")", "{", "blosc_set_splitmode", "(", "BLOSC_ALWAYS_SPLIT", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "envvar", ",", "\"NEVER\"", ")", "==", "0", ")", "{", "blosc_set_splitmode", "(", "BLOSC_NEVER_SPLIT", ")", ";", "}", "else", "{", "fprintf", "(", "stderr", ",", "\"BLOSC_SPLITMODE", "environment", "variable", "\\'%s\\'", "not", "recognized\\\"", ",", "envvar", ")", ";", "return", "-", "1", ";", "}", "}", "/*", "Check", "for", "a", "BLOSC_NOLOCK", "environment", "variable.", "It", "is", "important", "that", "this", "should", "be", "the", "last", "env", "var", "so", "that", "it", "can", "take", "the", "previous", "ones", "into", "account", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_NOLOCK\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "const", "char", "*", "compname", ";", "blosc_compcode_to_compname", "(", "g_compressor", ",", "&", "compname", ")", ";", "result", "=", "blosc_compress_ctx", "(", "clevel", ",", "doshuffle", ",", "typesize", ",", "nbytes", ",", "src", ",", "dest", ",", "destsize", ",", "compname", ",", "g_force_blocksize", ",", "g_threads", ")", ";", "return", "result", ";", "}", "pthread_mutex_lock", "(", "&", "global_comp_mutex", ")", ";", "error", "=", "initialize_context_compression", "(", "g_global_context", ",", "clevel", ",", "doshuffle", ",", "typesize", ",", "nbytes", ",", "src", ",", "dest", ",", "destsize", ",", "g_compressor", ",", "g_force_blocksize", ",", "g_threads", ")", ";", "if", "(", "error", "<", "0", ")", "{", "return", "error", ";", "}", "error", "=", "write_compression_header", "(", "g_global_context", ",", "clevel", ",", "doshuffle", ")", ";", "if", "(", "error", "<", "0", ")", "{", "return", "error", ";", "}", "result", "=", "blosc_compress_context", "(", "g_global_context", ")", ";", "pthread_mutex_unlock", "(", "&", "global_comp_mutex", ")", ";", "return", "result", ";", "}'" ]

[ "Decompress", "&", "unshuffle", "several", "blocks", "in", "a", "single", "thread" ]

[ "'static", "void", "*", "t_blosc", "(", "void", "*", "ctxt", ")", "{", "struct", "thread_context", "*", "context", "=", "(", "struct", "thread_context", "*", ")", "ctxt", ";", "int32_t", "cbytes", ",", "<type", "ref=\"prev\"/>", "ntdest", ";", "int32_t", "tblocks", ";", "/*", "number", "of", "blocks", "per", "thread", "*/", "int32_t", "leftover2", ";", "int32_t", "tblock", ";", "/*", "limit", "block", "on", "a", "thread", "*/", "int32_t", "nblock_", ";", "/*", "private", "copy", "of", "nblock", "*/", "int32_t", "bsize", ",", "<type", "ref=\"prev\"/>", "leftoverblock", ";", "/*", "Parameters", "for", "threads", "*/", "int32_t", "blocksize", ";", "int32_t", "ebsize", ";", "int32_t", "compress", ";", "int32_t", "maxbytes", ";", "int32_t", "ntbytes", ";", "int32_t", "flags", ";", "int32_t", "nblocks", ";", "int32_t", "leftover", ";", "uint8_t", "*", "bstarts", ";", "const", "uint8_t", "*", "src", ";", "uint8_t", "*", "dest", ";", "uint8_t", "*", "tmp", ";", "uint8_t", "*", "tmp2", ";", "uint8_t", "*", "tmp3", ";", "int", "rc", ";", "while", "(", "1", ")", "{", "/*", "Synchronization", "point", "for", "all", "threads", "(wait", "for", "initialization)", "*/", "WAIT_INIT", "(", "NULL", ",", "context", "->", "parent_context", ")", ";", "if", "(", "context", "->", "parent_context", "->", "end_threads", ")", "{", "break;", "}", "/*", "Get", "parameters", "for", "this", "thread", "before", "entering", "the", "main", "loop", "*/", "blocksize", "=", "context", "->", "parent_context", "->", "blocksize", ";", "ebsize", "=", "blocksize", "+", "context", "->", "parent_context", "->", "typesize", "*", "(", "int32_t", ")", "sizeof", "(", "int32_t", ")", ";", "compress", "=", "context", "->", "parent_context", "->", "compress", ";", "flags", "=", "*", "(", "context", "->", "parent_context", "->", "header_flags", ")", ";", "maxbytes", "=", "context", "->", "parent_context", "->", "destsize", ";", "nblocks", "=", "context", "->", "parent_context", "->", "nblocks", ";", "leftover", "=", "context", "->", "parent_context", "->", "leftover", ";", "bstarts", "=", "context", "->", "parent_context", "->", "bstarts", ";", "src", "=", "context", "->", "parent_context", "->", "src", ";", "dest", "=", "context", "->", "parent_context", "->", "dest", ";", "if", "(", "blocksize", ">", "context", "->", "tmpblocksize", ")", "{", "my_free", "(", "context", "->", "tmp", ")", ";", "context", "->", "tmp", "=", "my_malloc", "(", "blocksize", "+", "ebsize", "+", "blocksize", ")", ";", "context", "->", "tmp2", "=", "context", "->", "tmp", "+", "blocksize", ";", "context", "->", "tmp3", "=", "context", "->", "tmp", "+", "blocksize", "+", "ebsize", ";", "}", "tmp", "=", "context", "->", "tmp", ";", "tmp2", "=", "context", "->", "tmp2", ";", "tmp3", "=", "context", "->", "tmp3", ";", "ntbytes", "=", "0", ";", "/*", "only", "useful", "for", "decompression", "*/", "if", "(", "compress", "&&", "!", "(", "flags", "&", "BLOSC_MEMCPYED", ")", ")", "{", "/*", "Compression", "always", "has", "to", "follow", "the", "block", "order", "*/", "pthread_mutex_lock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "context", "->", "parent_context", "->", "thread_nblock", "++", ";", "nblock_", "=", "context", "->", "parent_context", "->", "thread_nblock", ";", "pthread_mutex_unlock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "tblock", "=", "nblocks", ";", "}", "else", "{", "/*", "Decompression", "can", "happen", "using", "any", "order.", "We", "choose", "sequential", "block", "order", "on", "each", "thread", "*/", "/*", "Blocks", "per", "thread", "*/", "tblocks", "=", "nblocks", "/", "context", "->", "parent_context", "->", "numthreads", ";", "leftover2", "=", "nblocks", "%", "context", "->", "parent_context", "->", "numthreads", ";", "tblocks", "=", "(", "leftover2", ">", "0", ")", "?", "tblocks", "+", "1", ":", "tblocks", ";", "nblock_", "=", "context", "->", "tid", "*", "tblocks", ";", "tblock", "=", "nblock_", "+", "tblocks", ";", "if", "(", "tblock", ">", "nblocks", ")", "{", "tblock", "=", "nblocks", ";", "}", "}", "/*", "Loop", "over", "blocks", "*/", "leftoverblock", "=", "0", ";", "while", "(", "(", "nblock_", "<", "tblock", ")", "&&", "context", "->", "parent_context", "->", "thread_giveup_code", ">", "0", ")", "{", "bsize", "=", "blocksize", ";", "if", "(", "nblock_", "==", "(", "nblocks", "-", "1", ")", "&&", "(", "leftover", ">", "0", ")", ")", "{", "bsize", "=", "leftover", ";", "leftoverblock", "=", "1", ";", "}", "if", "(", "compress", ")", "{", "if", "(", "flags", "&", "BLOSC_MEMCPYED", ")", "{", "/*", "We", "want", "to", "memcpy", "only", "*/", "fastcopy", "(", "dest", "+", "BLOSC_MAX_OVERHEAD", "+", "nblock_", "*", "blocksize", ",", "src", "+", "nblock_", "*", "blocksize", ",", "bsize", ")", ";", "cbytes", "=", "bsize", ";", "}", "else", "{", "/*", "Regular", "compression", "*/", "cbytes", "=", "blosc_c", "(", "context", "->", "parent_context", ",", "bsize", ",", "leftoverblock", ",", "0", ",", "ebsize", ",", "src", "+", "nblock_", "*", "blocksize", ",", "tmp2", ",", "tmp", ",", "tmp3", ")", ";", "}", "}", "else", "{", "if", "(", "flags", "&", "BLOSC_MEMCPYED", ")", "{", "/*", "We", "want", "to", "memcpy", "only", "*/", "fastcopy", "(", "dest", "+", "nblock_", "*", "blocksize", ",", "src", "+", "BLOSC_MAX_OVERHEAD", "+", "nblock_", "*", "blocksize", ",", "bsize", ")", ";", "cbytes", "=", "bsize", ";", "}", "else", "{", "cbytes", "=", "blosc_d", "(", "context", "->", "parent_context", ",", "bsize", ",", "leftoverblock", ",", "src", "+", "sw32_", "(", "bstarts", "+", "nblock_", "*", "4", ")", ",", "dest", "+", "nblock_", "*", "blocksize", ",", "tmp", ",", "tmp2", ")", ";", "}", "}", "/*", "Check", "whether", "current", "thread", "has", "to", "giveup", "*/", "if", "(", "context", "->", "parent_context", "->", "thread_giveup_code", "<=", "0", ")", "{", "break;", "}", "/*", "Check", "results", "for", "the", "compressed/decompressed", "block", "*/", "if", "(", "cbytes", "<", "0", ")", "{", "/*", "compr/decompr", "failure", "*/", "/*", "Set", "giveup_code", "error", "*/", "pthread_mutex_lock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "context", "->", "parent_context", "->", "thread_giveup_code", "=", "cbytes", ";", "pthread_mutex_unlock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "break;", "}", "if", "(", "compress", "&&", "!", "(", "flags", "&", "BLOSC_MEMCPYED", ")", ")", "{", "/*", "Start", "critical", "section", "*/", "pthread_mutex_lock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "ntdest", "=", "context", "->", "parent_context", "->", "num_output_bytes", ";", "_sw32", "(", "bstarts", "+", "nblock_", "*", "4", ",", "ntdest", ")", ";", "/*", "update", "block", "start", "counter", "*/", "if", "(", "(", "cbytes", "==", "0", ")", "||", "(", "ntdest", "+", "cbytes", ">", "maxbytes", ")", ")", "{", "context", "->", "parent_context", "->", "thread_giveup_code", "=", "0", ";", "/*", "uncompressible", "buffer", "*/", "pthread_mutex_unlock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "break;", "}", "context", "->", "parent_context", "->", "thread_nblock", "++", ";", "nblock_", "=", "context", "->", "parent_context", "->", "thread_nblock", ";", "context", "->", "parent_context", "->", "num_output_bytes", "+=", "cbytes", ";", "/*", "update", "return", "bytes", "counter", "*/", "pthread_mutex_unlock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "/*", "End", "of", "critical", "section", "*/", "/*", "Copy", "the", "compressed", "buffer", "to", "destination", "*/", "fastcopy", "(", "dest", "+", "ntdest", ",", "tmp2", ",", "cbytes", ")", ";", "}", "else", "{", "nblock_", "++", ";", "/*", "Update", "counter", "for", "this", "thread", "*/", "ntbytes", "+=", "cbytes", ";", "}", "}", "/*", "closes", "while", "(nblock_)", "*/", "/*", "Sum", "up", "all", "the", "bytes", "decompressed", "*/", "if", "(", "(", "!", "compress", "||", "(", "flags", "&", "BLOSC_MEMCPYED", ")", ")", "&&", "context", "->", "parent_context", "->", "thread_giveup_code", ">", "0", ")", "{", "/*", "Update", "global", "counter", "for", "all", "threads", "(decompression", "only)", "*/", "pthread_mutex_lock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "context", "->", "parent_context", "->", "num_output_bytes", "+=", "ntbytes", ";", "pthread_mutex_unlock", "(", "&", "context", "->", "parent_context", "->", "count_mutex", ")", ";", "}", "/*", "Meeting", "point", "for", "all", "threads", "(wait", "for", "finalization)", "*/", "WAIT_FINISH", "(", "NULL", ",", "context", "->", "parent_context", ")", ";", "}", "/*", "Cleanup", "our", "working", "space", "and", "context", "*/", "my_free", "(", "context", "->", "tmp", ")", ";", "my_free", "(", "context", ")", ";", "return", "(", "NULL", ")", ";", "}'" ]

[ "The", "public", "routine", "for", "compression", "with", "context" ]

[ "'int", "blosc_compress_ctx", "(", "int", "clevel", ",", "int", "doshuffle", ",", "size_t", "typesize", ",", "size_t", "nbytes", ",", "const", "void", "*", "src", ",", "void", "*", "dest", ",", "size_t", "destsize", ",", "const", "char", "*", "compressor", ",", "size_t", "blocksize", ",", "int", "numinternalthreads", ")", "{", "int", "error", ",", "<type", "ref=\"prev\"/>", "result", ";", "struct", "blosc_context", "context", ";", "context", ".", "threads_started", "=", "0", ";", "error", "=", "initialize_context_compression", "(", "&", "context", ",", "clevel", ",", "doshuffle", ",", "typesize", ",", "nbytes", ",", "src", ",", "dest", ",", "destsize", ",", "blosc_compname_to_compcode", "(", "compressor", ")", ",", "blocksize", ",", "numinternalthreads", ")", ";", "if", "(", "error", "<", "0", ")", "{", "return", "error", ";", "}", "error", "=", "write_compression_header", "(", "&", "context", ",", "clevel", ",", "doshuffle", ")", ";", "if", "(", "error", "<", "0", ")", "{", "return", "error", ";", "}", "result", "=", "blosc_compress_context", "(", "&", "context", ")", ";", "if", "(", "numinternalthreads", ">", "1", ")", "{", "blosc_release_threadpool", "(", "&", "context", ")", ";", "}", "return", "result", ";", "}'" ]

[ "Return", "the", "compressor", "library", "format", "used", "in", "a", "compressed", "buffer" ]

[ "'const", "char", "*", "blosc_cbuffer_complib", "(", "const", "void", "*", "cbuffer", ")", "{", "uint8_t", "*", "_src", "=", "(", "uint8_t", "*", ")", "(", "cbuffer", ")", ";", "/*", "current", "pos", "for", "source", "buffer", "*/", "int", "clibcode", ";", "const", "char", "*", "complib", ";", "/*", "Read", "the", "compressor", "format/library", "info", "*/", "clibcode", "=", "(", "_src", "[", "2", "]", "&", "0xe0", ")", ">>", "5", ";", "complib", "=", "clibcode_to_clibname", "(", "clibcode", ")", ";", "return", "complib", ";", "}'" ]

[ "Get", "the", "compressor", "code", "for", "the", "compressor", "name" ]

[ "'int", "blosc_compname_to_compcode", "(", "const", "char", "*", "compname", ")", "{", "int", "code", "=", "-", "1", ";", "/*", "-1", "means", "non-existent", "compressor", "code", "*/", "if", "(", "strcmp", "(", "compname", ",", "BLOSC_BLOSCLZ_COMPNAME", ")", "==", "0", ")", "{", "code", "=", "BLOSC_BLOSCLZ", ";", "}", "#", "if", "defined", "(", "HAVE_LZ4", ")", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "compname", ",", "BLOSC_LZ4_COMPNAME", ")", "==", "0", ")", "{", "code", "=", "BLOSC_LZ4", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "compname", ",", "BLOSC_LZ4HC_COMPNAME", ")", "==", "0", ")", "{", "code", "=", "BLOSC_LZ4HC", ";", "}", "#", "endif", "/*", "HAVE_LZ4", "*/", "#", "if", "defined", "(", "HAVE_SNAPPY", ")", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "compname", ",", "BLOSC_SNAPPY_COMPNAME", ")", "==", "0", ")", "{", "code", "=", "BLOSC_SNAPPY", ";", "}", "#", "endif", "/*", "HAVE_SNAPPY", "*/", "#", "if", "defined", "(", "HAVE_ZLIB", ")", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "compname", ",", "BLOSC_ZLIB_COMPNAME", ")", "==", "0", ")", "{", "code", "=", "BLOSC_ZLIB", ";", "}", "#", "endif", "/*", "HAVE_ZLIB", "*/", "#", "if", "defined", "(", "HAVE_ZSTD", ")", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "compname", ",", "BLOSC_ZSTD_COMPNAME", ")", "==", "0", ")", "{", "code", "=", "BLOSC_ZSTD", ";", "}", "#", "endif", "/*", "HAVE_ZSTD", "*/", "return", "code", ";", "}'" ]

[ "Force", "the", "use", "of", "a", "specific", "split", "mode" ]

[ "'void", "blosc_set_splitmode", "(", "int", "mode", ")", "{", "g_splitmode", "=", "mode", ";", "}'" ]

[ "Shuffle", "&", "compress", "a", "single", "block" ]

[ "'static", "int", "blosc_c", "(", "const", "struct", "blosc_context", "*", "context", ",", "int32_t", "blocksize", ",", "int32_t", "leftoverblock", ",", "int32_t", "ntbytes", ",", "int32_t", "maxbytes", ",", "const", "uint8_t", "*", "src", ",", "uint8_t", "*", "dest", ",", "uint8_t", "*", "tmp", ",", "uint8_t", "*", "tmp2", ")", "{", "int8_t", "header_flags", "=", "*", "(", "context", "->", "header_flags", ")", ";", "int", "dont_split", "=", "(", "header_flags", "&", "0x10", ")", ">>", "4", ";", "int32_t", "j", ",", "<type", "ref=\"prev\"/>", "neblock", ",", "<type", "ref=\"prev\"/>", "nsplits", ";", "int32_t", "cbytes", ";", "/*", "number", "of", "compressed", "bytes", "in", "split", "*/", "int32_t", "ctbytes", "=", "0", ";", "/*", "number", "of", "compressed", "bytes", "in", "block", "*/", "int32_t", "maxout", ";", "int32_t", "typesize", "=", "context", "->", "typesize", ";", "const", "uint8_t", "*", "_tmp", "=", "src", ";", "const", "char", "*", "compname", ";", "int", "accel", ";", "int", "bscount", ";", "int", "doshuffle", "=", "(", "header_flags", "&", "BLOSC_DOSHUFFLE", ")", "&&", "(", "typesize", ">", "1", ")", ";", "int", "dobitshuffle", "=", "(", "(", "header_flags", "&", "BLOSC_DOBITSHUFFLE", ")", "&&", "(", "blocksize", ">=", "typesize", ")", ")", ";", "if", "(", "doshuffle", ")", "{", "/*", "Byte", "shuffling", "only", "makes", "sense", "if", "typesize", ">", "1", "*/", "shuffle", "(", "typesize", ",", "blocksize", ",", "src", ",", "tmp", ")", ";", "_tmp", "=", "tmp", ";", "}", "/*", "We", "don\\'t", "allow", "more", "than", "1", "filter", "at", "the", "same", "time", "(yet)", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "dobitshuffle", ")", "{", "bscount", "=", "bitshuffle", "(", "typesize", ",", "blocksize", ",", "src", ",", "tmp", ",", "tmp2", ")", ";", "if", "(", "bscount", "<", "0", ")", "return", "bscount", ";", "_tmp", "=", "tmp", ";", "}", "/*", "Calculate", "acceleration", "for", "different", "compressors", "*/", "accel", "=", "get_accel", "(", "context", ")", ";", "/*", "The", "number", "of", "splits", "for", "this", "block", "*/", "if", "(", "!", "dont_split", "&&", "!", "leftoverblock", ")", "{", "nsplits", "=", "typesize", ";", "}", "else", "{", "nsplits", "=", "1", ";", "}", "neblock", "=", "blocksize", "/", "nsplits", ";", "for", "(", "j", "=", "0", ";", "j", "<", "nsplits", ";", "j", "++", ")", "{", "dest", "+=", "sizeof", "(", "int32_t", ")", ";", "ntbytes", "+=", "(", "int32_t", ")", "sizeof", "(", "int32_t", ")", ";", "ctbytes", "+=", "(", "int32_t", ")", "sizeof", "(", "int32_t", ")", ";", "maxout", "=", "neblock", ";", "#", "if", "defined", "(", "HAVE_SNAPPY", ")", "if", "(", "context", "->", "compcode", "==", "BLOSC_SNAPPY", ")", "{", "/*", "TODO", "perhaps", "refactor", "this", "to", "keep", "the", "value", "stashed", "somewhere", "*/", "maxout", "=", "snappy_max_compressed_length", "(", "neblock", ")", ";", "}", "#", "endif", "/*", "HAVE_SNAPPY", "*/", "if", "(", "ntbytes", "+", "maxout", ">", "maxbytes", ")", "{", "maxout", "=", "maxbytes", "-", "ntbytes", ";", "/*", "avoid", "buffer", "overrun", "*/", "if", "(", "maxout", "<=", "0", ")", "{", "return", "0", ";", "/*", "non-compressible", "block", "*/", "}", "}", "if", "(", "context", "->", "compcode", "==", "BLOSC_BLOSCLZ", ")", "{", "cbytes", "=", "blosclz_compress", "(", "context", "->", "clevel", ",", "_tmp", "+", "j", "*", "neblock", ",", "neblock", ",", "dest", ",", "maxout", ")", ";", "}", "#", "if", "defined", "(", "HAVE_LZ4", ")", "<if", "type=\"elseif\">", "else", "if", "(", "context", "->", "compcode", "==", "BLOSC_LZ4", ")", "{", "cbytes", "=", "lz4_wrap_compress", "(", "(", "char", "*", ")", "_tmp", "+", "j", "*", "neblock", ",", "(", "size_t", ")", "neblock", ",", "(", "char", "*", ")", "dest", ",", "(", "size_t", ")", "maxout", ",", "accel", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "context", "->", "compcode", "==", "BLOSC_LZ4HC", ")", "{", "cbytes", "=", "lz4hc_wrap_compress", "(", "(", "char", "*", ")", "_tmp", "+", "j", "*", "neblock", ",", "(", "size_t", ")", "neblock", ",", "(", "char", "*", ")", "dest", ",", "(", "size_t", ")", "maxout", ",", "context", "->", "clevel", ")", ";", "}", "#", "endif", "/*", "HAVE_LZ4", "*/", "#", "if", "defined", "(", "HAVE_SNAPPY", ")", "<if", "type=\"elseif\">", "else", "if", "(", "context", "->", "compcode", "==", "BLOSC_SNAPPY", ")", "{", "cbytes", "=", "snappy_wrap_compress", "(", "(", "char", "*", ")", "_tmp", "+", "j", "*", "neblock", ",", "(", "size_t", ")", "neblock", ",", "(", "char", "*", ")", "dest", ",", "(", "size_t", ")", "maxout", ")", ";", "}", "#", "endif", "/*", "HAVE_SNAPPY", "*/", "#", "if", "defined", "(", "HAVE_ZLIB", ")", "<if", "type=\"elseif\">", "else", "if", "(", "context", "->", "compcode", "==", "BLOSC_ZLIB", ")", "{", "cbytes", "=", "zlib_wrap_compress", "(", "(", "char", "*", ")", "_tmp", "+", "j", "*", "neblock", ",", "(", "size_t", ")", "neblock", ",", "(", "char", "*", ")", "dest", ",", "(", "size_t", ")", "maxout", ",", "context", "->", "clevel", ")", ";", "}", "#", "endif", "/*", "HAVE_ZLIB", "*/", "#", "if", "defined", "(", "HAVE_ZSTD", ")", "<if", "type=\"elseif\">", "else", "if", "(", "context", "->", "compcode", "==", "BLOSC_ZSTD", ")", "{", "cbytes", "=", "zstd_wrap_compress", "(", "(", "char", "*", ")", "_tmp", "+", "j", "*", "neblock", ",", "(", "size_t", ")", "neblock", ",", "(", "char", "*", ")", "dest", ",", "(", "size_t", ")", "maxout", ",", "context", "->", "clevel", ")", ";", "}", "#", "endif", "/*", "HAVE_ZSTD", "*/", "else", "{", "blosc_compcode_to_compname", "(", "context", "->", "compcode", ",", "&", "compname", ")", ";", "fprintf", "(", "stderr", ",", "\"Blosc", "has", "not", "been", "compiled", "with", "\\'%s\\'", "\"", ",", "compname", ")", ";", "fprintf", "(", "stderr", ",", "\"compression", "support.", "Please", "use", "one", "having", "it.\"", ")", ";", "return", "-", "5", ";", "/*", "signals", "no", "compression", "support", "*/", "}", "if", "(", "cbytes", ">", "maxout", ")", "{", "/*", "Buffer", "overrun", "caused", "by", "compression", "(should", "never", "happen)", "*/", "return", "-", "1", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "cbytes", "<", "0", ")", "{", "/*", "cbytes", "should", "never", "be", "negative", "*/", "return", "-", "2", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "cbytes", "==", "0", "||", "cbytes", "==", "neblock", ")", "{", "/*", "The", "compressor", "has", "been", "unable", "to", "compress", "data", "at", "all.", "*/", "/*", "Before", "doing", "the", "copy,", "check", "that", "we", "are", "not", "running", "into", "a", "buffer", "overflow.", "*/", "if", "(", "(", "ntbytes", "+", "neblock", ")", ">", "maxbytes", ")", "{", "return", "0", ";", "/*", "Non-compressible", "data", "*/", "}", "fastcopy", "(", "dest", ",", "_tmp", "+", "j", "*", "neblock", ",", "neblock", ")", ";", "cbytes", "=", "neblock", ";", "}", "_sw32", "(", "dest", "-", "4", ",", "cbytes", ")", ";", "dest", "+=", "cbytes", ";", "ntbytes", "+=", "cbytes", ";", "ctbytes", "+=", "cbytes", ";", "}", "/*", "Closes", "j", "<", "nsplits", "*/", "return", "ctbytes", ";", "}'" ]

[ "The", "public", "routine", "for", "decompression" ]

[ "'int", "blosc_decompress", "(", "const", "void", "*", "src", ",", "void", "*", "dest", ",", "size_t", "destsize", ")", "{", "int", "result", ";", "char", "*", "envvar", ";", "long", "nthreads", ";", "/*", "Check", "if", "should", "initialize", "*/", "if", "(", "!", "g_initlib", ")", "blosc_init", "()", ";", "/*", "Check", "for", "a", "BLOSC_NTHREADS", "environment", "variable", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_NTHREADS\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "nthreads", "=", "strtol", "(", "envvar", ",", "NULL", ",", "10", ")", ";", "if", "(", "(", "nthreads", "!=", "EINVAL", ")", "&&", "(", "nthreads", ">", "0", ")", ")", "{", "result", "=", "blosc_set_nthreads", "(", "(", "int", ")", "nthreads", ")", ";", "if", "(", "result", "<", "0", ")", "{", "return", "result", ";", "}", "}", "}", "/*", "Check", "for", "a", "BLOSC_NOLOCK", "environment", "variable.", "It", "is", "important", "that", "this", "should", "be", "the", "last", "env", "var", "so", "that", "it", "can", "take", "the", "previous", "ones", "into", "account", "*/", "envvar", "=", "getenv", "(", "\"BLOSC_NOLOCK\"", ")", ";", "if", "(", "envvar", "!=", "NULL", ")", "{", "result", "=", "blosc_decompress_ctx", "(", "src", ",", "dest", ",", "destsize", ",", "g_threads", ")", ";", "return", "result", ";", "}", "pthread_mutex_lock", "(", "&", "global_comp_mutex", ")", ";", "result", "=", "blosc_run_decompression_with_context", "(", "g_global_context", ",", "src", ",", "dest", ",", "destsize", ",", "g_threads", ")", ";", "pthread_mutex_unlock", "(", "&", "global_comp_mutex", ")", ";", "return", "result", ";", "}'" ]

[ "The", "public", "routine", "for", "decompression", "with", "context" ]

[ "'int", "blosc_decompress_ctx", "(", "const", "void", "*", "src", ",", "void", "*", "dest", ",", "size_t", "destsize", ",", "int", "numinternalthreads", ")", "{", "int", "result", ";", "struct", "blosc_context", "context", ";", "context", ".", "threads_started", "=", "0", ";", "result", "=", "blosc_run_decompression_with_context", "(", "&", "context", ",", "src", ",", "dest", ",", "destsize", ",", "numinternalthreads", ")", ";", "if", "(", "numinternalthreads", ">", "1", ")", "{", "blosc_release_threadpool", "(", "&", "context", ")", ";", "}", "return", "result", ";", "}'" ]

[ "Conditions", "for", "splitting", "a", "block", "before", "compressing", "with", "a", "codec" ]

[ "'static", "int", "split_block", "(", "int", "compcode", ",", "int", "typesize", ",", "int", "blocksize", ")", "{", "int", "splitblock", "=", "-", "1", ";", "switch", "(", "g_splitmode", ")", "{", "case", "BLOSC_ALWAYS_SPLIT", ":", "splitblock", "=", "1", ";", "break;", "case", "BLOSC_NEVER_SPLIT", ":", "splitblock", "=", "0", ";", "break;", "case", "BLOSC_AUTO_SPLIT", ":", "/*", "Normally", "all", "the", "compressors", "designed", "for", "speed", "benefit", "from", "a", "split.", "However,", "in", "conducted", "benchmarks", "LZ4", "seems", "that", "it", "runs", "faster", "if", "we", "don\\'t", "split,", "which", "is", "quite", "surprising.", "*/", "splitblock", "=", "(", "(", "(", "compcode", "==", "BLOSC_BLOSCLZ", ")", "||", "(", "compcode", "==", "BLOSC_SNAPPY", ")", ")", "&&", "(", "typesize", "<=", "MAX_SPLITS", ")", "&&", "(", "blocksize", "/", "typesize", ")", ">=", "MIN_BUFFERSIZE", ")", ";", "break;", "case", "BLOSC_FORWARD_COMPAT_SPLIT", ":", "/*", "The", "zstd", "support", "was", "introduced", "at", "the", "same", "time", "than", "the", "split", "flag,", "so", "*", "there", "should", "be", "not", "a", "problem", "with", "not", "splitting", "bloscks", "with", "it", "*/", "splitblock", "=", "(", "(", "compcode", "!=", "BLOSC_ZSTD", ")", "&&", "(", "typesize", "<=", "MAX_SPLITS", ")", "&&", "(", "blocksize", "/", "typesize", ")", ">=", "MIN_BUFFERSIZE", ")", ";", "break;", "default:", "fprintf", "(", "stderr", ",", "\"Split", "mode", "%d", "not", "supported\"", ",", "g_splitmode", ")", ";", "}", "return", "splitblock", ";", "}'" ]

[ "Function", "for", "polling", "BLE", "events" ]

[ "'static", "void", "nrf_sdh_ble_evts_poll", "(", "void", "*", "p_context", ")", "{", "UNUSED_VARIABLE", "(", "p_context", ")", ";", "ret_code_t", "ret_code", ";", "if", "(", "!", "m_stack_is_enabled", ")", "{", "return", ";", "}", "while", "(", "true", ")", "{", "/*lint", "-save", "-e(587)", "*/", "__ALIGN", "(", "4", ")", "uint8_t", "evt_buffer", "[", "NRF_SDH_BLE_EVT_BUF_SIZE", "]", ";", "/*lint", "-restore", "*/", "ble_evt_t", "*", "p_ble_evt", ";", "uint16_t", "evt_len", "=", "(", "uint16_t", ")", "sizeof", "(", "evt_buffer", ")", ";", "ret_code", "=", "sd_ble_evt_get", "(", "evt_buffer", ",", "&", "evt_len", ")", ";", "if", "(", "ret_code", "!=", "NRF_SUCCESS", ")", "{", "break;", "}", "p_ble_evt", "=", "(", "ble_evt_t", "*", ")", "evt_buffer", ";", "NRF_LOG_DEBUG", "(", "\"BLE", "event:", "0x%x.\"", ",", "p_ble_evt", "->", "header", ".", "evt_id", ")", ";", "//", "Forward", "the", "event", "to", "BLE", "observers.", "nrf_section_iter_t", "iter", ";", "for", "(", "nrf_section_iter_init", "(", "&", "iter", ",", "&", "sdh_ble_observers", ")", ";", "nrf_section_iter_get", "(", "&", "iter", ")", "!=", "NULL", ";", "nrf_section_iter_next", "(", "&", "iter", ")", ")", "{", "nrf_sdh_ble_evt_observer_t", "*", "p_observer", ";", "nrf_sdh_ble_evt_handler_t", "handler", ";", "p_observer", "=", "(", "nrf_sdh_ble_evt_observer_t", "*", ")", "nrf_section_iter_get", "(", "&", "iter", ")", ";", "handler", "=", "p_observer", "->", "handler", ";", "handler", "(", "p_ble_evt", ",", "p_observer", "->", "p_context", ")", ";", "}", "}", "if", "(", "ret_code", "!=", "NRF_ERROR_NOT_FOUND", ")", "{", "APP_ERROR_HANDLER", "(", "ret_code", ")", ";", "}", "}'" ]

[ "Free", "the", "name", "string" ]

[ "'static", "void", "done", "(", "void", ")", "{", "free", "(", "name", ")", ";", "name", "=", "NULL", ";", "}'" ]

[ "This", "file", "is", "the", "interface", "between", "EFSL", "ans", "Host", "massstorage", "class" ]

[ "'void", "DCD_Init", "(", "USB_OTG_CORE_HANDLE", "*", "pdev", ",", "USB_OTG_CORE_ID_TypeDef", "coreID", ")", "{", "uint32_t", "i", ";", "USB_OTG_EP", "*", "ep", ";", "USB_OTG_SelectCore", "(", "pdev", ",", "coreID", ")", ";", "pdev", "->", "dev", ".", "device_status", "=", "USB_OTG_DEFAULT", ";", "pdev", "->", "dev", ".", "device_address", "=", "0", ";", "/*", "Init", "ep", "structure", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "pdev", "->", "cfg", ".", "dev_endpoints", ";", "i", "++", ")", "{", "ep", "=", "&", "pdev", "->", "dev", ".", "in_ep", "[", "i", "]", ";", "/*", "Init", "ep", "structure", "*/", "ep", "->", "is_in", "=", "1", ";", "ep", "->", "num", "=", "i", ";", "ep", "->", "tx_fifo_num", "=", "i", ";", "/*", "Control", "until", "ep", "is", "actvated", "*/", "ep", "->", "type", "=", "EP_TYPE_CTRL", ";", "ep", "->", "maxpacket", "=", "USB_OTG_MAX_EP0_SIZE", ";", "ep", "->", "xfer_buff", "=", "0", ";", "ep", "->", "xfer_len", "=", "0", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "pdev", "->", "cfg", ".", "dev_endpoints", ";", "i", "++", ")", "{", "ep", "=", "&", "pdev", "->", "dev", ".", "out_ep", "[", "i", "]", ";", "/*", "Init", "ep", "structure", "*/", "ep", "->", "is_in", "=", "0", ";", "ep", "->", "num", "=", "i", ";", "ep", "->", "tx_fifo_num", "=", "i", ";", "/*", "Control", "until", "ep", "is", "activated", "*/", "ep", "->", "type", "=", "EP_TYPE_CTRL", ";", "ep", "->", "maxpacket", "=", "USB_OTG_MAX_EP0_SIZE", ";", "ep", "->", "xfer_buff", "=", "0", ";", "ep", "->", "xfer_len", "=", "0", ";", "}", "USB_OTG_DisableGlobalInt", "(", "pdev", ")", ";", "/*Init", "the", "Core", "(common", "init.)", "*/", "USB_OTG_CoreInit", "(", "pdev", ")", ";", "/*", "Force", "Device", "Mode*/", "USB_OTG_SetCurrentMode", "(", "pdev", ",", "DEVICE_MODE", ")", ";", "/*", "Init", "Device", "*/", "USB_OTG_CoreInitDev", "(", "pdev", ")", ";", "/*", "Enable", "USB", "Global", "interrupt", "*/", "USB_OTG_EnableGlobalInt", "(", "pdev", ")", ";", "}'" ]

[ "Connect", "device", "(enable", "internal", "pullup)" ]

[ "'void", "DCD_DevConnect", "(", "USB_OTG_CORE_HANDLE", "*", "pdev", ")", "{", "#", "ifndef", "USE_OTG_MODE", "USB_OTG_DCTL_TypeDef", "dctl", ";", "dctl", ".", "d32", "=", "USB_OTG_READ_REG32", "(", "&", "pdev", "->", "regs", ".", "DREGS", "->", "DCTL", ")", ";", "/*", "Connect", "device", "*/", "dctl", ".", "b", ".", "sftdiscon", "=", "0", ";", "USB_OTG_WRITE_REG32", "(", "&", "pdev", "->", "regs", ".", "DREGS", "->", "DCTL", ",", "dctl", ".", "d32", ")", ";", "USB_OTG_BSP_mDelay", "(", "3", ")", ";", "#", "endif", "}'" ]

[ "Clear", "stall", "condition", "on", "endpoints" ]

[ "'uint32_t", "DCD_EP_ClrStall", "(", "USB_OTG_CORE_HANDLE", "*", "pdev", ",", "uint8_t", "epnum", ")", "{", "USB_OTG_EP", "*", "ep", ";", "if", "(", "(", "0x80", "&", "epnum", ")", "==", "0x80", ")", "{", "ep", "=", "&", "pdev", "->", "dev", ".", "in_ep", "[", "epnum", "&", "0x7F", "]", ";", "}", "else", "{", "ep", "=", "&", "pdev", "->", "dev", ".", "out_ep", "[", "epnum", "]", ";", "}", "ep", "->", "is_stall", "=", "0", ";", "ep", "->", "num", "=", "epnum", "&", "0x7F", ";", "ep", "->", "is_in", "=", "(", "(", "epnum", "&", "0x80", ")", "==", "0x80", ")", ";", "USB_OTG_EPClearStall", "(", "pdev", ",", "ep", ")", ";", "return", "(", "0", ")", ";", "}'" ]

[ "Disconnect", "device", "(disable", "internal", "pullup)" ]

[ "'void", "DCD_DevDisconnect", "(", "USB_OTG_CORE_HANDLE", "*", "pdev", ")", "{", "#", "ifndef", "USE_OTG_MODE", "USB_OTG_DCTL_TypeDef", "dctl", ";", "dctl", ".", "d32", "=", "USB_OTG_READ_REG32", "(", "&", "pdev", "->", "regs", ".", "DREGS", "->", "DCTL", ")", ";", "/*", "Disconnect", "device", "for", "3ms", "*/", "dctl", ".", "b", ".", "sftdiscon", "=", "1", ";", "USB_OTG_WRITE_REG32", "(", "&", "pdev", "->", "regs", ".", "DREGS", "->", "DCTL", ",", "dctl", ".", "d32", ")", ";", "USB_OTG_BSP_mDelay", "(", "3", ")", ";", "#", "endif", "}'" ]

[ "returns", "the", "EP", "Status" ]

[ "'uint32_t", "DCD_GetEPStatus", "(", "USB_OTG_CORE_HANDLE", "*", "pdev", ",", "uint8_t", "epnum", ")", "{", "USB_OTG_EP", "*", "ep", ";", "uint32_t", "Status", "=", "0", ";", "if", "(", "(", "0x80", "&", "epnum", ")", "==", "0x80", ")", "{", "ep", "=", "&", "pdev", "->", "dev", ".", "in_ep", "[", "epnum", "&", "0x7F", "]", ";", "}", "else", "{", "ep", "=", "&", "pdev", "->", "dev", ".", "out_ep", "[", "epnum", "]", ";", "}", "Status", "=", "USB_OTG_GetEPStatus", "(", "pdev", ",", "ep", ")", ";", "/*", "Return", "the", "current", "status", "*/", "return", "Status", ";", "}'" ]

[ "Setup", "the", "endpoints", "to", "be", "bulk", "&", "register", "the", "callbacks" ]

[ "'static", "void", "msc_set_config", "(", "usbd_device", "*", "usbd_dev", ",", "uint16_t", "wValue", ")", "{", "usbd_mass_storage", "*", "ms", "=", "&", "_mass_storage", ";", "(", "void", ")", "wValue", ";", "usbd_ep_setup", "(", "usbd_dev", ",", "ms", "->", "ep_in", ",", "USB_ENDPOINT_ATTR_BULK", ",", "ms", "->", "ep_in_size", ",", "msc_data_tx_cb", ")", ";", "usbd_ep_setup", "(", "usbd_dev", ",", "ms", "->", "ep_out", ",", "USB_ENDPOINT_ATTR_BULK", ",", "ms", "->", "ep_out_size", ",", "msc_data_rx_cb", ")", ";", "usbd_register_control_callback", "(", "usbd_dev", ",", "USB_REQ_TYPE_CLASS", "|", "USB_REQ_TYPE_INTERFACE", ",", "USB_REQ_TYPE_TYPE", "|", "USB_REQ_TYPE_RECIPIENT", ",", "msc_control_request", ")", ";", "}'" ]

[ "Parsing", "a", "frame", "data", "and", "copy", "the", "payload", "to", "the", "datalink", "buffer" ]

[ "'void", "pprz_check_and_parse", "(", "struct", "link_device", "*", "dev", ",", "struct", "pprz_transport", "*", "trans", ",", "uint8_t", "*", "buf", ",", "bool", "*", "msg_available", ")", "{", "uint8_t", "i", ";", "if", "(", "dev", "->", "char_available", "(", "dev", "->", "periph", ")", ")", "{", "while", "(", "dev", "->", "char_available", "(", "dev", "->", "periph", ")", "&&", "!", "trans", "->", "trans_rx", ".", "msg_received", ")", "{", "parse_pprz", "(", "trans", ",", "dev", "->", "get_byte", "(", "dev", "->", "periph", ")", ")", ";", "}", "if", "(", "trans", "->", "trans_rx", ".", "msg_received", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "trans", "->", "trans_rx", ".", "payload_len", ";", "i", "++", ")", "{", "buf", "[", "i", "]", "=", "trans", "->", "trans_rx", ".", "payload", "[", "i", "]", ";", "}", "*", "msg_available", "=", "true", ";", "trans", "->", "trans_rx", ".", "msg_received", "=", "false", ";", "}", "}", "}'" ]

[ "Advances", "to", "state", "0", "if", "counter", "has", "exceeded", "threshold,", "returns", "otherwise" ]

[ "'static", "inline", "void", "skip_unknown_instr_inc", "(", "int", "reset_state", ",", "drx_state_machine_params_t", "*", "params", ")", "{", "if", "(", "params", "->", "skip_unknown_instr_count", "++", ">=", "DRX_RESTORE_EVENT_SKIP_UNKNOWN_INSTR_MAX", ")", "{", "advance_state", "(", "reset_state", ",", "params", ")", ";", "}", "}'" ]

[ "Returns", "whether", "to", "execute", "the", "system", "call" ]

[ "'static", "bool", "soft_kills_pre_syscall", "(", "void", "*", "drcontext", ",", "int", "sysnum", ")", "{", "if", "(", "sysnum", "==", "SYS_kill", ")", "{", "process_id_t", "pid", "=", "(", "process_id_t", ")", "dr_syscall_get_param", "(", "drcontext", ",", "0", ")", ";", "int", "sig", "=", "(", "int", ")", "dr_syscall_get_param", "(", "drcontext", ",", "1", ")", ";", "if", "(", "sig", "==", "SIGKILL", "&&", "pid", "!=", "INVALID_PROCESS_ID", "&&", "pid", "!=", "dr_get_process_id", "()", ")", "{", "/*", "Pass", "exit", "code", "<<", "8", "for", "use", "with", "dr_exit_process()", "*/", "int", "exit_code", "=", "sig", "<<", "8", ";", "if", "(", "soft_kills_invoke_cbs", "(", "pid", ",", "exit_code", ")", ")", "{", "/*", "set", "result", "to", "0", "(success)", "and", "use_high", "and", "use_errno", "to", "false", "*/", "dr_syscall_result_info_t", "info", "=", "{", "sizeof", "(", "info", ")", ",", "}", ";", "info", ".", "succeeded", "=", "true", ";", "dr_syscall_set_result_ex", "(", "drcontext", ",", "&", "info", ")", ";", "return", "false", ";", "/*", "skip", "syscall", "*/", "}", "else", "return", "true", ";", "/*", "execute", "syscall", "*/", "}", "}", "return", "true", ";", "}'" ]

[ "ADC", "Enable", "Analog", "Watchdog", "for", "All", "Regular", "and", "or", "Injected", "Channels" ]

[ "'void", "adc_enable_analog_watchdog_on_all_channels", "(", "uint32_t", "adc", ")", "{", "ADC_CR1", "(", "adc", ")", "&=", "~", "ADC_CR1_AWDSGL", ";", "}'" ]

[ "ADC", "Disable", "Automatic", "Injected", "Conversions" ]

[ "'void", "adc_disable_automatic_injected_group_conversion", "(", "uint32_t", "adc", ")", "{", "ADC_CR1", "(", "adc", ")", "&=", "~", "ADC_CR1_JAUTO", ";", "}'" ]

[ "ADC", "Set", "the", "Data", "as", "Right", "Aligned" ]

[ "'void", "adc_set_right_aligned", "(", "uint32_t", "adc", ")", "{", "ADC_CR2", "(", "adc", ")", "&=", "~", "ADC_CR2_ALIGN", ";", "}'" ]

[ "ADC", "Disable", "Analog", "Watchdog", "for", "Injected", "Conversions" ]

[ "'void", "adc_disable_analog_watchdog_injected", "(", "uint32_t", "adc", ")", "{", "ADC_CR1", "(", "adc", ")", "&=", "~", "ADC_CR1_JAWDEN", ";", "}'" ]

[ "ADC", "Read", "the", "EndofConversion", "Flag" ]

[ "'bool", "adc_eoc", "(", "uint32_t", "adc", ")", "{", "return", "(", "ADC_SR", "(", "adc", ")", "&", "ADC_SR_EOC", ")", "!=", "0", ";", "}'" ]

[ "ADC", "Enable", "Continuous", "Conversion", "Mode" ]

[ "'void", "adc_set_continuous_conversion_mode", "(", "uint32_t", "adc", ")", "{", "ADC_CR2", "(", "adc", ")", "|=", "ADC_CR2_CONT", ";", "}'" ]

[ "ADC", "Enable", "Single", "Conversion", "Mode" ]

[ "'void", "adc_set_single_conversion_mode", "(", "uint32_t", "adc", ")", "{", "ADC_CR2", "(", "adc", ")", "&=", "~", "ADC_CR2_CONT", ";", "}'" ]

[ "ADC", "Enable", "Analog", "Watchdog", "for", "Injected", "Conversions" ]

[ "'void", "adc_enable_analog_watchdog_injected", "(", "uint32_t", "adc", ")", "{", "ADC_CR1", "(", "adc", ")", "|=", "ADC_CR1_JAWDEN", ";", "}'" ]

[ "ADC", "Disable", "DMA", "Transfers" ]

[ "'void", "adc_disable_dma", "(", "uint32_t", "adc", ")", "{", "ADC_CR2", "(", "adc", ")", "&=", "~", "ADC_CR2_DMA", ";", "}'" ]

[ "ADC", "Disable", "Discontinuous", "Mode", "for", "Regular", "Conversions" ]

[ "'void", "adc_disable_discontinuous_mode_regular", "(", "uint32_t", "adc", ")", "{", "ADC_CR1", "(", "adc", ")", "&=", "~", "ADC_CR1_DISCEN", ";", "}'" ]

[ "ADC", "Disable", "Scan", "Mode" ]

[ "'void", "adc_disable_scan_mode", "(", "uint32_t", "adc", ")", "{", "ADC_CR1", "(", "adc", ")", "&=", "~", "ADC_CR1_SCAN", ";", "}'" ]

[ "public", "functions", "Create", "new", "instance", "of", "WInput", "object" ]

[ "'WInput", "*", "input_new", "(", "int", "y", ",", "int", "x", ",", "const", "int", "*", "colors", ",", "int", "width", ",", "const", "char", "*", "def_text", ",", "const", "char", "*", "histname", ",", "input_complete_t", "completion_flags", ")", "{", "WInput", "*", "in", ";", "Widget", "*", "w", ";", "in", "=", "g_new", "(", "WInput", ",", "1", ")", ";", "w", "=", "WIDGET", "(", "in", ")", ";", "widget_init", "(", "w", ",", "y", ",", "x", ",", "1", ",", "width", ",", "input_callback", ",", "input_mouse_callback", ")", ";", "w", "->", "options", "|=", "WOP_SELECTABLE", "|", "WOP_IS_INPUT", "|", "WOP_WANT_CURSOR", ";", "w", "->", "keymap", "=", "input_map", ";", "in", "->", "color", "=", "colors", ";", "in", "->", "first", "=", "TRUE", ";", "in", "->", "mark", "=", "-", "1", ";", "in", "->", "term_first_shown", "=", "0", ";", "in", "->", "disable_update", "=", "0", ";", "in", "->", "is_password", "=", "FALSE", ";", "in", "->", "strip_password", "=", "FALSE", ";", "/*", "in->buffer", "will", "be", "corrected", "in", "\"history_load\"", "event", "handler", "*/", "in", "->", "current_max_size", "=", "width", "+", "1", ";", "in", "->", "buffer", "=", "g_new0", "(", "char", ",", "in", "->", "current_max_size", ")", ";", "/*", "init", "completions", "before", "input_assign_text()", "call", "*/", "in", "->", "completions", "=", "NULL", ";", "in", "->", "completion_flags", "=", "completion_flags", ";", "in", "->", "init_from_history", "=", "(", "def_text", "==", "INPUT_LAST_TEXT", ")", ";", "if", "(", "in", "->", "init_from_history", "||", "def_text", "==", "NULL", ")", "def_text", "=", "\"\"", ";", "input_assign_text", "(", "in", ",", "def_text", ")", ";", "/*", "prepare", "to", "history", "setup", "*/", "in", "->", "history", ".", "list", "=", "NULL", ";", "in", "->", "history", ".", "current", "=", "NULL", ";", "in", "->", "history", ".", "changed", "=", "FALSE", ";", "in", "->", "history", ".", "name", "=", "NULL", ";", "if", "(", "(", "histname", "!=", "NULL", ")", "&&", "(", "*", "histname", "!=", "\\'\\\\0\\'", ")", ")", "in", "->", "history", ".", "name", "=", "g_strdup", "(", "histname", ")", ";", "/*", "history", "will", "be", "loaded", "later", "*/", "in", "->", "label", "=", "NULL", ";", "return", "in", ";", "}'" ]

[ "Cleans", "the", "input", "line", "and", "adds", "the", "current", "text", "to", "the", "history" ]

[ "\"void", "input_clean", "(", "WInput", "*", "in", ")", "{", "push_history", "(", "in", ",", "in", "->", "buffer", ")", ";", "in", "->", "need_push", "=", "TRUE", ";", "in", "->", "buffer", "[", "0", "]", "=", "'\\\\0'", ";", "in", "->", "point", "=", "0", ";", "in", "->", "charpoint", "=", "0", ";", "in", "->", "mark", "=", "-", "1", ";", "input_complete_free", "(", "in", ")", ";", "input_update", "(", "in", ",", "FALSE", ")", ";", "}\"" ]

[ "verify", "check_log", "helper", "can", "detect", "errors" ]

[ "'void", "test_check_length_ok", "(", "void", "*", "*", "state", ")", "{", "assert_int_equal", "(", "check_log", "(", "logfile", ")", ",", "0", ")", ";", "}'" ]

[ "verify", "that", "all", "log", "lines", "have", "correct", "length" ]

[ "'int", "check_log", "(", "char", "*", "file", ")", "{", "FILE", "*", "fp", ";", "char", "buffer", "[", "LOGLINELEN", "+", "5", "]", ";", "int", "result", "=", "0", ";", "fp", "=", "fopen", "(", "file", ",", "\"r\"", ")", ";", "while", "(", "fgets", "(", "buffer", ",", "LOGLINELEN", "+", "5", ",", "fp", ")", ")", "{", "if", "(", "strlen", "(", "buffer", ")", "!=", "LOGLINELEN", ")", "{", "result", "=", "1", ";", "break;", "}", "if", "(", "buffer", "[", "LOGLINELEN", "-", "1", "]", "!=", "\\'\\\\'", ")", "{", "result", "=", "1", ";", "break;", "}", "}", "fclose", "(", "fp", ")", ";", "return", "result", ";", "}'" ]

[ "A", "variant", "of", "run_listbox()", "which", "is", "more", "convenient", "to", "use", "when", "we", "need", "to", "select", "arbitrary", "'data'" ]

[ "'void", "*", "run_listbox_with_data", "(", "Listbox", "*", "l", ",", "const", "void", "*", "select", ")", "{", "void", "*", "val", "=", "NULL", ";", "if", "(", "select", "!=", "NULL", ")", "listbox_select_entry", "(", "l", "->", "list", ",", "listbox_search_data", "(", "l", "->", "list", ",", "select", ")", ")", ";", "if", "(", "dlg_run", "(", "l", "->", "dlg", ")", "!=", "B_CANCEL", ")", "{", "WLEntry", "*", "e", ";", "e", "=", "listbox_get_nth_item", "(", "l", "->", "list", ",", "l", "->", "list", "->", "pos", ")", ";", "if", "(", "e", "!=", "NULL", ")", "{", "/*", "The", "assert", "guards", "against", "returning", "a", "soon-to-be", "deallocated", "*", "pointer", "(as", "in", "listbox_add_item(...,", "TRUE)).", "*/", "g_assert", "(", "!", "e", "->", "free_data", ")", ";", "val", "=", "e", "->", "data", ";", "}", "}", "dlg_destroy", "(", "l", "->", "dlg", ")", ";", "g_free", "(", "l", ")", ";", "return", "val", ";", "}'" ]

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

[ "'void", "gpio_set", "(", "uint16_t", "gpios", ")", "{", "GPIO_ADATA", "|=", "gpios", ";", "}'" ]

[ "Set", "the", "direction", "of", "a", "Group", "of", "Pins", "to", "Output" ]

[ "'void", "gpio_output", "(", "uint16_t", "gpios", ")", "{", "GPIO_ADIR", "|=", "gpios", ";", "}'" ]

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

[ "'uint16_t", "gpio_get", "(", "uint16_t", "gpios", ")", "{", "return", "GPIO_AEXT", "&", "gpios", ";", "}'" ]

[ "Clear", "the", "specified", "pin", "interrupts" ]

[ "'void", "gpio_int_clear", "(", "uint16_t", "gpios", ")", "{", "GPIO_INTEOI_A", "|=", "gpios", ";", "}'" ]

[ "Gets", "the", "raw", "unmasked", "interrupt", "status" ]

[ "'uint16_t", "gpio_int_raw_status", "(", "void", ")", "{", "return", "GPIO_RAWINTSTAT_A", ";", "}'" ]

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

[ "'void", "gpio_toggle", "(", "uint16_t", "gpios", ")", "{", "uint32_t", "curr_status", "=", "GPIO_ADATA", "&", "gpios", ";", "GPIO_ADATA", "=", "(", "GPIO_ADATA", "&", "(", "~", "gpios", ")", ")", "|", "(", "~", "curr_status", ")", ";", "}'" ]

[ "Gets", "the", "masked", "interrupt", "status" ]

[ "'uint16_t", "gpio_int_status", "(", "void", ")", "{", "return", "GPIO_INTSTAT_A", ";", "}'" ]

[ "Set", "the", "direction", "of", "a", "Group", "of", "Pins", "to", "Input" ]

[ "'void", "gpio_input", "(", "uint16_t", "gpios", ")", "{", "GPIO_ADIR", "&=", "~", "gpios", ";", "}'" ]

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

[ "'void", "gpio_clear", "(", "uint16_t", "gpios", ")", "{", "GPIO_ADATA", "&=", "~", "gpios", ";", "}'" ]

[ "assumes", "that", "r", "and", "c", "are", "good" ]

[ "'static", "inline", "int", "cgc_isOnBoard", "(", "char", "r", ",", "char", "c", ",", "char", "d", ",", "int", "num", ")", "{", "if", "(", "d", "==", "DIR_R", ")", "{", "if", "(", "(", "c", "-", "COL_BASE", "+", "num", ")", "<=", "BOARD_SIZE", ")", "{", "return", "(", "1", ")", ";", "}", "}", "if", "(", "d", "==", "DIR_D", ")", "{", "if", "(", "(", "r", "-", "ROW_BASE", "+", "num", ")", "<=", "BOARD_SIZE", ")", "{", "return", "(", "1", ")", ";", "}", "}", "return", "(", "0", ")", ";", "}'" ]

[ "IS", "variants", "of", "TLB", "operations", "must", "affect", "all", "cores" ]

[ "'static", "void", "tlbiall_is_write", "(", "CPUARMState", "*", "env", ",", "const", "ARMCPRegInfo", "*", "ri", ",", "uint64_t", "value", ")", "{", "CPUState", "*", "other_cs", ";", "CPU_FOREACH", "(", "other_cs", ")", "{", "tlb_flush", "(", "other_cs", ",", "1", ")", ";", "}", "}'" ]

[ "Common", "wrapper", "to", "call", "recip_estimate" ]

[ "'static", "float64", "call_recip_estimate", "(", "float64", "num", ",", "int", "off", ",", "float_status", "*", "fpst", ")", "{", "uint64_t", "val64", "=", "float64_val", "(", "num", ")", ";", "uint64_t", "frac", "=", "extract64", "(", "val64", ",", "0", ",", "52", ")", ";", "int64_t", "exp", "=", "extract64", "(", "val64", ",", "52", ",", "11", ")", ";", "uint64_t", "sbit", ";", "float64", "scaled", ",", "<type", "ref=\"prev\"/>", "estimate", ";", "/*", "Generate", "the", "scaled", "number", "for", "the", "estimate", "function", "*/", "if", "(", "exp", "==", "0", ")", "{", "if", "(", "extract64", "(", "frac", ",", "51", ",", "1", ")", "==", "0", ")", "{", "exp", "=", "-", "1", ";", "frac", "=", "extract64", "(", "frac", ",", "0", ",", "50", ")", "<<", "2", ";", "}", "else", "{", "frac", "=", "extract64", "(", "frac", ",", "0", ",", "51", ")", "<<", "1", ";", "}", "}", "/*", "scaled", "=", "\\'0\\'", ":", "\\'01111111110\\'", ":", "fraction<51:44>", ":", "Zeros(44);", "*/", "scaled", "=", "make_float64", "(", "(", "0x3feULL", "<<", "52", ")", "|", "extract64", "(", "frac", ",", "44", ",", "8", ")", "<<", "44", ")", ";", "estimate", "=", "recip_estimate", "(", "scaled", ",", "fpst", ")", ";", "/*", "Build", "new", "result", "*/", "val64", "=", "float64_val", "(", "estimate", ")", ";", "sbit", "=", "0x8000000000000000ULL", "&", "val64", ";", "exp", "=", "off", "-", "exp", ";", "frac", "=", "extract64", "(", "val64", ",", "0", ",", "52", ")", ";", "if", "(", "exp", "==", "0", ")", "{", "frac", "=", "1ULL", "<<", "51", "|", "extract64", "(", "frac", ",", "1", ",", "51", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "exp", "==", "-", "1", ")", "{", "frac", "=", "1ULL", "<<", "50", "|", "extract64", "(", "frac", ",", "2", ",", "50", ")", ";", "exp", "=", "0", ";", "}", "return", "make_float64", "(", "sbit", "|", "(", "exp", "<<", "52", ")", "|", "frac", ")", ";", "}'" ]

[ "Convert", "ARM", "rounding", "mode", "to", "softfloat" ]

[ "'int", "arm_rmode_to_sf", "(", "int", "rmode", ")", "{", "switch", "(", "rmode", ")", "{", "case", "FPROUNDING_TIEAWAY", ":", "rmode", "=", "float_round_ties_away", ";", "break;", "case", "FPROUNDING_ODD", ":", "/*", "FIXME:", "add", "support", "for", "TIEAWAY", "and", "ODD", "*/", "qemu_log_mask", "(", "LOG_UNIMP", ",", "\"arm:", "unimplemented", "rounding", "mode:", "%d\\\"", ",", "rmode", ")", ";", "case", "FPROUNDING_TIEEVEN", ":", "default:", "rmode", "=", "float_round_nearest_even", ";", "break;", "case", "FPROUNDING_POSINF", ":", "rmode", "=", "float_round_up", ";", "break;", "case", "FPROUNDING_NEGINF", ":", "rmode", "=", "float_round_down", ";", "break;", "case", "FPROUNDING_ZERO", ":", "rmode", "=", "float_round_to_zero", ";", "break;", "}", "return", "rmode", ";", "}'" ]

[ "Sort", "alphabetically", "by", "type", "name,", "except", "for", "\"any\"" ]

[ "'static", "gint", "arm_cpu_list_compare", "(", "gconstpointer", "a", ",", "gconstpointer", "b", ")", "{", "ObjectClass", "*", "class_a", "=", "(", "ObjectClass", "*", ")", "a", ";", "ObjectClass", "*", "class_b", "=", "(", "ObjectClass", "*", ")", "b", ";", "const", "char", "*", "name_a", ",", "<type", "ref=\"prev\">", "*", "name_b", ";", "name_a", "=", "object_class_get_name", "(", "class_a", ")", ";", "name_b", "=", "object_class_get_name", "(", "class_b", ")", ";", "if", "(", "strcmp", "(", "name_a", ",", "\"any-\"", "TYPE_ARM_CPU", ")", "==", "0", ")", "{", "return", "1", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "name_b", ",", "\"any-\"", "TYPE_ARM_CPU", ")", "==", "0", ")", "{", "return", "-", "1", ";", "}", "else", "{", "return", "strcmp", "(", "name_a", ",", "name_b", ")", ";", "}", "}'" ]

[ "Set", "the", "SysTick", "Clock", "Source" ]

[ "'void", "systick_set_clocksource", "(", "uint8_t", "clocksource", ")", "{", "STK_CSR", "=", "(", "STK_CSR", "&", "(", "~", "STK_CSR_CLKSOURCE", ")", ")", "|", "(", "clocksource", "<<", "STK_CSR_CLKSOURCE_LSB", ")", ";", "}'" ]

[ "SysTick", "Set", "the", "Automatic", "Reload", "Value" ]

[ "'void", "systick_set_reload", "(", "uint32_t", "value", ")", "{", "STK_RVR", "=", "(", "value", "&", "STK_RVR_RELOAD", ")", ";", "}'" ]

[ "SysTick", "Get", "Calibration", "Value" ]

[ "'uint32_t", "systick_get_calib", "(", "void", ")", "{", "return", "STK_CALIB", "&", "STK_CALIB_TENMS", ";", "}'" ]

[ "SysTick", "Read", "the", "Automatic", "Reload", "Value" ]

[ "'uint32_t", "systick_get_reload", "(", "void", ")", "{", "return", "STK_RVR", "&", "STK_RVR_RELOAD", ";", "}'" ]

[ "Get", "the", "current", "SysTick", "counter", "value" ]

[ "'uint32_t", "systick_get_value", "(", "void", ")", "{", "return", "STK_CVR", "&", "STK_CVR_CURRENT", ";", "}'" ]

[ "USART", "Wait", "for", "Transmit", "Data", "Buffer", "Empty" ]

[ "'void", "usart_wait_send_ready", "(", "uint32_t", "usart", ")", "{", "/*", "Wait", "until", "the", "data", "has", "been", "transferred", "into", "the", "shift", "register.", "*/", "while", "(", "(", "USART_SR", "(", "usart", ")", "&", "USART_SR_TXE", ")", "==", "0", ")", ";", "}'" ]

[ "Handle", "DNS", "retransmission", "timer", "expiry" ]

[ "'static", "void", "dns_timer_expired", "(", "struct", "retry_timer", "*", "timer", ",", "int", "fail", ")", "{", "struct", "dns_request", "*", "dns", "=", "container_of", "(", "timer", ",", "struct", "dns_request", ",", "timer", ")", ";", "if", "(", "fail", ")", "{", "dns_done", "(", "dns", ",", "-", "ETIMEDOUT", ")", ";", "}", "else", "{", "dns_send_packet", "(", "dns", ")", ";", "}", "}'" ]

[ "Decode", "RFC1035encoded", "DNS", "name" ]

[ "\"int", "dns_decode", "(", "struct", "dns_name", "*", "name", ",", "char", "*", "data", ",", "size_t", "len", ")", "{", "unsigned", "int", "recursion_limit", "=", "name", "->", "len", ";", "/*", "Generous", "upper", "bound", "*/", "int", "offset", "=", "name", "->", "offset", ";", "const", "uint8_t", "*", "label", ";", "size_t", "decoded_len", "=", "0", ";", "size_t", "label_len", ";", "size_t", "copy_len", ";", "while", "(", "recursion_limit", "--", ")", "{", "/*", "Find", "valid", "DNS", "label", "*/", "offset", "=", "dns_label", "(", "name", ",", "offset", ")", ";", "if", "(", "offset", "<", "0", ")", "return", "offset", ";", "/*", "Terminate", "if", "we", "have", "reached", "the", "root", "*/", "label", "=", "(", "name", "->", "data", "+", "offset", ")", ";", "label_len", "=", "*", "(", "label", "++", ")", ";", "if", "(", "label_len", "==", "0", ")", "{", "if", "(", "decoded_len", "<", "len", ")", "*", "data", "=", "'\\\\0'", ";", "return", "decoded_len", ";", "}", "/*", "Prepend", "'.'", "if", "applicable", "*/", "if", "(", "decoded_len", "&&", "(", "decoded_len", "++", "<", "len", ")", ")", "*", "(", "data", "++", ")", "=", "'.'", ";", "/*", "Copy", "label", "to", "output", "buffer", "*/", "copy_len", "=", "(", "(", "decoded_len", "<", "len", ")", "?", "(", "len", "-", "decoded_len", ")", ":", "0", ")", ";", "if", "(", "copy_len", ">", "label_len", ")", "copy_len", "=", "label_len", ";", "memcpy", "(", "data", ",", "label", ",", "copy_len", ")", ";", "data", "+=", "copy_len", ";", "decoded_len", "+=", "label_len", ";", "/*", "Move", "to", "next", "label", "*/", "offset", "+=", "(", "sizeof", "(", "*", "label", ")", "+", "label_len", ")", ";", "}", "/*", "Recursion", "limit", "exceeded", "*/", "return", "-", "EINVAL", ";", "}\"" ]

[ "Skip", "RFC1035encoded", "DNS", "name", "in", "search", "list" ]

[ "'static", "int", "dns_skip_search", "(", "struct", "dns_name", "*", "name", ")", "{", "int", "offset", ";", "/*", "Find", "next", "name", "*/", "offset", "=", "dns_skip", "(", "name", ")", ";", "if", "(", "offset", "<", "0", ")", "return", "offset", ";", "/*", "Skip", "over", "any", "subsequent", "empty", "names", "(e.g.", "due", "to", "padding", "*", "bytes", "used", "in", "the", "NDP", "DNSSL", "option).", "*/", "while", "(", "(", "offset", "<", "(", "(", "int", ")", "name", "->", "len", ")", ")", "&&", "(", "*", "(", "(", "uint8_t", "*", ")", "(", "name", "->", "data", "+", "offset", ")", ")", "==", "0", ")", ")", "{", "offset", "++", ";", "}", "return", "offset", ";", "}'" ]

[ "Settings", "Format", "DNS", "search", "list", "setting" ]

[ "\"static", "int", "format_dnssl_setting", "(", "const", "struct", "setting_type", "*", "type", "__unused", ",", "const", "void", "*", "raw", ",", "size_t", "raw_len", ",", "char", "*", "buf", ",", "size_t", "len", ")", "{", "struct", "dns_name", "name", "=", "{", ".", "data", "=", "(", "(", "void", "*", ")", "raw", ")", ",", ".", "len", "=", "raw_len", ",", "}", ";", "size_t", "remaining", "=", "len", ";", "size_t", "total", "=", "0", ";", "int", "name_len", ";", "while", "(", "name", ".", "offset", "<", "raw_len", ")", "{", "/*", "Decode", "name", "*/", "remaining", "=", "(", "(", "total", "<", "len", ")", "?", "(", "len", "-", "total", ")", ":", "0", ")", ";", "name_len", "=", "dns_decode", "(", "&", "name", ",", "(", "buf", "+", "total", ")", ",", "remaining", ")", ";", "if", "(", "name_len", "<", "0", ")", "return", "name_len", ";", "total", "+=", "name_len", ";", "/*", "Move", "to", "next", "name", "*/", "name", ".", "offset", "=", "dns_skip_search", "(", "&", "name", ")", ";", "/*", "Add", "separator", "if", "applicable", "*/", "if", "(", "name", ".", "offset", "!=", "raw_len", ")", "{", "if", "(", "total", "<", "len", ")", "buf", "[", "total", "]", "=", "'", "'", ";", "total", "++", ";", "}", "}", "return", "total", ";", "}\"" ]

[ "Skip", "RFC1035encoded", "DNS", "name" ]

[ "'int", "dns_skip", "(", "struct", "dns_name", "*", "name", ")", "{", "unsigned", "int", "recursion_limit", "=", "name", "->", "len", ";", "/*", "Generous", "upper", "bound", "*/", "int", "offset", "=", "name", "->", "offset", ";", "int", "prev_offset", ";", "const", "uint8_t", "*", "label", ";", "size_t", "label_len", ";", "while", "(", "recursion_limit", "--", ")", "{", "/*", "Find", "valid", "DNS", "label", "*/", "prev_offset", "=", "offset", ";", "offset", "=", "dns_label", "(", "name", ",", "prev_offset", ")", ";", "if", "(", "offset", "<", "0", ")", "return", "offset", ";", "/*", "Terminate", "if", "we", "have", "reached", "a", "compression", "pointer", "*/", "if", "(", "offset", "!=", "prev_offset", ")", "return", "(", "prev_offset", "+", "sizeof", "(", "uint16_t", ")", ")", ";", "/*", "Skip", "this", "label", "*/", "label", "=", "(", "name", "->", "data", "+", "offset", ")", ";", "label_len", "=", "*", "label", ";", "offset", "+=", "(", "sizeof", "(", "*", "label", ")", "+", "label_len", ")", ";", "/*", "Terminate", "if", "we", "have", "reached", "the", "root", "*/", "if", "(", "label_len", "==", "0", ")", "return", "offset", ";", "}", "/*", "Recursion", "limit", "exceeded", "*/", "return", "-", "EINVAL", ";", "}'" ]

[ "Compare", "DNS", "names", "for", "equality" ]

[ "'int", "dns_compare", "(", "struct", "dns_name", "*", "first", ",", "struct", "dns_name", "*", "second", ")", "{", "unsigned", "int", "recursion_limit", "=", "first", "->", "len", ";", "/*", "Generous", "upper", "bound", "*/", "int", "first_offset", "=", "first", "->", "offset", ";", "int", "second_offset", "=", "second", "->", "offset", ";", "const", "uint8_t", "*", "first_label", ";", "const", "uint8_t", "*", "second_label", ";", "size_t", "label_len", ";", "size_t", "len", ";", "while", "(", "recursion_limit", "--", ")", "{", "/*", "Find", "valid", "DNS", "labels", "*/", "first_offset", "=", "dns_label", "(", "first", ",", "first_offset", ")", ";", "if", "(", "first_offset", "<", "0", ")", "return", "first_offset", ";", "second_offset", "=", "dns_label", "(", "second", ",", "second_offset", ")", ";", "if", "(", "second_offset", "<", "0", ")", "return", "second_offset", ";", "/*", "Compare", "label", "lengths", "*/", "first_label", "=", "(", "first", "->", "data", "+", "first_offset", ")", ";", "second_label", "=", "(", "second", "->", "data", "+", "second_offset", ")", ";", "label_len", "=", "*", "(", "first_label", "++", ")", ";", "if", "(", "label_len", "!=", "*", "(", "second_label", "++", ")", ")", "return", "-", "ENOENT", ";", "len", "=", "(", "sizeof", "(", "*", "first_label", ")", "+", "label_len", ")", ";", "/*", "Terminate", "if", "we", "have", "reached", "the", "root", "*/", "if", "(", "label_len", "==", "0", ")", "return", "0", ";", "/*", "Compare", "label", "contents", "(case-insensitively)", "*/", "while", "(", "label_len", "--", ")", "{", "if", "(", "tolower", "(", "*", "(", "first_label", "++", ")", ")", "!=", "tolower", "(", "*", "(", "second_label", "++", ")", ")", ")", "return", "-", "ENOENT", ";", "}", "/*", "Move", "to", "next", "labels", "*/", "first_offset", "+=", "len", ";", "second_offset", "+=", "len", ";", "}", "/*", "Recursion", "limit", "exceeded", "*/", "return", "-", "EINVAL", ";", "}'" ]

[ "Encode", "a", "DNS", "name", "using", "RFC1035", "encoding" ]

[ "\"int", "dns_encode", "(", "const", "char", "*", "string", ",", "struct", "dns_name", "*", "name", ")", "{", "uint8_t", "*", "start", "=", "(", "name", "->", "data", "+", "name", "->", "offset", ")", ";", "uint8_t", "*", "end", "=", "(", "name", "->", "data", "+", "name", "->", "len", ")", ";", "uint8_t", "*", "dst", "=", "start", ";", "size_t", "len", "=", "0", ";", "char", "c", ";", "/*", "Encode", "name", "*/", "while", "(", "(", "c", "=", "*", "(", "string", "++", ")", ")", ")", "{", "/*", "Handle", "'.'", "separators", "*/", "if", "(", "c", "==", "'.'", ")", "{", "/*", "Reject", "consecutive", "'.'", "*/", "if", "(", "(", "len", "==", "0", ")", "&&", "(", "dst", "!=", "start", ")", ")", "return", "-", "EINVAL", ";", "/*", "Terminate", "if", "this", "is", "the", "trailing", "'.'", "*/", "if", "(", "*", "string", "==", "'\\\\0'", ")", "break;", "/*", "Reject", "initial", "non-terminating", "'.'", "*/", "if", "(", "len", "==", "0", ")", "return", "-", "EINVAL", ";", "/*", "Reset", "length", "*/", "len", "=", "0", ";", "}", "else", "{", "/*", "Increment", "length", "*/", "len", "++", ";", "/*", "Check", "for", "overflow", "*/", "if", "(", "len", ">", "DNS_MAX_LABEL_LEN", ")", "return", "-", "EINVAL", ";", "}", "/*", "Copy", "byte,", "update", "length", "*/", "if", "(", "++", "dst", "<", "end", ")", "{", "*", "dst", "=", "c", ";", "dst", "[", "-", "len", "]", "=", "len", ";", "}", "}", "/*", "Add", "terminating", "root", "marker", "*/", "if", "(", "len", ")", "dst", "++", ";", "if", "(", "dst", "<", "end", ")", "*", "dst", "=", "'\\\\0'", ";", "dst", "++", ";", "return", "(", "dst", "-", "start", ")", ";", "}\"" ]

[ "Copy", "a", "DNS", "name" ]

[ "'int", "dns_copy", "(", "struct", "dns_name", "*", "src", ",", "struct", "dns_name", "*", "dst", ")", "{", "unsigned", "int", "recursion_limit", "=", "src", "->", "len", ";", "/*", "Generous", "upper", "bound", "*/", "int", "src_offset", "=", "src", "->", "offset", ";", "size_t", "dst_offset", "=", "dst", "->", "offset", ";", "const", "uint8_t", "*", "label", ";", "size_t", "label_len", ";", "size_t", "copy_len", ";", "size_t", "len", ";", "while", "(", "recursion_limit", "--", ")", "{", "/*", "Find", "valid", "DNS", "label", "*/", "src_offset", "=", "dns_label", "(", "src", ",", "src_offset", ")", ";", "if", "(", "src_offset", "<", "0", ")", "return", "src_offset", ";", "/*", "Copy", "as", "an", "uncompressed", "label", "*/", "label", "=", "(", "src", "->", "data", "+", "src_offset", ")", ";", "label_len", "=", "*", "label", ";", "len", "=", "(", "sizeof", "(", "*", "label", ")", "+", "label_len", ")", ";", "copy_len", "=", "(", "(", "dst_offset", "<", "dst", "->", "len", ")", "?", "(", "dst", "->", "len", "-", "dst_offset", ")", ":", "0", ")", ";", "if", "(", "copy_len", ">", "len", ")", "copy_len", "=", "len", ";", "memcpy", "(", "(", "dst", "->", "data", "+", "dst_offset", ")", ",", "label", ",", "copy_len", ")", ";", "src_offset", "+=", "len", ";", "dst_offset", "+=", "len", ";", "/*", "Terminate", "if", "we", "have", "reached", "the", "root", "*/", "if", "(", "label_len", "==", "0", ")", "return", "(", "dst_offset", "-", "dst", "->", "offset", ")", ";", "}", "/*", "Recursion", "limit", "exceeded", "*/", "return", "-", "EINVAL", ";", "}'" ]

[ "Resolve", "name", "using", "DNS" ]

[ "'static", "int", "dns_resolv", "(", "struct", "interface", "*", "resolv", ",", "const", "char", "*", "name", ",", "struct", "sockaddr", "*", "sa", ")", "{", "struct", "dns_request", "*", "dns", ";", "struct", "dns_header", "*", "query", ";", "size_t", "search_len", ";", "int", "name_len", ";", "int", "rc", ";", "/*", "Fail", "immediately", "if", "no", "DNS", "servers", "*/", "if", "(", "!", "nameserver", ".", "sa", ".", "sa_family", ")", "{", "DBG", "(", "\"DNS", "not", "attempting", "to", "resolve", "\\\\\"%s\\\\\":", "\"", "\"no", "DNS", "servers\\\"", ",", "name", ")", ";", "rc", "=", "-", "ENXIO_NO_NAMESERVER", ";", "goto", "err_no_nameserver", ";", "}", "/*", "Determine", "whether", "or", "not", "to", "use", "search", "list", "*/", "search_len", "=", "(", "strchr", "(", "name", ",", "\\'.\\'", ")", "?", "0", ":", "dns_search", ".", "len", ")", ";", "/*", "Allocate", "DNS", "structure", "*/", "dns", "=", "zalloc", "(", "sizeof", "(", "*", "dns", ")", "+", "search_len", ")", ";", "if", "(", "!", "dns", ")", "{", "rc", "=", "-", "ENOMEM", ";", "goto", "err_alloc_dns", ";", "}", "ref_init", "(", "&", "dns", "->", "refcnt", ",", "NULL", ")", ";", "intf_init", "(", "&", "dns", "->", "resolv", ",", "&", "dns_resolv_desc", ",", "&", "dns", "->", "refcnt", ")", ";", "intf_init", "(", "&", "dns", "->", "socket", ",", "&", "dns_socket_desc", ",", "&", "dns", "->", "refcnt", ")", ";", "timer_init", "(", "&", "dns", "->", "timer", ",", "dns_timer_expired", ",", "&", "dns", "->", "refcnt", ")", ";", "memcpy", "(", "&", "dns", "->", "address", ".", "sa", ",", "sa", ",", "sizeof", "(", "dns", "->", "address", ".", "sa", ")", ")", ";", "dns", "->", "search", ".", "data", "=", "(", "(", "(", "void", "*", ")", "dns", ")", "+", "sizeof", "(", "*", "dns", ")", ")", ";", "dns", "->", "search", ".", "len", "=", "search_len", ";", "memcpy", "(", "dns", "->", "search", ".", "data", ",", "dns_search", ".", "data", ",", "search_len", ")", ";", "/*", "Determine", "initial", "query", "type", "*/", "switch", "(", "nameserver", ".", "sa", ".", "sa_family", ")", "{", "case", "AF_INET", ":", "dns", "->", "qtype", "=", "htons", "(", "DNS_TYPE_A", ")", ";", "break;", "case", "AF_INET6", ":", "dns", "->", "qtype", "=", "htons", "(", "DNS_TYPE_AAAA", ")", ";", "break;", "default:", "rc", "=", "-", "ENOTSUP", ";", "goto", "err_type", ";", "}", "/*", "Construct", "query", "*/", "query", "=", "&", "dns", "->", "buf", ".", "query", ";", "query", "->", "flags", "=", "htons", "(", "DNS_FLAG_RD", ")", ";", "query", "->", "qdcount", "=", "htons", "(", "1", ")", ";", "dns", "->", "name", ".", "data", "=", "&", "dns", "->", "buf", ";", "dns", "->", "name", ".", "offset", "=", "offsetof", "(", "typeof", "(", "dns", "->", "buf", ")", ",", "name", ")", ";", "dns", "->", "name", ".", "len", "=", "offsetof", "(", "typeof", "(", "dns", "->", "buf", ")", ",", "padding", ")", ";", "name_len", "=", "dns_encode", "(", "name", ",", "&", "dns", "->", "name", ")", ";", "if", "(", "name_len", "<", "0", ")", "{", "rc", "=", "name_len", ";", "goto", "err_encode", ";", "}", "dns", "->", "offset", "=", "(", "offsetof", "(", "typeof", "(", "dns", "->", "buf", ")", ",", "name", ")", "+", "name_len", "-", "1", "/*", "Strip", "root", "label", "*/", ")", ";", "if", "(", "(", "rc", "=", "dns_question", "(", "dns", ")", ")", "!=", "0", ")", "goto", "err_question", ";", "/*", "Open", "UDP", "connection", "*/", "if", "(", "(", "rc", "=", "xfer_open_socket", "(", "&", "dns", "->", "socket", ",", "SOCK_DGRAM", ",", "&", "nameserver", ".", "sa", ",", "NULL", ")", ")", "!=", "0", ")", "{", "DBGC", "(", "dns", ",", "\"DNS", "%p", "could", "not", "open", "socket:", "%s\\\"", ",", "dns", ",", "strerror", "(", "rc", ")", ")", ";", "goto", "err_open_socket", ";", "}", "/*", "Start", "timer", "to", "trigger", "first", "packet", "*/", "start_timer_nodelay", "(", "&", "dns", "->", "timer", ")", ";", "/*", "Attach", "parent", "interface,", "mortalise", "self,", "and", "return", "*/", "intf_plug_plug", "(", "&", "dns", "->", "resolv", ",", "resolv", ")", ";", "ref_put", "(", "&", "dns", "->", "refcnt", ")", ";", "return", "0", ";", "err_open_socket", ":", "err_question", ":", "err_encode", ":", "err_type", ":", "ref_put", "(", "&", "dns", "->", "refcnt", ")", ";", "err_alloc_dns", ":", "err_no_nameserver", ":", "return", "rc", ";", "}'" ]

[ "Find", "start", "of", "valid", "label", "within", "an", "RFC1035encoded", "DNS", "name" ]

[ "'static", "int", "dns_label", "(", "struct", "dns_name", "*", "name", ",", "size_t", "offset", ")", "{", "const", "uint8_t", "*", "byte", ";", "const", "uint16_t", "*", "word", ";", "size_t", "len", ";", "size_t", "ptr", ";", "while", "(", "1", ")", "{", "/*", "Fail", "if", "we", "have", "overrun", "the", "DNS", "name", "*/", "if", "(", "(", "offset", "+", "sizeof", "(", "*", "byte", ")", ")", ">", "name", "->", "len", ")", "return", "-", "EINVAL", ";", "byte", "=", "(", "name", "->", "data", "+", "offset", ")", ";", "/*", "Follow", "compression", "pointer,", "if", "applicable", "*/", "if", "(", "DNS_IS_COMPRESSED", "(", "*", "byte", ")", ")", "{", "/*", "Fail", "if", "we", "have", "overrun", "the", "DNS", "name", "*/", "if", "(", "(", "offset", "+", "sizeof", "(", "*", "word", ")", ")", ">", "name", "->", "len", ")", "return", "-", "EINVAL", ";", "word", "=", "(", "name", "->", "data", "+", "offset", ")", ";", "/*", "Extract", "pointer", "to", "new", "offset", "*/", "ptr", "=", "DNS_COMPRESSED_OFFSET", "(", "ntohs", "(", "*", "word", ")", ")", ";", "/*", "Fail", "if", "pointer", "does", "not", "point", "backwards.", "*", "(This", "guarantees", "termination", "of", "the", "*", "function.)", "*/", "if", "(", "ptr", ">=", "offset", ")", "return", "-", "EINVAL", ";", "/*", "Continue", "from", "new", "offset", "*/", "offset", "=", "ptr", ";", "continue;", "}", "/*", "Fail", "if", "we", "have", "overrun", "the", "DNS", "name", "*/", "len", "=", "*", "byte", ";", "if", "(", "(", "offset", "+", "sizeof", "(", "*", "byte", ")", "+", "len", ")", ">", "name", "->", "len", ")", "return", "-", "EINVAL", ";", "/*", "We", "have", "a", "valid", "label", "*/", "return", "offset", ";", "}", "}'" ]