Datasets:

AISE-TUDelft

/

Capybara

like 1

[ "This", "is", "called", "from", "here", "and", "from", "ia64c" ]

[ "'void", "add_to_renaming_pragma_list", "(", "tree", "oldname", ",", "tree", "newname", ")", "{", "unsigned", "ix", ";", "pending_redefinition", "*", "p", ";", "FOR_EACH_VEC_SAFE_ELT", "(", "pending_redefine_extname", ",", "ix", ",", "p", ")", "if", "(", "oldname", "==", "p", "->", "oldname", ")", "{", "if", "(", "p", "->", "newname", "!=", "newname", ")", "warning", "(", "OPT_Wpragmas", ",", "\"#pragma", "redefine_extname", "ignored", "due", "to", "\"", "\"conflict", "with", "previous", "#pragma", "redefine_extname\"", ")", ";", "return", ";", "}", "pending_redefinition", "e", "=", "{", "oldname", ",", "newname", "}", ";", "vec_safe_push", "(", "pending_redefine_extname", ",", "e", ")", ";", "}'" ]

[ "Print", "a", "plain", "userspecified", "message" ]

[ "'static", "void", "handle_pragma_message", "(", "cpp_reader", "*", "ARG_UNUSED", "(", "dummy", ")", ")", "{", "enum", "cpp_ttype", "token", ";", "tree", "x", ",", "<type", "ref=\"prev\"/>", "message", "=", "0", ";", "token", "=", "pragma_lex", "(", "&", "x", ")", ";", "if", "(", "token", "==", "CPP_OPEN_PAREN", ")", "{", "token", "=", "pragma_lex", "(", "&", "x", ")", ";", "if", "(", "token", "==", "CPP_STRING", ")", "message", "=", "x", ";", "else", "GCC_BAD", "(", "\"expected", "a", "string", "after", "%<#pragma", "message%>\"", ")", ";", "if", "(", "pragma_lex", "(", "&", "x", ")", "!=", "CPP_CLOSE_PAREN", ")", "GCC_BAD", "(", "\"malformed", "%<#pragma", "message%>,", "ignored\"", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "token", "==", "CPP_STRING", ")", "message", "=", "x", ";", "else", "GCC_BAD", "(", "\"expected", "a", "string", "after", "%<#pragma", "message%>\"", ")", ";", "gcc_assert", "(", "message", ")", ";", "if", "(", "pragma_lex", "(", "&", "x", ")", "!=", "CPP_EOF", ")", "warning", "(", "OPT_Wpragmas", ",", "\"junk", "at", "end", "of", "%<#pragma", "message%>\"", ")", ";", "if", "(", "TREE_STRING_LENGTH", "(", "message", ")", ">", "1", ")", "inform", "(", "input_location", ",", "\"#pragma", "message:", "%s\"", ",", "TREE_STRING_POINTER", "(", "message", ")", ")", ";", "}'" ]

[ "Find", "symmetric", "(w,k)minimizers", "on", "a", "DNA", "sequence" ]

[ "'void", "mg_sketch", "(", "void", "*", "km", ",", "const", "char", "*", "str", ",", "int", "len", ",", "int", "w", ",", "int", "k", ",", "uint32_t", "rid", ",", "mg128_v", "*", "p", ")", "{", "uint64_t", "shift1", "=", "2", "*", "(", "k", "-", "1", ")", ",", "<type", "ref=\"prev\"/>", "mask", "=", "(", "1ULL", "<<", "2", "*", "k", ")", "-", "1", ",", "<type", "ref=\"prev\"/>", "kmer", "[", "2", "]", "=", "{", "0", ",", "0", "}", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ",", "<type", "ref=\"prev\"/>", "l", ",", "<type", "ref=\"prev\"/>", "buf_pos", ",", "<type", "ref=\"prev\"/>", "min_pos", ",", "<type", "ref=\"prev\"/>", "kmer_span", "=", "0", ";", "mg128_t", "buf", "[", "256", "]", ",", "<type", "ref=\"prev\"/>", "min", "=", "{", "UINT64_MAX", ",", "UINT64_MAX", "}", ";", "assert", "(", "len", ">", "0", "&&", "(", "w", ">", "0", "&&", "w", "<", "256", ")", "&&", "(", "k", ">", "0", "&&", "k", "<=", "28", ")", ")", ";", "//", "56", "bits", "for", "k-mer;", "could", "use", "long", "k-mers,", "but", "28", "enough", "in", "practice", "memset", "(", "buf", ",", "0xff", ",", "w", "*", "16", ")", ";", "kv_resize", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "p", "->", "n", "+", "len", "/", "w", ")", ";", "for", "(", "i", "=", "l", "=", "buf_pos", "=", "min_pos", "=", "0", ";", "i", "<", "len", ";", "++", "i", ")", "{", "int", "c", "=", "seq_nt4_table", "[", "(", "uint8_t", ")", "str", "[", "i", "]", "]", ";", "mg128_t", "info", "=", "{", "UINT64_MAX", ",", "UINT64_MAX", "}", ";", "if", "(", "c", "<", "4", ")", "{", "//", "not", "an", "ambiguous", "base", "int", "z", ";", "kmer_span", "=", "l", "+", "1", "<", "k", "?", "l", "+", "1", ":", "k", ";", "kmer", "[", "0", "]", "=", "(", "kmer", "[", "0", "]", "<<", "2", "|", "c", ")", "&", "mask", ";", "//", "forward", "k-mer", "kmer", "[", "1", "]", "=", "(", "kmer", "[", "1", "]", ">>", "2", ")", "|", "(", "3ULL", "^", "c", ")", "<<", "shift1", ";", "//", "reverse", "k-mer", "if", "(", "kmer", "[", "0", "]", "==", "kmer", "[", "1", "]", ")", "continue;", "//", "skip", "\"symmetric", "k-mers\"", "as", "we", "don\\'t", "know", "it", "strand", "z", "=", "kmer", "[", "0", "]", "<", "kmer", "[", "1", "]", "?", "0", ":", "1", ";", "//", "strand", "++", "l", ";", "if", "(", "l", ">=", "k", "&&", "kmer_span", "<", "256", ")", "{", "info", ".", "x", "=", "hash64", "(", "kmer", "[", "z", "]", ",", "mask", ")", "<<", "8", "|", "kmer_span", ";", "info", ".", "y", "=", "(", "uint64_t", ")", "rid", "<<", "32", "|", "(", "uint32_t", ")", "i", "<<", "1", "|", "z", ";", "}", "}", "else", "l", "=", "0", ",", "kmer_span", "=", "0", ";", "buf", "[", "buf_pos", "]", "=", "info", ";", "//", "need", "to", "do", "this", "here", "as", "appropriate", "buf_pos", "and", "buf[buf_pos]", "are", "needed", "below", "if", "(", "l", "==", "w", "+", "k", "-", "1", "&&", "min", ".", "x", "!=", "UINT64_MAX", ")", "{", "//", "special", "case", "for", "the", "first", "window", "-", "because", "identical", "k-mers", "are", "not", "stored", "yet", "for", "(", "j", "=", "buf_pos", "+", "1", ";", "j", "<", "w", ";", "++", "j", ")", "if", "(", "min", ".", "x", "==", "buf", "[", "j", "]", ".", "x", "&&", "buf", "[", "j", "]", ".", "y", "!=", "min", ".", "y", ")", "kv_push", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "buf", "[", "j", "]", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "buf_pos", ";", "++", "j", ")", "if", "(", "min", ".", "x", "==", "buf", "[", "j", "]", ".", "x", "&&", "buf", "[", "j", "]", ".", "y", "!=", "min", ".", "y", ")", "kv_push", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "buf", "[", "j", "]", ")", ";", "}", "if", "(", "info", ".", "x", "<=", "min", ".", "x", ")", "{", "//", "a", "new", "minimum;", "then", "write", "the", "old", "min", "if", "(", "l", ">=", "w", "+", "k", "&&", "min", ".", "x", "!=", "UINT64_MAX", ")", "kv_push", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "min", ")", ";", "min", "=", "info", ",", "min_pos", "=", "buf_pos", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "buf_pos", "==", "min_pos", ")", "{", "//", "old", "min", "has", "moved", "outside", "the", "window", "if", "(", "l", ">=", "w", "+", "k", "-", "1", "&&", "min", ".", "x", "!=", "UINT64_MAX", ")", "kv_push", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "min", ")", ";", "for", "(", "j", "=", "buf_pos", "+", "1", ",", "min", ".", "x", "=", "UINT64_MAX", ";", "j", "<", "w", ";", "++", "j", ")", "//", "the", "two", "loops", "are", "necessary", "when", "there", "are", "identical", "k-mers", "if", "(", "min", ".", "x", ">=", "buf", "[", "j", "]", ".", "x", ")", "min", "=", "buf", "[", "j", "]", ",", "min_pos", "=", "j", ";", "//", ">=", "is", "important", "s.t.", "min", "is", "always", "the", "closest", "k-mer", "for", "(", "j", "=", "0", ";", "j", "<=", "buf_pos", ";", "++", "j", ")", "if", "(", "min", ".", "x", ">=", "buf", "[", "j", "]", ".", "x", ")", "min", "=", "buf", "[", "j", "]", ",", "min_pos", "=", "j", ";", "if", "(", "l", ">=", "w", "+", "k", "-", "1", "&&", "min", ".", "x", "!=", "UINT64_MAX", ")", "{", "//", "write", "identical", "k-mers", "for", "(", "j", "=", "buf_pos", "+", "1", ";", "j", "<", "w", ";", "++", "j", ")", "//", "these", "two", "loops", "make", "sure", "the", "output", "is", "sorted", "if", "(", "min", ".", "x", "==", "buf", "[", "j", "]", ".", "x", "&&", "min", ".", "y", "!=", "buf", "[", "j", "]", ".", "y", ")", "kv_push", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "buf", "[", "j", "]", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<=", "buf_pos", ";", "++", "j", ")", "if", "(", "min", ".", "x", "==", "buf", "[", "j", "]", ".", "x", "&&", "min", ".", "y", "!=", "buf", "[", "j", "]", ".", "y", ")", "kv_push", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "buf", "[", "j", "]", ")", ";", "}", "}", "if", "(", "++", "buf_pos", "==", "w", ")", "buf_pos", "=", "0", ";", "}", "if", "(", "min", ".", "x", "!=", "UINT64_MAX", ")", "kv_push", "(", "mg128_t", ",", "km", ",", "*", "p", ",", "min", ")", ";", "}'" ]

[ "Constrains", "a", "box", "to", "fill", "a", "bounding", "box", "without", "changing", "aspect" ]

[ "'void", "rs_constrain_to_bounding_box", "(", "gint", "target_width", ",", "gint", "target_height", ",", "gint", "*", "width", ",", "gint", "*", "height", ")", "{", "g_return_if_fail", "(", "width", "!=", "NULL", ")", ";", "g_return_if_fail", "(", "height", "!=", "NULL", ")", ";", "gdouble", "target_aspect", "=", "(", "(", "gdouble", ")", "target_width", ")", "/", "(", "(", "gdouble", ")", "target_height", ")", ";", "gdouble", "input_aspect", "=", "(", "(", "gdouble", ")", "*", "width", ")", "/", "(", "(", "gdouble", ")", "*", "height", ")", ";", "gdouble", "scale", ";", "if", "(", "target_aspect", "<", "input_aspect", ")", "scale", "=", "(", "(", "gdouble", ")", "*", "width", ")", "/", "(", "(", "gdouble", ")", "target_width", ")", ";", "else", "scale", "=", "(", "(", "gdouble", ")", "*", "height", ")", "/", "(", "(", "gdouble", ")", "target_height", ")", ";", "*", "width", "=", "MIN", "(", "(", "gint", ")", "(", "(", "gdouble", ")", "*", "width", ")", "/", "scale", ",", "target_width", ")", ";", "*", "height", "=", "MIN", "(", "(", "gint", ")", "(", "(", "gdouble", ")", "*", "height", ")", "/", "scale", ",", "target_height", ")", ";", "}'" ]

[ "Rotate", "a", "RS_RECT", "in", "90", "degrees", "steps" ]

[ "'void", "rs_rect_rotate", "(", "RS_RECT", "*", "in", ",", "RS_RECT", "*", "out", ",", "gint", "w", ",", "gint", "h", ",", "gint", "quarterturns", ")", "{", "gint", "x1", ",", "<type", "ref=\"prev\"/>", "y1", ";", "gint", "x2", ",", "<type", "ref=\"prev\"/>", "y2", ";", "g_return_if_fail", "(", "in", "!=", "NULL", ")", ";", "g_return_if_fail", "(", "out", "!=", "NULL", ")", ";", "x1", "=", "in", "->", "x2", ";", "x2", "=", "in", "->", "x1", ";", "y1", "=", "in", "->", "y1", ";", "y2", "=", "in", "->", "y2", ";", "switch", "(", "quarterturns", ")", "{", "case", "1", ":", "x1", "=", "h", "-", "in", "->", "y1", "-", "1", ";", "x2", "=", "h", "-", "in", "->", "y2", "-", "1", ";", "y1", "=", "in", "->", "x1", ";", "y2", "=", "in", "->", "x2", ";", "break;", "case", "2", ":", "x1", "=", "w", "-", "in", "->", "x1", "-", "1", ";", "x2", "=", "w", "-", "in", "->", "x2", "-", "1", ";", "y1", "=", "h", "-", "in", "->", "y1", "-", "1", ";", "y2", "=", "h", "-", "in", "->", "y2", "-", "1", ";", "break;", "case", "3", ":", "x1", "=", "in", "->", "y1", ";", "x2", "=", "in", "->", "y2", ";", "y1", "=", "w", "-", "in", "->", "x1", "-", "1", ";", "y2", "=", "w", "-", "in", "->", "x2", "-", "1", ";", "break;", "}", "out", "->", "x1", "=", "x1", ";", "out", "->", "x2", "=", "x2", ";", "out", "->", "y1", "=", "y1", ";", "out", "->", "y2", "=", "y2", ";", "rs_rect_normalize", "(", "out", ",", "out", ")", ";", "}'" ]

[ "Reset", "a", "property", "on", "a", "GObject", "to", "it's", "default" ]

[ "'void", "rs_object_class_property_reset", "(", "GObject", "*", "object", ",", "const", "gchar", "*", "property_name", ")", "{", "GObjectClass", "*", "klass", ";", "GParamSpec", "*", "spec", ";", "GValue", "value", "=", "{", "0", "}", ";", "g_return_if_fail", "(", "G_IS_OBJECT", "(", "object", ")", ")", ";", "g_return_if_fail", "(", "property_name", "!=", "NULL", ")", ";", "klass", "=", "G_OBJECT_GET_CLASS", "(", "object", ")", ";", "spec", "=", "g_object_class_find_property", "(", "klass", ",", "property_name", ")", ";", "g_return_if_fail", "(", "spec", "!=", "NULL", ")", ";", "g_value_init", "(", "&", "value", ",", "spec", "->", "value_type", ")", ";", "g_param_value_set_default", "(", "spec", ",", "&", "value", ")", ";", "g_object_set_property", "(", "object", ",", "spec", "->", "name", ",", "&", "value", ")", ";", "g_value_unset", "(", "&", "value", ")", ";", "}'" ]

[ "A", "convenience", "function", "to", "convert", "an", "EXIF", "timestamp", "to", "a", "unix", "timestamp" ]

[ "'GTime", "rs_exiftime_to_unixtime", "(", "const", "gchar", "*", "str", ")", "{", "struct", "tm", "*", "tm", ";", "GTime", "timestamp", "=", "-", "1", ";", "g_return_val_if_fail", "(", "str", "!=", "NULL", ",", "-", "1", ")", ";", "tm", "=", "g_new0", "(", "struct", "tm", ",", "1", ")", ";", "if", "(", "strptime", "(", "str", ",", "\"%Y:%m:%d", "%H:%M:%S\"", ",", "tm", ")", ")", "timestamp", "=", "(", "GTime", ")", "mktime", "(", "tm", ")", ";", "g_free", "(", "tm", ")", ";", "return", "timestamp", ";", "}'" ]

[ "A", "convenience", "function", "to", "convert", "an", "unix", "timestamp", "to", "an", "EXIF", "timestamp" ]

[ "'gchar", "*", "rs_unixtime_to_exiftime", "(", "GTime", "timestamp", ")", "{", "struct", "tm", "*", "tm", "=", "g_new0", "(", "struct", "tm", ",", "1", ")", ";", "time_t", "tt", "=", "(", "time_t", ")", "timestamp", ";", "gchar", "*", "result", "=", "g_new0", "(", "gchar", ",", "20", ")", ";", "gmtime_r", "(", "&", "tt", ",", "tm", ")", ";", "if", "(", "strftime", "(", "result", ",", "20", ",", "\"%Y:%m:%d", "%H:%M:%S\"", ",", "tm", ")", "!=", "19", ")", "{", "g_free", "(", "result", ")", ";", "result", "=", "NULL", ";", "}", "g_free", "(", "tm", ")", ";", "return", "result", ";", "}'" ]

[ "Return", "a", "cache", "directory", "for", "filename" ]

[ "'gchar", "*", "rs_dotdir_get", "(", "const", "gchar", "*", "filename", ")", "{", "gchar", "*", "ret", "=", "NULL", ";", "gchar", "*", "directory", "=", "NULL", ";", "GString", "*", "dotdir", "=", "NULL", ";", "gboolean", "dotdir_is_local", "=", "FALSE", ";", "/*", "We", "never", "have", "local", "cache", "for", "/var/,", "since", "it", "is", "temporary", "*/", "if", "(", "0", "!=", "g_ascii_strncasecmp", "(", "filename", ",", "\"/var/\"", ",", "5", ")", ")", "{", "rs_conf_get_boolean", "(", "CONF_CACHEDIR_IS_LOCAL", ",", "&", "dotdir_is_local", ")", ";", "if", "(", "g_file_test", "(", "filename", ",", "G_FILE_TEST_IS_DIR", ")", ")", "directory", "=", "g_strdup", "(", "filename", ")", ";", "else", "directory", "=", "g_path_get_dirname", "(", "filename", ")", ";", "if", "(", "dotdir_is_local", ")", "{", "dotdir", "=", "g_string_new", "(", "g_get_home_dir", "()", ")", ";", "dotdir", "=", "g_string_append", "(", "dotdir", ",", "G_DIR_SEPARATOR_S", ")", ";", "dotdir", "=", "g_string_append", "(", "dotdir", ",", "DOTDIR", ")", ";", "dotdir", "=", "g_string_append", "(", "dotdir", ",", "G_DIR_SEPARATOR_S", ")", ";", "dotdir", "=", "g_string_append", "(", "dotdir", ",", "directory", ")", ";", "}", "else", "{", "dotdir", "=", "g_string_new", "(", "directory", ")", ";", "dotdir", "=", "g_string_append", "(", "dotdir", ",", "G_DIR_SEPARATOR_S", ")", ";", "dotdir", "=", "g_string_append", "(", "dotdir", ",", "DOTDIR", ")", ";", "}", "if", "(", "!", "g_file_test", "(", "dotdir", "->", "str", ",", "(", "G_FILE_TEST_EXISTS", "|", "G_FILE_TEST_IS_DIR", ")", ")", ")", "{", "if", "(", "g_mkdir_with_parents", "(", "dotdir", "->", "str", ",", "0700", ")", "!=", "0", ")", "ret", "=", "NULL", ";", "else", "ret", "=", "dotdir", "->", "str", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "g_file_test", "(", "dotdir", "->", "str", ",", "G_FILE_TEST_IS_DIR", ")", ")", "ret", "=", "dotdir", "->", "str", ";", "else", "ret", "=", "NULL", ";", "}", "/*", "If", "we", "for", "some", "reason", "cannot", "write", "to", "the", "current", "directory,", "*/", "/*", "we", "save", "it", "to", "a", "new", "folder", "named", "as", "the", "md5", "of", "the", "file", "content,", "*/", "/*", "not", "particularly", "fast,", "but", "ensures", "that", "the", "images", "can", "be", "moved", "*/", "if", "(", "ret", "==", "NULL", ")", "{", "if", "(", "dotdir", ")", "g_string_free", "(", "dotdir", ",", "TRUE", ")", ";", "if", "(", "directory", ")", "g_free", "(", "directory", ")", ";", "if", "(", "g_file_test", "(", "filename", ",", "G_FILE_TEST_IS_REGULAR", ")", ")", "{", "gchar", "*", "md5", "=", "rs_file_checksum", "(", "filename", ")", ";", "ret", "=", "g_strdup_printf", "(", "\"%s/read-only-cache/%s\"", ",", "rs_confdir_get", "()", ",", "md5", ")", ";", "g_free", "(", "md5", ")", ";", "if", "(", "!", "g_file_test", "(", "ret", ",", "(", "G_FILE_TEST_EXISTS", "|", "G_FILE_TEST_IS_DIR", ")", ")", ")", "{", "if", "(", "g_mkdir_with_parents", "(", "ret", ",", "0700", ")", "!=", "0", ")", "ret", "=", "NULL", ";", "}", "}", "return", "ret", ";", "}", "g_free", "(", "directory", ")", ";", "g_string_free", "(", "dotdir", ",", "FALSE", ")", ";", "return", "(", "ret", ")", ";", "}'" ]

[ "Normalize", "a", "RS_RECT,", "ie", "makes", "sure", "that", "x1", "<", "x2", "and", "y1<y2" ]

[ "'void", "rs_rect_normalize", "(", "RS_RECT", "*", "in", ",", "RS_RECT", "*", "out", ")", "{", "gint", "n", ";", "gint", "x1", ",", "<type", "ref=\"prev\"/>", "y1", ";", "gint", "x2", ",", "<type", "ref=\"prev\"/>", "y2", ";", "g_return_if_fail", "(", "in", "!=", "NULL", ")", ";", "g_return_if_fail", "(", "out", "!=", "NULL", ")", ";", "x1", "=", "in", "->", "x2", ";", "x2", "=", "in", "->", "x1", ";", "y1", "=", "in", "->", "y1", ";", "y2", "=", "in", "->", "y2", ";", "if", "(", "x1", ">", "x2", ")", "{", "n", "=", "x1", ";", "x1", "=", "x2", ";", "x2", "=", "n", ";", "}", "if", "(", "y1", ">", "y2", ")", "{", "n", "=", "y1", ";", "y1", "=", "y2", ";", "y2", "=", "n", ";", "}", "out", "->", "x1", "=", "x1", ";", "out", "->", "x2", "=", "x2", ";", "out", "->", "y1", "=", "y1", ";", "out", "->", "y2", "=", "y2", ";", "}'" ]

[ "Rewritten", "from", "Exiftools", "lib", "Image", "ExifTool", "Canon" ]

[ "'gfloat", "CanonEv", "(", "gint", "val", ")", "{", "gfloat", "sign", ";", "gfloat", "frac", ";", "/*", "temporarily", "make", "the", "number", "positive", "*/", "if", "(", "val", "<", "0", ")", "{", "val", "=", "-", "val", ";", "sign", "=", "-", "1.0", ";", "}", "else", "{", "sign", "=", "1.0", ";", "}", "gint", "ifrac", "=", "val", "&", "0x1f", ";", "/*", "remove", "fraction", "*/", "val", "-=", "ifrac", ";", "/*", "Convert", "1/3", "and", "2/3", "codes", "*/", "if", "(", "ifrac", "==", "0x0c", ")", "frac", "=", "32.0", "/", "3.0", ";", "/*", "0x20", "/", "3", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "ifrac", "==", "0x14", ")", "frac", "=", "64.0", "/", "3.0", ";", "/*", "0x40", "/", "3", "*/", "else", "frac", "=", "(", "gfloat", ")", "ifrac", ";", "return", "sign", "*", "(", "(", "(", "gfloat", ")", "val", ")", "+", "frac", ")", "/", "32.0", ";", "}'" ]

[ "Split", "a", "char", "with", "a", "given", "delimiter" ]

[ "'GList", "*", "rs_split_string", "(", "const", "gchar", "*", "str", ",", "const", "gchar", "*", "delimiters", ")", "{", "g_return_val_if_fail", "(", "str", "!=", "NULL", ",", "NULL", ")", ";", "g_return_val_if_fail", "(", "delimiters", "!=", "NULL", ",", "NULL", ")", ";", "gchar", "*", "*", "temp", "=", "g_strsplit_set", "(", "str", ",", "delimiters", ",", "0", ")", ";", "int", "i", "=", "0", ";", "GList", "*", "glist", "=", "NULL", ";", "while", "(", "temp", "[", "i", "]", ")", "{", "gchar", "*", "text", "=", "(", "gchar", "*", ")", "temp", "[", "i", "]", ";", "if", "(", "text", "[", "0", "]", "!=", "0", ")", "glist", "=", "g_list_append", "(", "glist", ",", "text", ")", ";", "else", "g_free", "(", "text", ")", ";", "i", "++", ";", "}", "g_free", "(", "temp", ")", ";", "return", "glist", ";", "}'" ]

[ "Copy", "a", "file", "from", "one", "location", "to", "another" ]

[ "'gboolean", "rs_file_copy", "(", "const", "gchar", "*", "source", ",", "const", "gchar", "*", "destination", ")", "{", "gboolean", "ret", "=", "FALSE", ";", "const", "gint", "buffer_size", "=", "1024", "*", "1024", ";", "gint", "source_fd", ",", "<type", "ref=\"prev\"/>", "destination_fd", ";", "gint", "bytes_read", ",", "<type", "ref=\"prev\"/>", "bytes_written", ";", "struct", "stat", "st", ";", "mode_t", "default_mode", "=", "00666", ";", "/*", "We", "set", "this", "relaxed", "to", "respect", "the", "users", "umask", "*/", "g_return_val_if_fail", "(", "source", "!=", "NULL", ",", "FALSE", ")", ";", "g_return_val_if_fail", "(", "source", "[", "0", "]", "!=", "\\'\\\\0\\'", ",", "FALSE", ")", ";", "g_return_val_if_fail", "(", "g_path_is_absolute", "(", "source", ")", ",", "FALSE", ")", ";", "g_return_val_if_fail", "(", "destination", "!=", "NULL", ",", "FALSE", ")", ";", "g_return_val_if_fail", "(", "destination", "[", "0", "]", "!=", "\\'\\\\0\\'", ",", "FALSE", ")", ";", "g_return_val_if_fail", "(", "g_path_is_absolute", "(", "destination", ")", ",", "FALSE", ")", ";", "source_fd", "=", "open", "(", "source", ",", "O_RDONLY", ")", ";", "if", "(", "source_fd", ">", "0", ")", "{", "/*", "Try", "to", "copy", "permissions", "too", "*/", "if", "(", "fstat", "(", "source_fd", ",", "&", "st", ")", "==", "0", ")", "default_mode", "=", "st", ".", "st_mode", ";", "destination_fd", "=", "creat", "(", "destination", ",", "default_mode", ")", ";", "if", "(", "destination_fd", ">", "0", ")", "{", "gpointer", "buffer", "=", "g_malloc", "(", "buffer_size", ")", ";", "do", "{", "bytes_read", "=", "read", "(", "source_fd", ",", "buffer", ",", "buffer_size", ")", ";", "bytes_written", "=", "write", "(", "destination_fd", ",", "buffer", ",", "bytes_read", ")", ";", "if", "(", "bytes_written", "!=", "bytes_read", ")", "g_warning", "(", "\"%s", "was", "truncated\"", ",", "destination", ")", ";", "}", "while", "(", "bytes_read", ">", "0", ")", ";", "g_free", "(", "buffer", ")", ";", "ret", "=", "TRUE", ";", "close", "(", "destination_fd", ")", ";", "}", "close", "(", "source_fd", ")", ";", "}", "return", "ret", ";", "}'" ]

[ "Removes", "tailing", "spaces", "from", "a", "gchar" ]

[ "'gchar", "*", "rs_remove_tailing_spaces", "(", "gchar", "*", "str", ",", "gboolean", "inplace", ")", "{", "gint", "i", ";", "gchar", "*", "ret", "=", "str", ";", "g_return_val_if_fail", "(", "str", "!=", "NULL", ",", "NULL", ")", ";", "if", "(", "!", "inplace", ")", "ret", "=", "g_strdup", "(", "str", ")", ";", "for", "(", "i", "=", "strlen", "(", "ret", ")", "-", "1", ";", "i", ">", "0", ";", "i", "--", ")", "{", "if", "(", "ret", "[", "i", "]", "==", "0x20", ")", "ret", "[", "i", "]", "=", "0x00", ";", "else", "i", "=", "0", ";", "}", "return", "ret", ";", "}'" ]

[ "A", "version", "of", "atof()", "that", "isn't", "locale", "specific", "@note", "This", "doesn't", "do", "any", "error", "checking!" ]

[ "'gdouble", "rs_atof", "(", "const", "gchar", "*", "str", ")", "{", "gdouble", "result", "=", "0.0f", ";", "gdouble", "div", "=", "1.0f", ";", "gboolean", "point_passed", "=", "FALSE", ";", "gchar", "*", "ptr", "=", "(", "gchar", "*", ")", "str", ";", "while", "(", "str", "&&", "*", "ptr", ")", "{", "if", "(", "g_ascii_isdigit", "(", "*", "ptr", ")", ")", "{", "result", "=", "result", "*", "10.0f", "+", "g_ascii_digit_value", "(", "*", "ptr", ")", ";", "if", "(", "point_passed", ")", "div", "*=", "10.0f", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "*", "ptr", "==", "\\'-\\'", ")", "div", "*=", "-", "1.0f", ";", "<if", "type=\"elseif\">", "else", "if", "(", "g_ascii_ispunct", "(", "*", "ptr", ")", ")", "point_passed", "=", "TRUE", ";", "ptr", "++", ";", "}", "return", "result", "/", "div", ";", "}'" ]

[ "Key", "Agreement", "Recipient", "Info", "(KARI)", "routines" ]

[ "'int", "CMS_RecipientInfo_kari_get0_alg", "(", "CMS_RecipientInfo", "*", "ri", ",", "X509_ALGOR", "*", "*", "palg", ",", "ASN1_OCTET_STRING", "*", "*", "pukm", ")", "{", "if", "(", "ri", "->", "type", "!=", "CMS_RECIPINFO_AGREE", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG", ",", "CMS_R_NOT_KEY_AGREEMENT", ")", ";", "return", "0", ";", "}", "if", "(", "palg", ")", "*", "palg", "=", "ri", "->", "d", ".", "kari", "->", "keyEncryptionAlgorithm", ";", "if", "(", "pukm", ")", "*", "pukm", "=", "ri", "->", "d", ".", "kari", "->", "ukm", ";", "return", "1", ";", "}'" ]

[ "Encrypt", "content", "key", "in", "key", "agreement", "recipient", "info" ]

[ "'int", "cms_RecipientInfo_kari_encrypt", "(", "CMS_ContentInfo", "*", "cms", ",", "CMS_RecipientInfo", "*", "ri", ")", "{", "CMS_KeyAgreeRecipientInfo", "*", "kari", ";", "CMS_EncryptedContentInfo", "*", "ec", ";", "CMS_RecipientEncryptedKey", "*", "rek", ";", "STACK_OF", "(", "CMS_RecipientEncryptedKey", ")", "*", "reks", ";", "int", "i", ";", "if", "(", "ri", "->", "type", "!=", "CMS_RECIPINFO_AGREE", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT", ",", "CMS_R_NOT_KEY_AGREEMENT", ")", ";", "return", "0", ";", "}", "kari", "=", "ri", "->", "d", ".", "kari", ";", "reks", "=", "kari", "->", "recipientEncryptedKeys", ";", "ec", "=", "cms", "->", "d", ".", "envelopedData", "->", "encryptedContentInfo", ";", "/*", "Initialise", "wrap", "algorithm", "parameters", "*/", "if", "(", "!", "cms_wrap_init", "(", "kari", ",", "ec", "->", "cipher", ")", ")", "return", "0", ";", "/*", "*", "If", "no", "originator", "key", "set", "up", "initialise", "for", "ephemeral", "key", "the", "public", "key", "*", "ASN1", "structure", "will", "set", "the", "actual", "public", "key", "value.", "*/", "if", "(", "kari", "->", "originator", "->", "type", "==", "-", "1", ")", "{", "CMS_OriginatorIdentifierOrKey", "*", "oik", "=", "kari", "->", "originator", ";", "oik", "->", "type", "=", "CMS_OIK_PUBKEY", ";", "oik", "->", "d", ".", "originatorKey", "=", "M_ASN1_new_of", "(", "CMS_OriginatorPublicKey", ")", ";", "if", "(", "!", "oik", "->", "d", ".", "originatorKey", ")", "return", "0", ";", "}", "/*", "Initialise", "KDF", "algorithm", "*/", "if", "(", "!", "cms_env_asn1_ctrl", "(", "ri", ",", "0", ")", ")", "return", "0", ";", "/*", "For", "each", "rek,", "derive", "KEK,", "encrypt", "CEK", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "sk_CMS_RecipientEncryptedKey_num", "(", "reks", ")", ";", "i", "++", ")", "{", "unsigned", "char", "*", "enckey", ";", "size_t", "enckeylen", ";", "rek", "=", "sk_CMS_RecipientEncryptedKey_value", "(", "reks", ",", "i", ")", ";", "if", "(", "EVP_PKEY_derive_set_peer", "(", "kari", "->", "pctx", ",", "rek", "->", "pkey", ")", "<=", "0", ")", "return", "0", ";", "if", "(", "!", "cms_kek_cipher", "(", "&", "enckey", ",", "&", "enckeylen", ",", "ec", "->", "key", ",", "ec", "->", "keylen", ",", "kari", ",", "1", ")", ")", "return", "0", ";", "ASN1_STRING_set0", "(", "rek", "->", "encryptedKey", ",", "enckey", ",", "enckeylen", ")", ";", "}", "return", "1", ";", "}'" ]

[ "Initialise", "a", "kari", "based", "on", "passed", "certificate", "and", "key" ]

[ "'int", "cms_RecipientInfo_kari_init", "(", "CMS_RecipientInfo", "*", "ri", ",", "X509", "*", "recip", ",", "EVP_PKEY", "*", "pk", ",", "unsigned", "int", "flags", ")", "{", "CMS_KeyAgreeRecipientInfo", "*", "kari", ";", "CMS_RecipientEncryptedKey", "*", "rek", "=", "NULL", ";", "ri", "->", "d", ".", "kari", "=", "M_ASN1_new_of", "(", "CMS_KeyAgreeRecipientInfo", ")", ";", "if", "(", "!", "ri", "->", "d", ".", "kari", ")", "return", "0", ";", "ri", "->", "type", "=", "CMS_RECIPINFO_AGREE", ";", "kari", "=", "ri", "->", "d", ".", "kari", ";", "kari", "->", "version", "=", "3", ";", "rek", "=", "M_ASN1_new_of", "(", "CMS_RecipientEncryptedKey", ")", ";", "if", "(", "rek", "==", "NULL", ")", "return", "0", ";", "if", "(", "!", "sk_CMS_RecipientEncryptedKey_push", "(", "kari", "->", "recipientEncryptedKeys", ",", "rek", ")", ")", "{", "M_ASN1_free_of", "(", "rek", ",", "CMS_RecipientEncryptedKey", ")", ";", "return", "0", ";", "}", "if", "(", "flags", "&", "CMS_USE_KEYID", ")", "{", "rek", "->", "rid", "->", "type", "=", "CMS_REK_KEYIDENTIFIER", ";", "rek", "->", "rid", "->", "d", ".", "rKeyId", "=", "M_ASN1_new_of", "(", "CMS_RecipientKeyIdentifier", ")", ";", "if", "(", "rek", "->", "rid", "->", "d", ".", "rKeyId", "==", "NULL", ")", "return", "0", ";", "if", "(", "!", "cms_set1_keyid", "(", "&", "rek", "->", "rid", "->", "d", ".", "rKeyId", "->", "subjectKeyIdentifier", ",", "recip", ")", ")", "return", "0", ";", "}", "else", "{", "rek", "->", "rid", "->", "type", "=", "CMS_REK_ISSUER_SERIAL", ";", "if", "(", "!", "cms_set1_ias", "(", "&", "rek", "->", "rid", "->", "d", ".", "issuerAndSerialNumber", ",", "recip", ")", ")", "return", "0", ";", "}", "/*", "Create", "ephemeral", "key", "*/", "if", "(", "!", "cms_kari_create_ephemeral_key", "(", "kari", ",", "pk", ")", ")", "return", "0", ";", "EVP_PKEY_up_ref", "(", "pk", ")", ";", "rek", "->", "pkey", "=", "pk", ";", "return", "1", ";", "}'" ]

[ "Look", "through", "a", "list", "of", "name", "value", "pairs" ]

[ "'int", "opt_pair", "(", "const", "char", "*", "name", ",", "const", "OPT_PAIR", "*", "pairs", ",", "int", "*", "result", ")", "{", "const", "OPT_PAIR", "*", "pp", ";", "for", "(", "pp", "=", "pairs", ";", "pp", "->", "name", ";", "pp", "++", ")", "if", "(", "strcmp", "(", "pp", "->", "name", ",", "name", ")", "==", "0", ")", "{", "*", "result", "=", "pp", "->", "retval", ";", "return", "1", ";", "}", "BIO_printf", "(", "bio_err", ",", "\"%s:", "Value", "must", "be", "one", "of:\\\"", ",", "prog", ")", ";", "for", "(", "pp", "=", "pairs", ";", "pp", "->", "name", ";", "pp", "++", ")", "BIO_printf", "(", "bio_err", ",", "\"\\\\t%s\\\"", ",", "pp", "->", "name", ")", ";", "return", "0", ";", "}'" ]

[ "Parse", "a", "format", "string,", "put", "it", "into", "result;", "return", "0", "on", "failure,", "else", "1" ]

[ "'int", "opt_format", "(", "const", "char", "*", "s", ",", "unsigned", "long", "flags", ",", "int", "*", "result", ")", "{", "switch", "(", "*", "s", ")", "{", "default:", "return", "0", ";", "case", "\\'D\\'", ":", "case", "\\'d\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_PEMDER", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_ASN1", ";", "break;", "case", "\\'T\\'", ":", "case", "\\'t\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_TEXT", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_TEXT", ";", "break;", "case", "\\'B\\'", ":", "case", "\\'b\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_BINARY", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_BINARY", ";", "break;", "case", "\\'N\\'", ":", "case", "\\'n\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_NSS", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "if", "(", "strcmp", "(", "s", ",", "\"NSS\"", ")", "!=", "0", "&&", "strcmp", "(", "s", ",", "\"nss\"", ")", "!=", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_NSS", ";", "break;", "case", "\\'S\\'", ":", "case", "\\'s\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_SMIME", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_SMIME", ";", "break;", "case", "\\'M\\'", ":", "case", "\\'m\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_MSBLOB", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_MSBLOB", ";", "break;", "case", "\\'E\\'", ":", "case", "\\'e\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_ENGINE", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_ENGINE", ";", "break;", "case", "\\'H\\'", ":", "case", "\\'h\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_HTTP", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_HTTP", ";", "break;", "case", "\\'1\\'", ":", "if", "(", "(", "flags", "&", "OPT_FMT_PKCS12", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_PKCS12", ";", "break;", "case", "\\'P\\'", ":", "case", "\\'p\\'", ":", "if", "(", "s", "[", "1", "]", "==", "\\'\\\\0\\'", "||", "strcmp", "(", "s", ",", "\"PEM\"", ")", "==", "0", "||", "strcmp", "(", "s", ",", "\"pem\"", ")", "==", "0", ")", "{", "if", "(", "(", "flags", "&", "OPT_FMT_PEMDER", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_PEM", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "s", ",", "\"PVK\"", ")", "==", "0", "||", "strcmp", "(", "s", ",", "\"pvk\"", ")", "==", "0", ")", "{", "if", "(", "(", "flags", "&", "OPT_FMT_PVK", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_PVK", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "s", ",", "\"P12\"", ")", "==", "0", "||", "strcmp", "(", "s", ",", "\"p12\"", ")", "==", "0", "||", "strcmp", "(", "s", ",", "\"PKCS12\"", ")", "==", "0", "||", "strcmp", "(", "s", ",", "\"pkcs12\"", ")", "==", "0", ")", "{", "if", "(", "(", "flags", "&", "OPT_FMT_PKCS12", ")", "==", "0", ")", "return", "opt_format_error", "(", "s", ",", "flags", ")", ";", "*", "result", "=", "FORMAT_PKCS12", ";", "}", "else", "return", "0", ";", "break;", "}", "return", "1", ";", "}'" ]

[ "Parse", "an", "intmax_t,", "put", "it", "into", "result;", "return", "0", "on", "failure,", "else", "1" ]

[ "'int", "opt_imax", "(", "const", "char", "*", "value", ",", "intmax_t", "*", "result", ")", "{", "int", "oerrno", "=", "errno", ";", "intmax_t", "m", ";", "char", "*", "endp", ";", "errno", "=", "0", ";", "m", "=", "strtoimax", "(", "value", ",", "&", "endp", ",", "0", ")", ";", "if", "(", "*", "endp", "||", "endp", "==", "value", "||", "(", "(", "m", "==", "INTMAX_MAX", "||", "m", "==", "INTMAX_MIN", ")", "&&", "errno", "==", "ERANGE", ")", "||", "(", "m", "==", "0", "&&", "errno", "!=", "0", ")", ")", "{", "BIO_printf", "(", "bio_err", ",", "\"%s:", "Can\\'t", "parse", "\\\\\"%s\\\\\"", "as", "a", "number\\\"", ",", "prog", ",", "value", ")", ";", "errno", "=", "oerrno", ";", "return", "0", ";", "}", "*", "result", "=", "m", ";", "errno", "=", "oerrno", ";", "return", "1", ";", "}'" ]

[ "Return", "the", "rest", "of", "the", "arguments", "after", "parsing", "flags" ]

[ "'char", "*", "*", "opt_rest", "(", "void", ")", "{", "return", "&", "argv", "[", "opt_index", "]", ";", "}'" ]

[ "Print", "an", "error", "message", "about", "a", "failed", "format", "parse" ]

[ "'int", "opt_format_error", "(", "const", "char", "*", "s", ",", "unsigned", "long", "flags", ")", "{", "OPT_PAIR", "*", "ap", ";", "if", "(", "flags", "==", "OPT_FMT_PEMDER", ")", "BIO_printf", "(", "bio_err", ",", "\"%s:", "Bad", "format", "\\\\\"%s\\\\\";", "must", "be", "pem", "or", "der\\\"", ",", "prog", ",", "s", ")", ";", "else", "{", "BIO_printf", "(", "bio_err", ",", "\"%s:", "Bad", "format", "\\\\\"%s\\\\\";", "must", "be", "one", "of:\\\"", ",", "prog", ",", "s", ")", ";", "for", "(", "ap", "=", "formats", ";", "ap", "->", "name", ";", "ap", "++", ")", "if", "(", "flags", "&", "ap", "->", "retval", ")", "BIO_printf", "(", "bio_err", ",", "\"", "%s\\\"", ",", "ap", "->", "name", ")", ";", "}", "return", "0", ";", "}'" ]

[ "Set", "up", "the", "arg", "parsing" ]

[ "'char", "*", "opt_init", "(", "int", "ac", ",", "char", "*", "*", "av", ",", "const", "OPTIONS", "*", "o", ")", "{", "/*", "Store", "state.", "*/", "argc", "=", "ac", ";", "argv", "=", "av", ";", "opt_index", "=", "1", ";", "opts", "=", "o", ";", "opt_progname", "(", "av", "[", "0", "]", ")", ";", "unknown", "=", "NULL", ";", "for", "(", ";", "o", "->", "name", ";", "++", "o", ")", "{", "#", "ifndef", "NDEBUG", "const", "OPTIONS", "*", "next", ";", "int", "duplicated", ",", "<type", "ref=\"prev\"/>", "i", ";", "#", "endif", "if", "(", "o", "->", "name", "==", "OPT_HELP_STR", "||", "o", "->", "name", "==", "OPT_MORE_STR", ")", "continue;", "#", "ifndef", "NDEBUG", "i", "=", "o", "->", "valtype", ";", "/*", "Make", "sure", "options", "are", "legit.", "*/", "assert", "(", "o", "->", "name", "[", "0", "]", "!=", "\\'-\\'", ")", ";", "assert", "(", "o", "->", "retval", ">", "0", ")", ";", "switch", "(", "i", ")", "{", "case", "0", ":", "case", "\\'-\\'", ":", "case", "\\'/\\'", ":", "case", "\\'<\\'", ":", "case", "\\'>\\'", ":", "case", "\\'E\\'", ":", "case", "\\'F\\'", ":", "case", "\\'M\\'", ":", "case", "\\'U\\'", ":", "case", "\\'f\\'", ":", "case", "\\'l\\'", ":", "case", "\\'n\\'", ":", "case", "\\'p\\'", ":", "case", "\\'s\\'", ":", "case", "\\'u\\'", ":", "case", "\\'c\\'", ":", "break;", "default:", "assert", "(", "0", ")", ";", "}", "/*", "Make", "sure", "there", "are", "no", "duplicates.", "*/", "for", "(", "next", "=", "o", "+", "1", ";", "next", "->", "name", ";", "++", "next", ")", "{", "/*", "*", "Some", "compilers", "inline", "strcmp", "and", "the", "assert", "string", "is", "too", "long.", "*/", "duplicated", "=", "strcmp", "(", "o", "->", "name", ",", "next", "->", "name", ")", "==", "0", ";", "assert", "(", "!", "duplicated", ")", ";", "}", "#", "endif", "if", "(", "o", "->", "name", "[", "0", "]", "==", "\\'\\\\0\\'", ")", "{", "assert", "(", "unknown", "==", "NULL", ")", ";", "unknown", "=", "o", ";", "assert", "(", "unknown", "->", "valtype", "==", "0", "||", "unknown", "->", "valtype", "==", "\\'-\\'", ")", ";", "}", "}", "return", "prog", ";", "}'" ]

[ "How", "many", "items", "in", "remaining", "args?" ]

[ "'int", "opt_num_rest", "(", "void", ")", "{", "int", "i", "=", "0", ";", "char", "*", "*", "pp", ";", "for", "(", "pp", "=", "opt_rest", "()", ";", "*", "pp", ";", "pp", "++", ",", "i", "++", ")", "continue;", "return", "i", ";", "}'" ]

[ "Parse", "a", "cipher", "name,", "put", "it", "in", "EVP_CIPHER;", "return", "0", "on", "failure,", "else", "1" ]

[ "'int", "opt_cipher", "(", "const", "char", "*", "name", ",", "const", "EVP_CIPHER", "*", "*", "cipherp", ")", "{", "*", "cipherp", "=", "EVP_get_cipherbyname", "(", "name", ")", ";", "if", "(", "*", "cipherp", ")", "return", "1", ";", "BIO_printf", "(", "bio_err", ",", "\"%s:", "Unknown", "cipher", "%s\\\"", ",", "prog", ",", "name", ")", ";", "return", "0", ";", "}'" ]

[ "Parse", "an", "int,", "put", "it", "into", "result;", "return", "0", "on", "failure,", "else", "1" ]

[ "'int", "opt_int", "(", "const", "char", "*", "value", ",", "int", "*", "result", ")", "{", "long", "l", ";", "if", "(", "!", "opt_long", "(", "value", ",", "&", "l", ")", ")", "return", "0", ";", "*", "result", "=", "(", "int", ")", "l", ";", "if", "(", "*", "result", "!=", "l", ")", "{", "BIO_printf", "(", "bio_err", ",", "\"%s:", "Value", "\\\\\"%s\\\\\"", "outside", "integer", "range\\\"", ",", "prog", ",", "value", ")", ";", "return", "0", ";", "}", "return", "1", ";", "}'" ]

[ "Perform", "get_thread_are", "call", "along", "with", "printing", "the", "expected", "output", "and", "checking", "the", "result", "against", "the", "argument", "of", "the", "previous", "set_thread_area", "call,", "if", "it", "had", "place" ]

[ "'static", "void", "get_thread_area", "(", "kernel_ulong_t", "ptr_val", ",", "const", "char", "*", "ptr_str", ",", "bool", "valid", ",", "long", "set_rc", ",", "kernel_ulong_t", "expected", ")", "{", "struct", "user_desc", "*", "ptr", "=", "(", "struct", "user_desc", "*", ")", "(", "uintptr_t", ")", "ptr_val", ";", "struct", "user_desc", "*", "expected_ptr", "=", "(", "struct", "user_desc", "*", ")", "(", "uintptr_t", ")", "expected", ";", "int", "saved_errno", ";", "long", "rc", ";", "rc", "=", "syscall", "(", "__NR_get_thread_area", ",", "ptr_val", ")", ";", "saved_errno", "=", "errno", ";", "printf", "(", "\"get_thread_area(\"", ")", ";", "if", "(", "valid", "&&", "!", "rc", ")", "{", "if", "(", "!", "set_rc", ")", "{", "assert", "(", "ptr", "->", "entry_number", "==", "expected_ptr", "->", "entry_number", ")", ";", "assert", "(", "ptr", "->", "base_addr", "==", "expected_ptr", "->", "base_addr", ")", ";", "assert", "(", "ptr", "->", "limit", "==", "expected_ptr", "->", "limit", ")", ";", "assert", "(", "ptr", "->", "seg_32bit", "==", "expected_ptr", "->", "seg_32bit", ")", ";", "assert", "(", "ptr", "->", "contents", "==", "expected_ptr", "->", "contents", ")", ";", "assert", "(", "ptr", "->", "read_exec_only", "==", "expected_ptr", "->", "read_exec_only", ")", ";", "assert", "(", "ptr", "->", "limit_in_pages", "==", "expected_ptr", "->", "limit_in_pages", ")", ";", "assert", "(", "ptr", "->", "seg_not_present", "==", "expected_ptr", "->", "seg_not_present", ")", ";", "assert", "(", "ptr", "->", "useable", "==", "expected_ptr", "->", "useable", ")", ";", "/*", "*", "We", "do", "not", "check", "lm", "as", "32-bit", "processes", "ignore", "it,", "and", "*", "only", "32-bit", "processes", "can", "successfully", "execute", "*", "get_thread_area.", "*/", "}", "print_user_desc", "(", "ptr", ",", "(", "int", ")", "ptr", "->", "entry_number", "==", "-", "1", "?", "\"-1\"", ":", "NULL", ")", ";", "}", "else", "{", "printptr", "(", "ptr_val", ",", "ptr_str", ")", ";", "}", "errno", "=", "saved_errno", ";", "printf", "(", "\")", "=", "%s\\\"", ",", "sprintrc", "(", "rc", ")", ")", ";", "}'" ]

[ "Perform", "set_thread_area", "call", "along", "with", "printing", "the", "expected", "output" ]

[ "'static", "long", "set_thread_area", "(", "kernel_ulong_t", "ptr_val", ",", "const", "char", "*", "ptr_str", ",", "bool", "valid", ",", "const", "char", "*", "entry_number_str", ")", "{", "struct", "user_desc", "*", "ptr", "=", "(", "struct", "user_desc", "*", ")", "(", "uintptr_t", ")", "ptr_val", ";", "long", "rc", "=", "-", "1", ";", "int", "saved_errno", ";", "rc", "=", "syscall", "(", "__NR_set_thread_area", ",", "ptr_val", ")", ";", "saved_errno", "=", "errno", ";", "printf", "(", "\"set_thread_area(\"", ")", ";", "if", "(", "valid", ")", "print_user_desc", "(", "ptr", ",", "entry_number_str", ")", ";", "else", "printptr", "(", "ptr_val", ",", "ptr_str", ")", ";", "errno", "=", "saved_errno", ";", "printf", "(", "\")", "=", "%s\"", ",", "sprintrc", "(", "rc", ")", ")", ";", "if", "(", "!", "rc", ")", "printf", "(", "\"", "(entry_number=%u)\"", ",", "ptr", "->", "entry_number", ")", ";", "puts", "(", "\"\"", ")", ";", "return", "rc", ";", "}'" ]

[ "SRP", "test", "vectors", "from", "RFC5054" ]

[ "'static", "int", "run_srp_kat", "(", "void", ")", "{", "int", "ret", "=", "0", ";", "BIGNUM", "*", "s", "=", "NULL", ";", "BIGNUM", "*", "v", "=", "NULL", ";", "BIGNUM", "*", "a", "=", "NULL", ";", "BIGNUM", "*", "b", "=", "NULL", ";", "BIGNUM", "*", "u", "=", "NULL", ";", "BIGNUM", "*", "x", "=", "NULL", ";", "BIGNUM", "*", "Apub", "=", "NULL", ";", "BIGNUM", "*", "Bpub", "=", "NULL", ";", "BIGNUM", "*", "Kclient", "=", "NULL", ";", "BIGNUM", "*", "Kserver", "=", "NULL", ";", "/*", "use", "builtin", "1024-bit", "params", "*/", "const", "SRP_gN", "*", "GN", ";", "if", "(", "!", "TEST_ptr", "(", "GN", "=", "SRP_get_default_gN", "(", "\"1024\"", ")", ")", ")", "goto", "err", ";", "BN_hex2bn", "(", "&", "s", ",", "\"BEB25379D1A8581EB5A727673A2441EE\"", ")", ";", "/*", "Set", "up", "server\\'s", "password", "entry", "*/", "if", "(", "!", "TEST_true", "(", "SRP_create_verifier_BN", "(", "\"alice\"", ",", "\"password123\"", ",", "&", "s", ",", "&", "v", ",", "GN", "->", "N", ",", "GN", "->", "g", ")", ")", ")", "goto", "err", ";", "TEST_info", "(", "\"checking", "v\"", ")", ";", "if", "(", "!", "TEST_true", "(", "check_bn", "(", "\"v\"", ",", "v", ",", "\"7E273DE8696FFC4F4E337D05B4B375BEB0DDE1569E8FA00A9886D812\"", "\"9BADA1F1822223CA1A605B530E379BA4729FDC59F105B4787E5186F5\"", "\"C671085A1447B52A48CF1970B4FB6F8400BBF4CEBFBB168152E08AB5\"", "\"EA53D15C1AFF87B2B9DA6E04E058AD51CC72BFC9033B564E26480D78\"", "\"E955A5E29E7AB245DB2BE315E2099AFB\"", ")", ")", ")", "goto", "err", ";", "TEST_note", "(", "\"", "okay\"", ")", ";", "/*", "Server", "random", "*/", "BN_hex2bn", "(", "&", "b", ",", "\"E487CB59D31AC550471E81F00F6928E01DDA08E974A004F49E61F5D1\"", "\"05284D20\"", ")", ";", "/*", "Server\\'s", "first", "message", "*/", "Bpub", "=", "SRP_Calc_B", "(", "b", ",", "GN", "->", "N", ",", "GN", "->", "g", ",", "v", ")", ";", "if", "(", "!", "TEST_true", "(", "SRP_Verify_B_mod_N", "(", "Bpub", ",", "GN", "->", "N", ")", ")", ")", "goto", "err", ";", "TEST_info", "(", "\"checking", "B\"", ")", ";", "if", "(", "!", "TEST_true", "(", "check_bn", "(", "\"B\"", ",", "Bpub", ",", "\"BD0C61512C692C0CB6D041FA01BB152D4916A1E77AF46AE105393011\"", "\"BAF38964DC46A0670DD125B95A981652236F99D9B681CBF87837EC99\"", "\"6C6DA04453728610D0C6DDB58B318885D7D82C7F8DEB75CE7BD4FBAA\"", "\"37089E6F9C6059F388838E7A00030B331EB76840910440B1B27AAEAE\"", "\"EB4012B7D7665238A8E3FB004B117B58\"", ")", ")", ")", "goto", "err", ";", "TEST_note", "(", "\"", "okay\"", ")", ";", "/*", "Client", "random", "*/", "BN_hex2bn", "(", "&", "a", ",", "\"60975527035CF2AD1989806F0407210BC81EDC04E2762A56AFD529DD\"", "\"DA2D4393\"", ")", ";", "/*", "Client\\'s", "response", "*/", "Apub", "=", "SRP_Calc_A", "(", "a", ",", "GN", "->", "N", ",", "GN", "->", "g", ")", ";", "if", "(", "!", "TEST_true", "(", "SRP_Verify_A_mod_N", "(", "Apub", ",", "GN", "->", "N", ")", ")", ")", "goto", "err", ";", "TEST_info", "(", "\"checking", "A\"", ")", ";", "if", "(", "!", "TEST_true", "(", "check_bn", "(", "\"A\"", ",", "Apub", ",", "\"61D5E490F6F1B79547B0704C436F523DD0E560F0C64115BB72557EC4\"", "\"4352E8903211C04692272D8B2D1A5358A2CF1B6E0BFCF99F921530EC\"", "\"8E39356179EAE45E42BA92AEACED825171E1E8B9AF6D9C03E1327F44\"", "\"BE087EF06530E69F66615261EEF54073CA11CF5858F0EDFDFE15EFEA\"", "\"B349EF5D76988A3672FAC47B0769447B\"", ")", ")", ")", "goto", "err", ";", "TEST_note", "(", "\"", "okay\"", ")", ";", "/*", "Both", "sides", "calculate", "u", "*/", "u", "=", "SRP_Calc_u", "(", "Apub", ",", "Bpub", ",", "GN", "->", "N", ")", ";", "if", "(", "!", "TEST_true", "(", "check_bn", "(", "\"u\"", ",", "u", ",", "\"CE38B9593487DA98554ED47D70A7AE5F462EF019\"", ")", ")", ")", "goto", "err", ";", "/*", "Client\\'s", "key", "*/", "x", "=", "SRP_Calc_x", "(", "s", ",", "\"alice\"", ",", "\"password123\"", ")", ";", "Kclient", "=", "SRP_Calc_client_key", "(", "GN", "->", "N", ",", "Bpub", ",", "GN", "->", "g", ",", "x", ",", "a", ",", "u", ")", ";", "TEST_info", "(", "\"checking", "client\\'s", "key\"", ")", ";", "if", "(", "!", "TEST_true", "(", "check_bn", "(", "\"Client\\'s", "key\"", ",", "Kclient", ",", "\"B0DC82BABCF30674AE450C0287745E7990A3381F63B387AAF271A10D\"", "\"233861E359B48220F7C4693C9AE12B0A6F67809F0876E2D013800D6C\"", "\"41BB59B6D5979B5C00A172B4A2A5903A0BDCAF8A709585EB2AFAFA8F\"", "\"3499B200210DCC1F10EB33943CD67FC88A2F39A4BE5BEC4EC0A3212D\"", "\"C346D7E474B29EDE8A469FFECA686E5A\"", ")", ")", ")", "goto", "err", ";", "TEST_note", "(", "\"", "okay\"", ")", ";", "/*", "Server\\'s", "key", "*/", "Kserver", "=", "SRP_Calc_server_key", "(", "Apub", ",", "v", ",", "u", ",", "b", ",", "GN", "->", "N", ")", ";", "TEST_info", "(", "\"checking", "server\\'s", "key\"", ")", ";", "if", "(", "!", "TEST_true", "(", "check_bn", "(", "\"Server\\'s", "key\"", ",", "Kserver", ",", "\"B0DC82BABCF30674AE450C0287745E7990A3381F63B387AAF271A10D\"", "\"233861E359B48220F7C4693C9AE12B0A6F67809F0876E2D013800D6C\"", "\"41BB59B6D5979B5C00A172B4A2A5903A0BDCAF8A709585EB2AFAFA8F\"", "\"3499B200210DCC1F10EB33943CD67FC88A2F39A4BE5BEC4EC0A3212D\"", "\"C346D7E474B29EDE8A469FFECA686E5A\"", ")", ")", ")", "goto", "err", ";", "TEST_note", "(", "\"", "okay\"", ")", ";", "ret", "=", "1", ";", "err", ":", "BN_clear_free", "(", "Kclient", ")", ";", "BN_clear_free", "(", "Kserver", ")", ";", "BN_clear_free", "(", "x", ")", ";", "BN_free", "(", "u", ")", ";", "BN_free", "(", "Apub", ")", ";", "BN_clear_free", "(", "a", ")", ";", "BN_free", "(", "Bpub", ")", ";", "BN_clear_free", "(", "b", ")", ";", "BN_free", "(", "s", ")", ";", "BN_clear_free", "(", "v", ")", ";", "return", "ret", ";", "}'" ]

[ "Return", "true", "iff", "the", "DIGEST_LEN", "bytes", "in", "digest", "are", "all", "zero" ]

[ "'int", "tor_digest_is_zero", "(", "const", "char", "*", "digest", ")", "{", "static", "const", "uint8_t", "ZERO_DIGEST", "[]", "=", "{", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", "}", ";", "return", "tor_memeq", "(", "digest", ",", "ZERO_DIGEST", ",", "DIGEST_LEN", ")", ";", "}'" ]

[ "As", "tor_parse_long(),", "but", "return", "an", "unsigned", "long" ]

[ "'unsigned", "long", "tor_parse_ulong", "(", "const", "char", "*", "s", ",", "int", "base", ",", "unsigned", "long", "min", ",", "unsigned", "long", "max", ",", "int", "*", "ok", ",", "char", "*", "*", "next", ")", "{", "char", "*", "endptr", ";", "unsigned", "long", "r", ";", "if", "(", "base", "<", "0", ")", "{", "if", "(", "ok", ")", "*", "ok", "=", "0", ";", "return", "0", ";", "}", "errno", "=", "0", ";", "r", "=", "strtoul", "(", "s", ",", "&", "endptr", ",", "base", ")", ";", "CHECK_STRTOX_RESULT", "()", ";", "}'" ]

[ "Return", "true", "iff", "the", "'len'", "bytes", "at", "'mem'", "are", "all", "zero" ]

[ "\"int", "tor_mem_is_zero", "(", "const", "char", "*", "mem", ",", "size_t", "len", ")", "{", "static", "const", "char", "ZERO", "[]", "=", "{", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "}", ";", "while", "(", "len", ">=", "sizeof", "(", "ZERO", ")", ")", "{", "/*", "It's", "safe", "to", "use", "fast_memcmp", "here,", "since", "the", "very", "worst", "thing", "an", "*", "attacker", "could", "learn", "is", "how", "many", "initial", "bytes", "of", "a", "secret", "were", "zero", "*/", "if", "(", "fast_memcmp", "(", "mem", ",", "ZERO", ",", "sizeof", "(", "ZERO", ")", ")", ")", "return", "0", ";", "len", "-=", "sizeof", "(", "ZERO", ")", ";", "mem", "+=", "sizeof", "(", "ZERO", ")", ";", "}", "/*", "Deal", "with", "leftover", "bytes.", "*/", "if", "(", "len", ")", "return", "fast_memeq", "(", "mem", ",", "ZERO", ",", "len", ")", ";", "return", "1", ";", "}\"" ]

[ "Return", "the", "number", "of", "bits", "set", "in", "<b>v<", "b>" ]

[ "'int", "n_bits_set_u8", "(", "uint8_t", "v", ")", "{", "static", "const", "int", "nybble_table", "[]", "=", "{", "0", ",", "/*", "0000", "*/", "1", ",", "/*", "0001", "*/", "1", ",", "/*", "0010", "*/", "2", ",", "/*", "0011", "*/", "1", ",", "/*", "0100", "*/", "2", ",", "/*", "0101", "*/", "2", ",", "/*", "0110", "*/", "3", ",", "/*", "0111", "*/", "1", ",", "/*", "1000", "*/", "2", ",", "/*", "1001", "*/", "2", ",", "/*", "1010", "*/", "3", ",", "/*", "1011", "*/", "2", ",", "/*", "1100", "*/", "3", ",", "/*", "1101", "*/", "3", ",", "/*", "1110", "*/", "4", ",", "/*", "1111", "*/", "}", ";", "return", "nybble_table", "[", "v", "&", "15", "]", "+", "nybble_table", "[", "v", ">>", "4", "]", ";", "}'" ]

[ "gzip", "a", "log", "file" ]

[ "'void", "OS_CompressLog", "(", "const", "char", "*", "logfile", ")", "{", "FILE", "*", "log", ";", "gzFile", "zlog", ";", "char", "logfileGZ", "[", "OS_FLSIZE", "+", "1", "]", ";", "int", "len", ",", "<type", "ref=\"prev\"/>", "err", ";", "char", "buf", "[", "OS_MAXSTR", "+", "1", "]", ";", "/*", "Do", "not", "compress", "*/", "if", "(", "mond", ".", "compress", "==", "0", ")", "{", "return", ";", "}", "/*", "Clear", "memory", "*/", "memset", "(", "logfileGZ", ",", "\\'\\\\0\\'", ",", "OS_FLSIZE", "+", "1", ")", ";", "memset", "(", "buf", ",", "\\'\\\\0\\'", ",", "OS_MAXSTR", "+", "1", ")", ";", "/*", "Set", "umask", "*/", "umask", "(", "0027", ")", ";", "/*", "Create", "the", "gzip", "file", "name", "*/", "snprintf", "(", "logfileGZ", ",", "OS_FLSIZE", ",", "\"%s.gz\"", ",", "logfile", ")", ";", "/*", "Read", "log", "file", "*/", "log", "=", "fopen", "(", "logfile", ",", "\"r\"", ")", ";", "if", "(", "!", "log", ")", "{", "/*", "Do", "not", "warn", "in", "here,", "since", "the", "alert", "file", "may", "not", "exist", "*/", "return", ";", "}", "/*", "Open", "compressed", "file", "*/", "zlog", "=", "gzopen", "(", "logfileGZ", ",", "\"w\"", ")", ";", "if", "(", "!", "zlog", ")", "{", "fclose", "(", "log", ")", ";", "merror", "(", "FOPEN_ERROR", ",", "ARGV0", ",", "logfileGZ", ",", "errno", ",", "strerror", "(", "errno", ")", ")", ";", "return", ";", "}", "for", "(", ";", ";", ")", "{", "len", "=", "(", "int", ")", "fread", "(", "buf", ",", "1", ",", "OS_MAXSTR", ",", "log", ")", ";", "if", "(", "len", "<=", "0", ")", "{", "break;", "}", "if", "(", "gzwrite", "(", "zlog", ",", "buf", ",", "(", "unsigned", ")", "len", ")", "!=", "len", ")", "{", "merror", "(", "\"%s:", "Compression", "error:", "%s\"", ",", "ARGV0", ",", "gzerror", "(", "zlog", ",", "&", "err", ")", ")", ";", "}", "}", "fclose", "(", "log", ")", ";", "gzclose", "(", "zlog", ")", ";", "/*", "Remove", "uncompressed", "file", "*/", "if", "(", "(", "unlink", "(", "logfile", ")", ")", "<", "0", ")", "{", "merror", "(", "\"%s:", "ERROR:", "Cannot", "unlink", "file", "%s:", "%s\"", ",", "ARGV0", ",", "logfile", ",", "strerror", "(", "errno", ")", ")", ";", "}", "return", ";", "}'" ]

[ "Helper", "used", "to", "add", "an", "encoded", "certs", "to", "a", "cert", "cell" ]

[ "'static", "void", "add_certs_cell_cert_helper", "(", "certs_cell_t", "*", "certs_cell", ",", "uint8_t", "cert_type", ",", "const", "uint8_t", "*", "cert_encoded", ",", "size_t", "cert_len", ")", "{", "tor_assert", "(", "cert_len", "<=", "UINT16_MAX", ")", ";", "certs_cell_cert_t", "*", "ccc", "=", "certs_cell_cert_new", "()", ";", "ccc", "->", "cert_type", "=", "cert_type", ";", "ccc", "->", "cert_len", "=", "cert_len", ";", "certs_cell_cert_setlen_body", "(", "ccc", ",", "cert_len", ")", ";", "memcpy", "(", "certs_cell_cert_getarray_body", "(", "ccc", ")", ",", "cert_encoded", ",", "cert_len", ")", ";", "certs_cell_add_certs", "(", "certs_cell", ",", "ccc", ")", ";", "}'" ]

[ "Free", "all", "storage", "held", "by", "<b>state<", "b>" ]

[ "'void", "or_handshake_state_free", "(", "or_handshake_state_t", "*", "state", ")", "{", "if", "(", "!", "state", ")", "return", ";", "crypto_digest_free", "(", "state", "->", "digest_sent", ")", ";", "crypto_digest_free", "(", "state", "->", "digest_received", ")", ";", "or_handshake_certs_free", "(", "state", "->", "certs", ")", ";", "tor_cert_free", "(", "state", "->", "own_link_cert", ")", ";", "memwipe", "(", "state", ",", "0xBE", ",", "sizeof", "(", "or_handshake_state_t", ")", ")", ";", "tor_free", "(", "state", ")", ";", "}'" ]

[ "Block", "all", "future", "attempts", "to", "renegotiate", "on", "'conn'" ]

[ "'void", "connection_or_block_renegotiation", "(", "or_connection_t", "*", "conn", ")", "{", "tor_tls_t", "*", "tls", "=", "conn", "->", "tls", ";", "if", "(", "!", "tls", ")", "return", ";", "tor_tls_set_renegotiate_callback", "(", "tls", ",", "NULL", ",", "NULL", ")", ";", "tor_tls_block_renegotiation", "(", "tls", ")", ";", "}'" ]

[ "Deallocate", "the", "global", "Extended", "ORPort", "identifier", "list" ]

[ "'void", "connection_or_clear_ext_or_id_map", "(", "void", ")", "{", "digestmap_free", "(", "orconn_ext_or_id_map", ",", "NULL", ")", ";", "orconn_ext_or_id_map", "=", "NULL", ";", "}'" ]

[ "We've", "received", "an", "EOF", "from", "<b>conn<", "b>" ]

[ "'int", "connection_or_reached_eof", "(", "or_connection_t", "*", "conn", ")", "{", "tor_assert", "(", "conn", ")", ";", "log_info", "(", "LD_OR", ",", "\"OR", "connection", "reached", "EOF.", "Closing.\"", ")", ";", "connection_or_close_normally", "(", "conn", ",", "1", ")", ";", "return", "0", ";", "}'" ]

[ "Clear", "all", "identities", "in", "OR", "conns" ]

[ "'void", "connection_or_clear_identity_map", "(", "void", ")", "{", "smartlist_t", "*", "conns", "=", "get_connection_array", "()", ";", "SMARTLIST_FOREACH", "(", "conns", ",", "connection_t", "*", ",", "conn", ",", "{", "if", "(conn->type", "==", "CONN_TYPE_OR)", "{", "connection_or_clear_identity(TO_OR_CONN(conn));", "}", "}", ")", ";", "}'" ]

[ "Simple", "producev()", "and", "produceva()", "verification" ]

[ "'static", "void", "do_test_srkt_leak", "(", "void", ")", "{", "rd_kafka_conf_t", "*", "conf", ";", "char", "buf", "[", "2000", "]", ";", "rd_kafka_t", "*", "rk", ";", "rd_kafka_resp_err_t", "err", ";", "rd_kafka_error_t", "*", "error", ";", "rd_kafka_vu_t", "vus", "[", "3", "]", ";", "conf", "=", "rd_kafka_conf_new", "()", ";", "test_conf_set", "(", "conf", ",", "\"message.max.bytes\"", ",", "\"1000\"", ")", ";", "rk", "=", "test_create_handle", "(", "RD_KAFKA_PRODUCER", ",", "conf", ")", ";", "err", "=", "rd_kafka_producev", "(", "rk", ",", "RD_KAFKA_V_TOPIC", "(", "\"test\"", ")", ",", "RD_KAFKA_V_VALUE", "(", "buf", ",", "sizeof", "(", "buf", ")", ")", ",", "RD_KAFKA_V_END", ")", ";", "TEST_ASSERT", "(", "err", "==", "RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE", ",", "\"expected", "MSG_SIZE_TOO_LARGE,", "not", "%s\"", ",", "rd_kafka_err2str", "(", "err", ")", ")", ";", "vus", "[", "0", "]", ".", "vtype", "=", "RD_KAFKA_VTYPE_TOPIC", ";", "vus", "[", "0", "]", ".", "u", ".", "cstr", "=", "\"test\"", ";", "vus", "[", "1", "]", ".", "vtype", "=", "RD_KAFKA_VTYPE_VALUE", ";", "vus", "[", "1", "]", ".", "u", ".", "mem", ".", "ptr", "=", "buf", ";", "vus", "[", "1", "]", ".", "u", ".", "mem", ".", "size", "=", "sizeof", "(", "buf", ")", ";", "vus", "[", "2", "]", ".", "vtype", "=", "RD_KAFKA_VTYPE_HEADER", ";", "vus", "[", "2", "]", ".", "u", ".", "header", ".", "name", "=", "\"testheader\"", ";", "vus", "[", "2", "]", ".", "u", ".", "header", ".", "val", "=", "\"test", "value\"", ";", "vus", "[", "2", "]", ".", "u", ".", "header", ".", "size", "=", "-", "1", ";", "error", "=", "rd_kafka_produceva", "(", "rk", ",", "vus", ",", "3", ")", ";", "TEST_ASSERT", "(", "error", ",", "\"expected", "failure\"", ")", ";", "TEST_ASSERT", "(", "rd_kafka_error_code", "(", "error", ")", "==", "RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE", ",", "\"expected", "MSG_SIZE_TOO_LARGE,", "not", "%s\"", ",", "rd_kafka_error_string", "(", "error", ")", ")", ";", "TEST_SAY", "(", "\"produceva()", "error", "(expected):", "%s\\\"", ",", "rd_kafka_error_string", "(", "error", ")", ")", ";", "rd_kafka_error_destroy", "(", "error", ")", ";", "rd_kafka_destroy", "(", "rk", ")", ";", "}'" ]

[ "Expected", "key", "and", "signature", "types" ]

[ "'__owur", "static", "int", "parse_expected_key_type", "(", "int", "*", "ptype", ",", "const", "char", "*", "value", ")", "{", "int", "nid", ";", "const", "EVP_PKEY_ASN1_METHOD", "*", "ameth", ";", "if", "(", "value", "==", "NULL", ")", "return", "0", ";", "ameth", "=", "EVP_PKEY_asn1_find_str", "(", "NULL", ",", "value", ",", "-", "1", ")", ";", "if", "(", "ameth", "!=", "NULL", ")", "EVP_PKEY_asn1_get0_info", "(", "&", "nid", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ",", "ameth", ")", ";", "else", "nid", "=", "OBJ_sn2nid", "(", "value", ")", ";", "if", "(", "nid", "==", "NID_undef", ")", "nid", "=", "OBJ_ln2nid", "(", "value", ")", ";", "#", "ifndef", "OPENSSL_NO_EC", "if", "(", "nid", "==", "NID_undef", ")", "nid", "=", "EC_curve_nist2nid", "(", "value", ")", ";", "#", "endif", "if", "(", "nid", "==", "NID_undef", ")", "return", "0", ";", "*", "ptype", "=", "nid", ";", "return", "1", ";", "}'" ]

[ "refer", "to", "ThumbExpandImm", "in", "the", "manual" ]

[ "'static", "uint32_t", "__thumb_expand_imm", "(", "uint32_t", "i", ",", "uint32_t", "imm3", ",", "uint32_t", "imm8", ")", "{", "uint32_t", "imm12", "=", "(", "i", "<<", "11", ")", "|", "(", "imm3", "<<", "8", ")", "|", "imm8", ";", "uint32_t", "m", ";", "switch", "(", "__bits", "(", "imm12", ",", "11", ",", "8", ")", ")", "{", "case", "0", ":", "return", "(", "imm8", ")", ";", "case", "1", ":", "return", "(", "imm8", "<<", "16", ")", "|", "(", "imm8", ")", ";", "case", "2", ":", "return", "(", "imm8", "<<", "24", ")", "|", "(", "imm8", "<<", "8", ")", ";", "case", "3", ":", "return", "(", "imm8", "<<", "24", ")", "|", "(", "imm8", "<<", "16", ")", "|", "(", "imm8", "<<", "8", ")", "|", "(", "imm8", ")", ";", "default:", "m", "=", "__bits", "(", "imm12", ",", "11", ",", "7", ")", ";", "return", "(", "imm8", "<<", "(", "32", "-", "m", ")", ")", "|", "(", "imm8", ">>", "m", ")", ";", "}", "}'" ]

[ "FUNCTION", "bfd_get_full_section_contents", "SYNOPSIS", "bfd_boolean", "bfd_get_full_section_contents", "(bfd", "abfd,", "asection", "section,", "bfd_byte", "ptr);", "DESCRIPTION", "Read", "all", "data", "from" ]

[ "'bfd_boolean", "bfd_get_full_section_contents", "(", "bfd", "*", "abfd", ",", "sec_ptr", "sec", ",", "bfd_byte", "*", "*", "ptr", ")", "{", "bfd_size_type", "sz", ";", "bfd_byte", "*", "p", "=", "*", "ptr", ";", "bfd_boolean", "ret", ";", "bfd_size_type", "save_size", ";", "bfd_size_type", "save_rawsize", ";", "bfd_byte", "*", "compressed_buffer", ";", "unsigned", "int", "compression_header_size", ";", "if", "(", "abfd", "->", "direction", "!=", "write_direction", "&&", "sec", "->", "rawsize", "!=", "0", ")", "sz", "=", "sec", "->", "rawsize", ";", "else", "sz", "=", "sec", "->", "size", ";", "if", "(", "sz", "==", "0", ")", "{", "*", "ptr", "=", "NULL", ";", "return", "TRUE", ";", "}", "switch", "(", "sec", "->", "compress_status", ")", "{", "case", "COMPRESS_SECTION_NONE", ":", "if", "(", "p", "==", "NULL", ")", "{", "p", "=", "(", "bfd_byte", "*", ")", "bfd_malloc", "(", "sz", ")", ";", "if", "(", "p", "==", "NULL", ")", "{", "/*", "PR", "20801:", "Provide", "a", "more", "helpful", "error", "message.", "*/", "if", "(", "bfd_get_error", "()", "==", "bfd_error_no_memory", ")", "_bfd_error_handler", "/*", "xgettext:c-format", "*/", "(", "_", "(", "\"error:", "%pB(%pA)", "is", "too", "large", "(%#\"", "PRIx64", "\"", "bytes)\"", ")", ",", "abfd", ",", "sec", ",", "(", "uint64_t", ")", "sz", ")", ";", "return", "FALSE", ";", "}", "}", "if", "(", "!", "bfd_get_section_contents", "(", "abfd", ",", "sec", ",", "p", ",", "0", ",", "sz", ")", ")", "{", "if", "(", "*", "ptr", "!=", "p", ")", "free", "(", "p", ")", ";", "return", "FALSE", ";", "}", "*", "ptr", "=", "p", ";", "return", "TRUE", ";", "case", "DECOMPRESS_SECTION_SIZED", ":", "/*", "Read", "in", "the", "full", "compressed", "section", "contents.", "*/", "compressed_buffer", "=", "(", "bfd_byte", "*", ")", "bfd_malloc", "(", "sec", "->", "compressed_size", ")", ";", "if", "(", "compressed_buffer", "==", "NULL", ")", "return", "FALSE", ";", "save_rawsize", "=", "sec", "->", "rawsize", ";", "save_size", "=", "sec", "->", "size", ";", "/*", "Clear", "rawsize,", "set", "size", "to", "compressed", "size", "and", "set", "compress_status", "to", "COMPRESS_SECTION_NONE.", "If", "the", "compressed", "size", "is", "bigger", "than", "the", "uncompressed", "size,", "bfd_get_section_contents", "will", "fail.", "*/", "sec", "->", "rawsize", "=", "0", ";", "sec", "->", "size", "=", "sec", "->", "compressed_size", ";", "sec", "->", "compress_status", "=", "COMPRESS_SECTION_NONE", ";", "ret", "=", "bfd_get_section_contents", "(", "abfd", ",", "sec", ",", "compressed_buffer", ",", "0", ",", "sec", "->", "compressed_size", ")", ";", "/*", "Restore", "rawsize", "and", "size.", "*/", "sec", "->", "rawsize", "=", "save_rawsize", ";", "sec", "->", "size", "=", "save_size", ";", "sec", "->", "compress_status", "=", "DECOMPRESS_SECTION_SIZED", ";", "if", "(", "!", "ret", ")", "goto", "fail_compressed", ";", "if", "(", "p", "==", "NULL", ")", "p", "=", "(", "bfd_byte", "*", ")", "bfd_malloc", "(", "sz", ")", ";", "if", "(", "p", "==", "NULL", ")", "goto", "fail_compressed", ";", "compression_header_size", "=", "bfd_get_compression_header_size", "(", "abfd", ",", "sec", ")", ";", "if", "(", "compression_header_size", "==", "0", ")", "/*", "Set", "header", "size", "to", "the", "zlib", "header", "size", "if", "it", "is", "a", "SHF_COMPRESSED", "section.", "*/", "compression_header_size", "=", "12", ";", "if", "(", "!", "decompress_contents", "(", "compressed_buffer", "+", "compression_header_size", ",", "sec", "->", "compressed_size", "-", "compression_header_size", ",", "p", ",", "sz", ")", ")", "{", "bfd_set_error", "(", "bfd_error_bad_value", ")", ";", "if", "(", "p", "!=", "*", "ptr", ")", "free", "(", "p", ")", ";", "fail_compressed", ":", "free", "(", "compressed_buffer", ")", ";", "return", "FALSE", ";", "}", "free", "(", "compressed_buffer", ")", ";", "*", "ptr", "=", "p", ";", "return", "TRUE", ";", "case", "COMPRESS_SECTION_DONE", ":", "if", "(", "sec", "->", "contents", "==", "NULL", ")", "return", "FALSE", ";", "if", "(", "p", "==", "NULL", ")", "{", "p", "=", "(", "bfd_byte", "*", ")", "bfd_malloc", "(", "sz", ")", ";", "if", "(", "p", "==", "NULL", ")", "return", "FALSE", ";", "*", "ptr", "=", "p", ";", "}", "/*", "PR", "17512;", "file:", "5bc29788.", "*/", "if", "(", "p", "!=", "sec", "->", "contents", ")", "memcpy", "(", "p", ",", "sec", "->", "contents", ",", "sz", ")", ";", "return", "TRUE", ";", "default:", "abort", "()", ";", "}", "}'" ]

[ "Compress", "data", "of", "the", "size", "specified", "in" ]

[ "'static", "bfd_size_type", "bfd_compress_section_contents", "(", "bfd", "*", "abfd", ",", "sec_ptr", "sec", ",", "bfd_byte", "*", "uncompressed_buffer", ",", "bfd_size_type", "uncompressed_size", ")", "{", "uLong", "compressed_size", ";", "bfd_byte", "*", "buffer", ";", "bfd_size_type", "buffer_size", ";", "bfd_boolean", "decompress", ";", "int", "zlib_size", "=", "0", ";", "int", "orig_compression_header_size", ";", "bfd_size_type", "orig_uncompressed_size", ";", "int", "header_size", "=", "bfd_get_compression_header_size", "(", "abfd", ",", "NULL", ")", ";", "bfd_boolean", "compressed", "=", "bfd_is_section_compressed_with_header", "(", "abfd", ",", "sec", ",", "&", "orig_compression_header_size", ",", "&", "orig_uncompressed_size", ")", ";", "/*", "Either", "ELF", "compression", "header", "or", "the", "12-byte,", "\"ZLIB\"", "+", "8-byte", "size,", "overhead", "in", ".zdebug*", "section.", "*/", "if", "(", "!", "header_size", ")", "header_size", "=", "12", ";", "if", "(", "compressed", ")", "{", "/*", "We", "shouldn\\'t", "decompress", "unsupported", "compressed", "section.", "*/", "if", "(", "orig_compression_header_size", "<", "0", ")", "abort", "()", ";", "/*", "Different", "compression", "schemes.", "Just", "move", "the", "compressed", "section", "contents", "to", "the", "right", "position.", "*/", "if", "(", "orig_compression_header_size", "==", "0", ")", "{", "/*", "Convert", "it", "from", ".zdebug*", "section.", "Get", "the", "uncompressed", "size", "first.", "We", "need", "to", "subtract", "the", "12-byte", "overhead", "in", ".zdebug*", "section.", "Set", "orig_compression_header_size", "to", "the", "12-bye", "overhead.", "*/", "orig_compression_header_size", "=", "12", ";", "zlib_size", "=", "uncompressed_size", "-", "12", ";", "}", "else", "{", "/*", "Convert", "it", "to", ".zdebug*", "section.", "*/", "zlib_size", "=", "uncompressed_size", "-", "orig_compression_header_size", ";", "}", "/*", "Add", "the", "header", "size.", "*/", "compressed_size", "=", "zlib_size", "+", "header_size", ";", "}", "else", "compressed_size", "=", "compressBound", "(", "uncompressed_size", ")", "+", "header_size", ";", "/*", "Uncompress", "if", "it", "leads", "to", "smaller", "size.", "*/", "if", "(", "compressed", "&&", "compressed_size", ">", "orig_uncompressed_size", ")", "{", "decompress", "=", "TRUE", ";", "buffer_size", "=", "orig_uncompressed_size", ";", "}", "else", "{", "decompress", "=", "FALSE", ";", "buffer_size", "=", "compressed_size", ";", "}", "buffer", "=", "(", "bfd_byte", "*", ")", "bfd_alloc", "(", "abfd", ",", "buffer_size", ")", ";", "if", "(", "buffer", "==", "NULL", ")", "return", "0", ";", "if", "(", "compressed", ")", "{", "sec", "->", "size", "=", "orig_uncompressed_size", ";", "if", "(", "decompress", ")", "{", "if", "(", "!", "decompress_contents", "(", "uncompressed_buffer", "+", "orig_compression_header_size", ",", "zlib_size", ",", "buffer", ",", "buffer_size", ")", ")", "{", "bfd_set_error", "(", "bfd_error_bad_value", ")", ";", "bfd_release", "(", "abfd", ",", "buffer", ")", ";", "return", "0", ";", "}", "free", "(", "uncompressed_buffer", ")", ";", "sec", "->", "contents", "=", "buffer", ";", "sec", "->", "compress_status", "=", "COMPRESS_SECTION_DONE", ";", "return", "orig_uncompressed_size", ";", "}", "else", "{", "bfd_update_compression_header", "(", "abfd", ",", "buffer", ",", "sec", ")", ";", "memmove", "(", "buffer", "+", "header_size", ",", "uncompressed_buffer", "+", "orig_compression_header_size", ",", "zlib_size", ")", ";", "}", "}", "else", "{", "if", "(", "compress", "(", "(", "Bytef", "*", ")", "buffer", "+", "header_size", ",", "&", "compressed_size", ",", "(", "const", "Bytef", "*", ")", "uncompressed_buffer", ",", "uncompressed_size", ")", "!=", "Z_OK", ")", "{", "bfd_release", "(", "abfd", ",", "buffer", ")", ";", "bfd_set_error", "(", "bfd_error_bad_value", ")", ";", "return", "0", ";", "}", "compressed_size", "+=", "header_size", ";", "/*", "PR", "binutils/18087:", "If", "compression", "didn\\'t", "make", "the", "section", "smaller,", "just", "keep", "it", "uncompressed.", "*/", "if", "(", "compressed_size", "<", "uncompressed_size", ")", "bfd_update_compression_header", "(", "abfd", ",", "buffer", ",", "sec", ")", ";", "else", "{", "/*", "NOTE:", "There", "is", "a", "small", "memory", "leak", "here", "since", "uncompressed_buffer", "is", "malloced", "and", "won\\'t", "be", "freed.", "*/", "bfd_release", "(", "abfd", ",", "buffer", ")", ";", "sec", "->", "contents", "=", "uncompressed_buffer", ";", "sec", "->", "compress_status", "=", "COMPRESS_SECTION_NONE", ";", "return", "uncompressed_size", ";", "}", "}", "free", "(", "uncompressed_buffer", ")", ";", "sec", "->", "contents", "=", "buffer", ";", "sec", "->", "size", "=", "compressed_size", ";", "sec", "->", "compress_status", "=", "COMPRESS_SECTION_DONE", ";", "return", "uncompressed_size", ";", "}'" ]

[ "FUNCTION", "bfd_is_section_compressed", "SYNOPSIS", "bfd_boolean", "bfd_is_section_compressed", "(bfd", "abfd,", "asection", "section);", "DESCRIPTION", "Return", "@code{TRUE}", "if" ]

[ "'bfd_boolean", "bfd_is_section_compressed", "(", "bfd", "*", "abfd", ",", "sec_ptr", "sec", ")", "{", "int", "compression_header_size", ";", "bfd_size_type", "uncompressed_size", ";", "return", "(", "bfd_is_section_compressed_with_header", "(", "abfd", ",", "sec", ",", "&", "compression_header_size", ",", "&", "uncompressed_size", ")", "&&", "compression_header_size", ">=", "0", "&&", "uncompressed_size", ">", "0", ")", ";", "}'" ]

[ "FUNCTION", "bfd_is_section_compressed_with_header", "SYNOPSIS", "bfd_boolean", "bfd_is_section_compressed_with_header", "(bfd", "abfd,", "asection", "section,", "int", "compression_header_size_p,", "bfd_size_type", "uncompressed_size_p);", "DESCRIPTION", "Return", "@code{TRUE}", "if" ]

[ "'bfd_boolean", "bfd_is_section_compressed_with_header", "(", "bfd", "*", "abfd", ",", "sec_ptr", "sec", ",", "int", "*", "compression_header_size_p", ",", "bfd_size_type", "*", "uncompressed_size_p", ")", "{", "bfd_byte", "header", "[", "MAX_COMPRESSION_HEADER_SIZE", "]", ";", "int", "compression_header_size", ";", "int", "header_size", ";", "unsigned", "int", "saved", "=", "sec", "->", "compress_status", ";", "bfd_boolean", "compressed", ";", "compression_header_size", "=", "bfd_get_compression_header_size", "(", "abfd", ",", "sec", ")", ";", "if", "(", "compression_header_size", ">", "MAX_COMPRESSION_HEADER_SIZE", ")", "abort", "()", ";", "header_size", "=", "compression_header_size", "?", "compression_header_size", ":", "12", ";", "/*", "Don\\'t", "decompress", "the", "section.", "*/", "sec", "->", "compress_status", "=", "COMPRESS_SECTION_NONE", ";", "/*", "Read", "the", "header.", "*/", "if", "(", "bfd_get_section_contents", "(", "abfd", ",", "sec", ",", "header", ",", "0", ",", "header_size", ")", ")", "{", "if", "(", "compression_header_size", "==", "0", ")", "/*", "In", "this", "case,", "it", "should", "be", "\"ZLIB\"", "followed", "by", "the", "uncompressed", "section", "size,", "8", "bytes", "in", "big-endian", "order.", "*/", "compressed", "=", "CONST_STRNEQ", "(", "(", "char", "*", ")", "header", ",", "\"ZLIB\"", ")", ";", "else", "compressed", "=", "TRUE", ";", "}", "else", "compressed", "=", "FALSE", ";", "*", "uncompressed_size_p", "=", "sec", "->", "size", ";", "if", "(", "compressed", ")", "{", "if", "(", "compression_header_size", "!=", "0", ")", "{", "if", "(", "!", "bfd_check_compression_header", "(", "abfd", ",", "header", ",", "sec", ",", "uncompressed_size_p", ")", ")", "compression_header_size", "=", "-", "1", ";", "}", "/*", "Check", "for", "the", "pathalogical", "case", "of", "a", "debug", "string", "section", "that", "contains", "the", "string", "ZLIB....", "as", "the", "first", "entry.", "We", "assume", "that", "no", "uncompressed", ".debug_str", "section", "would", "ever", "be", "big", "enough", "to", "have", "the", "first", "byte", "of", "its", "(big-endian)", "size", "be", "non-zero.", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "strcmp", "(", "sec", "->", "name", ",", "\".debug_str\"", ")", "==", "0", "&&", "ISPRINT", "(", "header", "[", "4", "]", ")", ")", "compressed", "=", "FALSE", ";", "else", "*", "uncompressed_size_p", "=", "bfd_getb64", "(", "header", "+", "4", ")", ";", "}", "/*", "Restore", "compress_status.", "*/", "sec", "->", "compress_status", "=", "saved", ";", "*", "compression_header_size_p", "=", "compression_header_size", ";", "return", "compressed", ";", "}'" ]

[ "This", "is", "the", "old", "name", "for", "cmd_Groups", "retained", "for", "backwards", "compatibility" ]

[ "'static", "int", "cmd_Curves", "(", "SSL_CONF_CTX", "*", "cctx", ",", "const", "char", "*", "value", ")", "{", "return", "cmd_Groups", "(", "cctx", ",", "value", ")", ";", "}'" ]

[ "Intern", "a", "string", "and", "return", "string", "object" ]

[ "\"GCstr", "*", "lj_str_new", "(", "lua_State", "*", "L", ",", "const", "char", "*", "str", ",", "size_t", "lenx", ")", "{", "global_State", "*", "g", ";", "GCstr", "*", "s", ";", "GCobj", "*", "o", ";", "MSize", "len", "=", "(", "MSize", ")", "lenx", ";", "MSize", "h", ";", "if", "(", "lenx", ">=", "LJ_MAX_STR", ")", "lj_err_msg", "(", "L", ",", "LJ_ERR_STROV", ")", ";", "g", "=", "G", "(", "L", ")", ";", "if", "(", "LJ_UNLIKELY", "(", "lenx", "==", "0", ")", ")", "{", "return", "&", "g", "->", "strempty", ";", "}", "h", "=", "LJ_STR_HASH", "(", "str", ",", "lenx", ")", ";", "/*", "Check", "if", "the", "string", "has", "already", "been", "interned.", "*/", "o", "=", "gcref", "(", "g", "->", "strhash", "[", "h", "&", "g", "->", "strmask", "]", ")", ";", "#", "ifndef", "LUAJIT_USE_VALGRIND", "if", "(", "LJ_LIKELY", "(", "(", "(", "(", "uintptr_t", ")", "str", "+", "len", "-", "1", ")", "&", "(", "LJ_PAGESIZE", "-", "1", ")", ")", "<=", "LJ_PAGESIZE", "-", "4", ")", ")", "{", "while", "(", "o", "!=", "NULL", ")", "{", "GCstr", "*", "sx", "=", "gco2str", "(", "o", ")", ";", "if", "(", "sx", "->", "len", "==", "len", "&&", "sx", "->", "hash", "==", "h", "&&", "str_fastcmp", "(", "str", ",", "strdata", "(", "sx", ")", ",", "len", ")", "==", "0", ")", "{", "/*", "Resurrect", "if", "dead.", "Can", "only", "happen", "with", "fixstring()", "(keywords).", "*/", "if", "(", "isdead", "(", "g", ",", "o", ")", ")", "flipwhite", "(", "o", ")", ";", "return", "sx", ";", "/*", "Return", "existing", "string.", "*/", "}", "o", "=", "gcnext", "(", "o", ")", ";", "}", "}", "else", "{", "/*", "Slow", "path:", "end", "of", "string", "is", "too", "close", "to", "a", "page", "boundary.", "*/", "#", "endif", "while", "(", "o", "!=", "NULL", ")", "{", "GCstr", "*", "sx", "=", "gco2str", "(", "o", ")", ";", "if", "(", "sx", "->", "len", "==", "len", "&&", "sx", "->", "hash", "==", "h", "&&", "memcmp", "(", "str", ",", "strdata", "(", "sx", ")", ",", "len", ")", "==", "0", ")", "{", "/*", "Resurrect", "if", "dead.", "Can", "only", "happen", "with", "fixstring()", "(keywords).", "*/", "if", "(", "isdead", "(", "g", ",", "o", ")", ")", "flipwhite", "(", "o", ")", ";", "return", "sx", ";", "/*", "Return", "existing", "string.", "*/", "}", "o", "=", "gcnext", "(", "o", ")", ";", "}", "#", "ifndef", "LUAJIT_USE_VALGRIND", "}", "#", "endif", "/*", "Nope,", "create", "a", "new", "string.", "*/", "s", "=", "lj_mem_newt", "(", "L", ",", "sizeof", "(", "GCstr", ")", "+", "len", "+", "1", ",", "GCstr", ")", ";", "newwhite", "(", "g", ",", "s", ")", ";", "s", "->", "gct", "=", "~", "LJ_TSTR", ";", "s", "->", "len", "=", "len", ";", "s", "->", "hash", "=", "h", ";", "s", "->", "reserved", "=", "0", ";", "memcpy", "(", "strdatawr", "(", "s", ")", ",", "str", ",", "len", ")", ";", "strdatawr", "(", "s", ")", "[", "len", "]", "=", "'\\\\0'", ";", "/*", "Zero-terminate", "string.", "*/", "/*", "Add", "it", "to", "string", "hash", "table.", "*/", "h", "&=", "g", "->", "strmask", ";", "s", "->", "nextgc", "=", "g", "->", "strhash", "[", "h", "]", ";", "/*", "NOBARRIER:", "The", "string", "table", "is", "a", "GC", "root.", "*/", "setgcref", "(", "g", "->", "strhash", "[", "h", "]", ",", "obj2gco", "(", "s", ")", ")", ";", "if", "(", "g", "->", "strnum", "++", ">", "g", "->", "strmask", ")", "/*", "Allow", "a", "100%", "load", "factor.", "*/", "lj_str_resize", "(", "L", ",", "(", "g", "->", "strmask", "<<", "1", ")", "+", "1", ")", ";", "/*", "Grow", "string", "table.", "*/", "return", "s", ";", "/*", "Return", "newly", "interned", "string.", "*/", "}\"" ]

[ "Main", "entry", "method", "of", "the", "response", "generation" ]

[ "'TS_RESP", "*", "TS_RESP_create_response", "(", "TS_RESP_CTX", "*", "ctx", ",", "BIO", "*", "req_bio", ")", "{", "ASN1_OBJECT", "*", "policy", ";", "TS_RESP", "*", "response", ";", "int", "result", "=", "0", ";", "ts_RESP_CTX_init", "(", "ctx", ")", ";", "if", "(", "(", "ctx", "->", "response", "=", "TS_RESP_new", "()", ")", "==", "NULL", ")", "{", "TSerr", "(", "TS_F_TS_RESP_CREATE_RESPONSE", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "goto", "end", ";", "}", "if", "(", "(", "ctx", "->", "request", "=", "d2i_TS_REQ_bio", "(", "req_bio", ",", "NULL", ")", ")", "==", "NULL", ")", "{", "TS_RESP_CTX_set_status_info", "(", "ctx", ",", "TS_STATUS_REJECTION", ",", "\"Bad", "request", "format", "or", "system", "error.\"", ")", ";", "TS_RESP_CTX_add_failure_info", "(", "ctx", ",", "TS_INFO_BAD_DATA_FORMAT", ")", ";", "goto", "end", ";", "}", "if", "(", "!", "TS_RESP_CTX_set_status_info", "(", "ctx", ",", "TS_STATUS_GRANTED", ",", "NULL", ")", ")", "goto", "end", ";", "if", "(", "!", "ts_RESP_check_request", "(", "ctx", ")", ")", "goto", "end", ";", "if", "(", "(", "policy", "=", "ts_RESP_get_policy", "(", "ctx", ")", ")", "==", "NULL", ")", "goto", "end", ";", "if", "(", "(", "ctx", "->", "tst_info", "=", "ts_RESP_create_tst_info", "(", "ctx", ",", "policy", ")", ")", "==", "NULL", ")", "goto", "end", ";", "if", "(", "!", "ts_RESP_process_extensions", "(", "ctx", ")", ")", "goto", "end", ";", "if", "(", "!", "ts_RESP_sign", "(", "ctx", ")", ")", "goto", "end", ";", "result", "=", "1", ";", "end", ":", "if", "(", "!", "result", ")", "{", "TSerr", "(", "TS_F_TS_RESP_CREATE_RESPONSE", ",", "TS_R_RESPONSE_SETUP_ERROR", ")", ";", "if", "(", "ctx", "->", "response", "!=", "NULL", ")", "{", "if", "(", "TS_RESP_CTX_set_status_info_cond", "(", "ctx", ",", "TS_STATUS_REJECTION", ",", "\"Error", "during", "response", "\"", "\"generation.\"", ")", "==", "0", ")", "{", "TS_RESP_free", "(", "ctx", "->", "response", ")", ";", "ctx", "->", "response", "=", "NULL", ";", "}", "}", "}", "response", "=", "ctx", "->", "response", ";", "ctx", "->", "response", "=", "NULL", ";", "/*", "Ownership", "will", "be", "returned", "to", "caller.", "*/", "ts_RESP_CTX_cleanup", "(", "ctx", ")", ";", "return", "response", ";", "}'" ]

[ "Default", "callback", "for", "response", "generation" ]

[ "'static", "ASN1_INTEGER", "*", "def_serial_cb", "(", "struct", "TS_resp_ctx", "*", "ctx", ",", "void", "*", "data", ")", "{", "ASN1_INTEGER", "*", "serial", "=", "ASN1_INTEGER_new", "()", ";", "if", "(", "serial", "==", "NULL", ")", "goto", "err", ";", "if", "(", "!", "ASN1_INTEGER_set", "(", "serial", ",", "1", ")", ")", "goto", "err", ";", "return", "serial", ";", "err", ":", "TSerr", "(", "TS_F_DEF_SERIAL_CB", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "TS_RESP_CTX_set_status_info", "(", "ctx", ",", "TS_STATUS_REJECTION", ",", "\"Error", "during", "serial", "number", "generation.\"", ")", ";", "return", "NULL", ";", "}'" ]

[ "on_new()", "interceptor", "to", "set", "up", "message", "interceptors" ]

[ "'static", "rd_kafka_resp_err_t", "on_new", "(", "rd_kafka_t", "*", "rk", ",", "const", "rd_kafka_conf_t", "*", "conf", ",", "void", "*", "ic_opaque", ",", "char", "*", "errstr", ",", "size_t", "errstr_size", ")", "{", "rd_kafka_interceptor_add_on_send", "(", "rk", ",", "__FILE__", ",", "on_send1", ",", "NULL", ")", ";", "rd_kafka_interceptor_add_on_send", "(", "rk", ",", "__FILE__", ",", "on_send2", ",", "NULL", ")", ";", "return", "RD_KAFKA_RESP_ERR_NO_ERROR", ";", "}'" ]

[ "Function", "definitions", "for", "certificate", "and", "key", "loading" ]

[ "'X509", "*", "TS_CONF_load_cert", "(", "const", "char", "*", "file", ")", "{", "BIO", "*", "cert", "=", "NULL", ";", "X509", "*", "x", "=", "NULL", ";", "if", "(", "(", "cert", "=", "BIO_new_file", "(", "file", ",", "\"r\"", ")", ")", "==", "NULL", ")", "goto", "end", ";", "x", "=", "PEM_read_bio_X509_AUX", "(", "cert", ",", "NULL", ",", "NULL", ",", "NULL", ")", ";", "end", ":", "if", "(", "x", "==", "NULL", ")", "TSerr", "(", "TS_F_TS_CONF_LOAD_CERT", ",", "TS_R_CANNOT_LOAD_CERT", ")", ";", "BIO_free", "(", "cert", ")", ";", "return", "x", ";", "}'" ]

[ "Return", "the", "recorded", "merge", "weight" ]

[ "'unsigned", "gcov_get_merge_weight", "(", "void", ")", "{", "return", "gcov_merge_weight", ";", "}'" ]

[ "Driver", "to", "normalize", "profile", "counters" ]

[ "'int", "gcov_profile_normalize", "(", "struct", "gcov_info", "*", "profile", ",", "gcov_type", "max_val", ")", "{", "struct", "gcov_info", "*", "gi_ptr", ";", "gcov_type", "curr_max_val", "=", "0", ";", "unsigned", "f_ix", ";", "unsigned", "int", "i", ";", "float", "scale_factor", ";", "/*", "Find", "the", "largest", "count", "value.", "*/", "for", "(", "gi_ptr", "=", "profile", ";", "gi_ptr", ";", "gi_ptr", "=", "gi_ptr", "->", "next", ")", "for", "(", "f_ix", "=", "0", ";", "f_ix", "<", "gi_ptr", "->", "n_functions", ";", "f_ix", "++", ")", "{", "unsigned", "t_ix", ";", "const", "struct", "gcov_fn_info", "*", "gfi_ptr", "=", "gi_ptr", "->", "functions", "[", "f_ix", "]", ";", "const", "struct", "gcov_ctr_info", "*", "ci_ptr", ";", "if", "(", "!", "gfi_ptr", "||", "gfi_ptr", "->", "key", "!=", "gi_ptr", ")", "continue;", "ci_ptr", "=", "gfi_ptr", "->", "ctrs", ";", "for", "(", "t_ix", "=", "0", ";", "t_ix", "<", "1", ";", "t_ix", "++", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "ci_ptr", "->", "num", ";", "i", "++", ")", "if", "(", "ci_ptr", "->", "values", "[", "i", "]", ">", "curr_max_val", ")", "curr_max_val", "=", "ci_ptr", "->", "values", "[", "i", "]", ";", "ci_ptr", "++", ";", "}", "}", "scale_factor", "=", "(", "float", ")", "max_val", "/", "curr_max_val", ";", "if", "(", "verbose", ")", "fnotice", "(", "stdout", ",", "\"max_val", "is", "%\"", "PRId64", "\"\\\"", ",", "curr_max_val", ")", ";", "return", "gcov_profile_scale", "(", "profile", ",", "scale_factor", ",", "0", ",", "0", ")", ";", "}'" ]

[ "Read", "a", "counter", "value", "from", "gcov_value_buf", "array" ]

[ "'gcov_type", "gcov_read_counter_mem", "(", "void", ")", "{", "gcov_type", "ret", ";", "gcc_assert", "(", "gcov_value_buf_pos", "<", "gcov_value_buf_size", ")", ";", "ret", "=", "*", "(", "gcov_value_buf", "+", "gcov_value_buf_pos", ")", ";", "++", "gcov_value_buf_pos", ";", "return", "ret", ";", "}'" ]

[ "Handler", "for", "reading", "summary", "tag" ]

[ "'static", "void", "tag_summary", "(", "unsigned", "tag", "ATTRIBUTE_UNUSED", ",", "unsigned", "length", "ATTRIBUTE_UNUSED", ")", "{", "struct", "gcov_summary", "summary", ";", "gcov_read_summary", "(", "&", "summary", ")", ";", "}'" ]

[ "Handler", "for", "reading", "flow", "arc", "tag" ]

[ "'static", "void", "tag_arcs", "(", "unsigned", "tag", "ATTRIBUTE_UNUSED", ",", "unsigned", "length", "ATTRIBUTE_UNUSED", ")", "{", "/*", "TBD:", "gcov-tool", "currently", "does", "not", "handle", "gcno", "files.", "Assert", "here.", "*/", "gcc_unreachable", "()", ";", "}'" ]

[ "Handler", "for", "reading", "line", "tag" ]

[ "'static", "void", "tag_lines", "(", "unsigned", "tag", "ATTRIBUTE_UNUSED", ",", "unsigned", "length", "ATTRIBUTE_UNUSED", ")", "{", "/*", "TBD:", "gcov-tool", "currently", "does", "not", "handle", "gcno", "files.", "Assert", "here.", "*/", "gcc_unreachable", "()", ";", "}'" ]

[ "Handler", "for", "reading", "function", "tag" ]

[ "'static", "void", "tag_function", "(", "unsigned", "tag", "ATTRIBUTE_UNUSED", ",", "unsigned", "length", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "/*", "write", "out", "previous", "fn_info.", "*/", "if", "(", "num_fn_info", ")", "{", "set_fn_ctrs", "(", "curr_fn_info", ")", ";", "obstack_ptr_grow", "(", "&", "fn_info", ",", "curr_fn_info", ")", ";", "}", "/*", "Here", "we", "over", "allocate", "a", "bit,", "using", "GCOV_COUNTERS", "instead", "of", "the", "actual", "active", "counter", "types.", "*/", "curr_fn_info", "=", "(", "struct", "gcov_fn_info", "*", ")", "xcalloc", "(", "sizeof", "(", "struct", "gcov_fn_info", ")", "+", "GCOV_COUNTERS", "*", "sizeof", "(", "struct", "gcov_ctr_info", ")", ",", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GCOV_COUNTERS", ";", "i", "++", ")", "k_ctrs", "[", "i", "]", ".", "num", "=", "0", ";", "k_ctrs_types", "=", "0", ";", "curr_fn_info", "->", "key", "=", "curr_gcov_info", ";", "curr_fn_info", "->", "ident", "=", "gcov_read_unsigned", "()", ";", "curr_fn_info", "->", "lineno_checksum", "=", "gcov_read_unsigned", "()", ";", "curr_fn_info", "->", "cfg_checksum", "=", "gcov_read_unsigned", "()", ";", "num_fn_info", "++", ";", "if", "(", "verbose", ")", "fnotice", "(", "stdout", ",", "\"tag", "one", "function", "id=%d\\\"", ",", "curr_fn_info", "->", "ident", ")", ";", "}'" ]

[ "Performing", "FN", "upon", "single", "counters" ]

[ "'static", "void", "__gcov_single_counter_op", "(", "gcov_type", "*", "counters", ",", "unsigned", "n_counters", ",", "counter_op_fn", "fn", ",", "void", "*", "data1", ",", "void", "*", "data2", ")", "{", "unsigned", "i", ",", "<type", "ref=\"prev\"/>", "n_measures", ";", "gcc_assert", "(", "!", "(", "n_counters", "%", "3", ")", ")", ";", "n_measures", "=", "n_counters", "/", "3", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_measures", ";", "i", "++", ",", "counters", "+=", "3", ")", "{", "counters", "[", "1", "]", "=", "fn", "(", "counters", "[", "1", "]", ",", "data1", ",", "data2", ")", ";", "counters", "[", "2", "]", "=", "fn", "(", "counters", "[", "2", "]", ",", "data1", ",", "data2", ")", ";", "}", "}'" ]

[ "Extract", "the", "basename", "of", "the", "filename", "NAME" ]

[ "'static", "char", "*", "extract_file_basename", "(", "const", "char", "*", "name", ")", "{", "char", "*", "str", ";", "int", "len", "=", "0", ";", "char", "*", "path", "=", "xstrdup", "(", "name", ")", ";", "char", "sep_str", "[", "2", "]", ";", "sep_str", "[", "0", "]", "=", "DIR_SEPARATOR", ";", "sep_str", "[", "1", "]", "=", "0", ";", "str", "=", "strstr", "(", "path", ",", "sep_str", ")", ";", "do", "{", "len", "=", "strlen", "(", "str", ")", "+", "1", ";", "path", "=", "&", "path", "[", "strlen", "(", "path", ")", "-", "len", "+", "2", "]", ";", "str", "=", "strstr", "(", "path", ",", "sep_str", ")", ";", "}", "while", "(", "str", ")", ";", "return", "path", ";", "}'" ]

[ "Driver", "for", "scaling", "profile", "counters" ]

[ "'int", "gcov_profile_scale", "(", "struct", "gcov_info", "*", "profile", ",", "float", "scale_factor", ",", "int", "n", ",", "int", "d", ")", "{", "struct", "gcov_info", "*", "gi_ptr", ";", "unsigned", "f_ix", ";", "if", "(", "verbose", ")", "fnotice", "(", "stdout", ",", "\"scale_factor", "is", "%f", "or", "%d/%d\\\"", ",", "scale_factor", ",", "n", ",", "d", ")", ";", "/*", "Scaling", "the", "counters.", "*/", "for", "(", "gi_ptr", "=", "profile", ";", "gi_ptr", ";", "gi_ptr", "=", "gi_ptr", "->", "next", ")", "for", "(", "f_ix", "=", "0", ";", "f_ix", "<", "gi_ptr", "->", "n_functions", ";", "f_ix", "++", ")", "{", "unsigned", "t_ix", ";", "const", "struct", "gcov_fn_info", "*", "gfi_ptr", "=", "gi_ptr", "->", "functions", "[", "f_ix", "]", ";", "const", "struct", "gcov_ctr_info", "*", "ci_ptr", ";", "if", "(", "!", "gfi_ptr", "||", "gfi_ptr", "->", "key", "!=", "gi_ptr", ")", "continue;", "ci_ptr", "=", "gfi_ptr", "->", "ctrs", ";", "for", "(", "t_ix", "=", "0", ";", "t_ix", "!=", "GCOV_COUNTERS", ";", "t_ix", "++", ")", "{", "gcov_merge_fn", "merge", "=", "gi_ptr", "->", "merge", "[", "t_ix", "]", ";", "if", "(", "!", "merge", ")", "continue;", "if", "(", "d", "==", "0", ")", "(", "*", "ctr_functions", "[", "t_ix", "]", ")", "(", "ci_ptr", "->", "values", ",", "ci_ptr", "->", "num", ",", "fp_scale", ",", "&", "scale_factor", ",", "NULL", ")", ";", "else", "(", "*", "ctr_functions", "[", "t_ix", "]", ")", "(", "ci_ptr", "->", "values", ",", "ci_ptr", "->", "num", ",", "int_scale", ",", "&", "n", ",", "&", "d", ")", ";", "ci_ptr", "++", ";", "}", "}", "return", "0", ";", "}'" ]

[ "Scaling", "the", "counter", "value", "V", "by", "multiplying", "DATA2", "DATA1" ]

[ "'static", "gcov_type", "int_scale", "(", "gcov_type", "v", ",", "void", "*", "data1", ",", "void", "*", "data2", ")", "{", "int", "n", "=", "*", "(", "int", "*", ")", "data1", ";", "int", "d", "=", "*", "(", "int", "*", ")", "data2", ";", "return", "(", "gcov_type", ")", "(", "RDIV", "(", "v", ",", "d", ")", "*", "n", ")", ";", "}'" ]

[ "Performing", "FN", "upon", "arc", "counters" ]

[ "'static", "void", "__gcov_add_counter_op", "(", "gcov_type", "*", "counters", ",", "unsigned", "n_counters", ",", "counter_op_fn", "fn", ",", "void", "*", "data1", ",", "void", "*", "data2", ")", "{", "for", "(", ";", "n_counters", ";", "counters", "++", ",", "n_counters", "--", ")", "{", "gcov_type", "val", "=", "*", "counters", ";", "*", "counters", "=", "fn", "(", "val", ",", "data1", ",", "data2", ")", ";", "}", "}'" ]

[ "Performing", "FN", "upon", "indirectcall", "profile", "counters" ]

[ "'static", "void", "__gcov_icall_topn_counter_op", "(", "gcov_type", "*", "counters", ",", "unsigned", "n_counters", ",", "counter_op_fn", "fn", ",", "void", "*", "data1", ",", "void", "*", "data2", ")", "{", "unsigned", "i", ";", "gcc_assert", "(", "!", "(", "n_counters", "%", "GCOV_ICALL_TOPN_NCOUNTS", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_counters", ";", "i", "+=", "GCOV_ICALL_TOPN_NCOUNTS", ")", "{", "unsigned", "j", ";", "gcov_type", "*", "value_array", "=", "&", "counters", "[", "i", "+", "1", "]", ";", "for", "(", "j", "=", "0", ";", "j", "<", "GCOV_ICALL_TOPN_NCOUNTS", "-", "1", ";", "j", "+=", "2", ")", "value_array", "[", "j", "+", "1", "]", "=", "fn", "(", "value_array", "[", "j", "+", "1", "]", ",", "data1", ",", "data2", ")", ";", "}", "}'" ]

[ "Handler", "for", "reading", "counters", "array", "tag", "with", "value", "as", "TAG", "and", "length", "of", "LENGTH" ]

[ "'static", "void", "tag_counters", "(", "unsigned", "tag", ",", "unsigned", "length", ")", "{", "unsigned", "n_counts", "=", "GCOV_TAG_COUNTER_NUM", "(", "length", ")", ";", "gcov_type", "*", "values", ";", "unsigned", "ix", ";", "unsigned", "tag_ix", ";", "tag_ix", "=", "GCOV_COUNTER_FOR_TAG", "(", "tag", ")", ";", "gcc_assert", "(", "tag_ix", "<", "GCOV_COUNTERS", ")", ";", "k_ctrs_mask", "[", "tag_ix", "]", "=", "1", ";", "gcc_assert", "(", "k_ctrs", "[", "tag_ix", "]", ".", "num", "==", "0", ")", ";", "k_ctrs", "[", "tag_ix", "]", ".", "num", "=", "n_counts", ";", "k_ctrs", "[", "tag_ix", "]", ".", "values", "=", "values", "=", "(", "gcov_type", "*", ")", "xmalloc", "(", "n_counts", "*", "sizeof", "(", "gcov_type", ")", ")", ";", "gcc_assert", "(", "values", ")", ";", "for", "(", "ix", "=", "0", ";", "ix", "!=", "n_counts", ";", "ix", "++", ")", "values", "[", "ix", "]", "=", "gcov_read_counter", "()", ";", "}'" ]

[ "Handler", "for", "reading", "block", "tag" ]

[ "'static", "void", "tag_blocks", "(", "unsigned", "tag", "ATTRIBUTE_UNUSED", ",", "unsigned", "length", "ATTRIBUTE_UNUSED", ")", "{", "/*", "TBD:", "gcov-tool", "currently", "does", "not", "handle", "gcno", "files.", "Assert", "here.", "*/", "gcc_unreachable", "()", ";", "}'" ]

[ "Scaling", "the", "counter", "value", "V", "by", "multiplying", "(float)", "DATA1" ]

[ "'static", "gcov_type", "fp_scale", "(", "gcov_type", "v", ",", "void", "*", "data1", ",", "void", "*", "data2", "ATTRIBUTE_UNUSED", ")", "{", "float", "f", "=", "*", "(", "float", "*", ")", "data1", ";", "return", "(", "gcov_type", ")", "(", "v", "*", "f", ")", ";", "}'" ]

[ "Set", "the", "ctrs", "field", "in", "gcov_fn_info", "object", "FN_INFO" ]

[ "'static", "void", "set_fn_ctrs", "(", "struct", "gcov_fn_info", "*", "fn_info", ")", "{", "int", "j", "=", "0", ",", "<type", "ref=\"prev\"/>", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GCOV_COUNTERS", ";", "i", "++", ")", "{", "if", "(", "k_ctrs_mask", "[", "i", "]", "==", "0", ")", "continue;", "fn_info", "->", "ctrs", "[", "j", "]", ".", "num", "=", "k_ctrs", "[", "i", "]", ".", "num", ";", "fn_info", "->", "ctrs", "[", "j", "]", ".", "values", "=", "k_ctrs", "[", "i", "]", ".", "values", ";", "j", "++", ";", "}", "if", "(", "k_ctrs_types", "==", "0", ")", "k_ctrs_types", "=", "j", ";", "else", "gcc_assert", "(", "j", "==", "k_ctrs_types", ")", ";", "}'" ]

[ "Performing", "FN", "upon", "ior", "counters" ]

[ "'static", "void", "__gcov_ior_counter_op", "(", "gcov_type", "*", "counters", "ATTRIBUTE_UNUSED", ",", "unsigned", "n_counters", "ATTRIBUTE_UNUSED", ",", "counter_op_fn", "fn", "ATTRIBUTE_UNUSED", ",", "void", "*", "data1", "ATTRIBUTE_UNUSED", ",", "void", "*", "data2", "ATTRIBUTE_UNUSED", ")", "{", "/*", "Do", "nothing.", "*/", "}'" ]

[ "Here", "we", "test", "the", "interfaces", "into", "Dwarf_Line_Context" ]

[ "'static", "void", "print_line_context_record", "(", "Dwarf_Debug", "dbg", ",", "Dwarf_Line_Context", "line_context", ")", "{", "int", "vres", "=", "0", ";", "Dwarf_Unsigned", "lsecoff", "=", "0", ";", "Dwarf_Unsigned", "version", "=", "0", ";", "Dwarf_Signed", "count", "=", "0", ";", "Dwarf_Signed", "i", "=", "0", ";", "const", "char", "*", "name", "=", "0", ";", "Dwarf_Small", "table_count", "=", "0", ";", "Dwarf_Error", "err", "=", "0", ";", "struct", "esb_s", "bufr", ";", "esb_constructor", "(", "&", "bufr", ")", ";", "printf", "(", "\"Line", "Context", "data\\\"", ")", ";", "vres", "=", "dwarf_srclines_table_offset", "(", "line_context", ",", "&", "lsecoff", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "printf", "(", "\"", "Line", "Section", "Offset", "0x%\"", "DW_PR_XZEROS", "DW_PR_DUx", "\"\\\"", ",", "lsecoff", ")", ";", "vres", "=", "dwarf_srclines_version", "(", "line_context", ",", "&", "version", ",", "&", "table_count", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "printf", "(", "\"", "version", "number", "0x%\"", "DW_PR_DUx", "\"", "%\"", "DW_PR_DUu", "\"\\\"", ",", "version", ",", "version", ")", ";", "printf", "(", "\"", "number", "of", "line", "tables", "%d.\\\"", ",", "table_count", ")", ";", "vres", "=", "dwarf_srclines_comp_dir", "(", "line_context", ",", "&", "name", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "if", "(", "name", ")", "{", "printf", "(", "\"", "Compilation", "directory:", "%s\\\"", ",", "name", ")", ";", "}", "else", "{", "printf", "(", "\"", "Compilation", "directory:", "<unknown", "no", "DW_AT_comp_dir>\\\"", ")", ";", "}", "vres", "=", "dwarf_srclines_include_dir_count", "(", "line_context", ",", "&", "count", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "printf", "(", "\"", "include", "directory", "count", "0x%\"", "DW_PR_DUx", "\"", "%\"", "DW_PR_DSd", "\"\\\"", ",", "(", "Dwarf_Unsigned", ")", "count", ",", "count", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "count", ";", "++", "i", ")", "{", "vres", "=", "dwarf_srclines_include_dir_data", "(", "line_context", ",", "i", ",", "&", "name", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "printf", "(", "\"", "[%2\"", "DW_PR_DSd", "\"]", "\\\\\"%s\\\\\"\\\"", ",", "i", ",", "name", ")", ";", "}", "vres", "=", "dwarf_srclines_files_count", "(", "line_context", ",", "&", "count", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "printf", "(", "\"", "files", "count", "0x%\"", "DW_PR_DUx", "\"", "%\"", "DW_PR_DUu", "\"\\\"", ",", "count", ",", "count", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "count", ";", "++", "i", ")", "{", "Dwarf_Unsigned", "dirindex", "=", "0", ";", "Dwarf_Unsigned", "modtime", "=", "0", ";", "Dwarf_Unsigned", "flength", "=", "0", ";", "vres", "=", "dwarf_srclines_files_data", "(", "line_context", ",", "i", ",", "&", "name", ",", "&", "dirindex", ",", "&", "modtime", ",", "&", "flength", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "esb_empty_string", "(", "&", "bufr", ")", ";", "if", "(", "name", ")", "{", "esb_empty_string", "(", "&", "bufr", ")", ";", "esb_append", "(", "&", "bufr", ",", "\"\\\\\"\"", ")", ";", "esb_append", "(", "&", "bufr", ",", "name", ")", ";", "esb_append", "(", "&", "bufr", ",", "\"\\\\\"\"", ")", ";", "}", "else", "{", "esb_append", "(", "&", "bufr", ",", "\"<ERROR:NULL", "name", "in", "files", "list>\"", ")", ";", "}", "printf", "(", "\"", "[%2\"", "DW_PR_DSd", "\"]", "%-24s", ",\"", ",", "i", ",", "esb_get_string", "(", "&", "bufr", ")", ")", ";", "printf", "(", "\"", "directory", "index", "%2\"", "DW_PR_DUu", ",", "dirindex", ")", ";", "printf", "(", "\",", "file", "length", "%2\"", "DW_PR_DUu", ",", "flength", ")", ";", "if", "(", "modtime", ")", "{", "time_t", "tt3", "=", "(", "time_t", ")", "modtime", ";", "/*", "ctime", "supplies", "*/", "printf", "(", "\"file", "mod", "time", "0x%x", "%s\"", ",", "(", "unsigned", ")", "tt3", ",", "ctime", "(", "&", "tt3", ")", ")", ";", "}", "else", "{", "printf", "(", "\"", "file", "mod", "time", "0\\\"", ")", ";", "}", "}", "esb_destructor", "(", "&", "bufr", ")", ";", "vres", "=", "dwarf_srclines_subprog_count", "(", "line_context", ",", "&", "count", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "if", "(", "count", "==", "0", ")", "{", "return", ";", "}", "printf", "(", "\"", "subprograms", "count", "(experimental)", "0x%\"", "DW_PR_DUx", "\"", "%\"", "DW_PR_DUu", "\"\\\"", ",", "count", ",", "count", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "count", ";", "++", "i", ")", "{", "Dwarf_Unsigned", "decl_file", "=", "0", ";", "Dwarf_Unsigned", "decl_line", "=", "0", ";", "vres", "=", "dwarf_srclines_subprog_data", "(", "line_context", ",", "i", ",", "&", "name", ",", "&", "decl_file", ",", "&", "decl_line", ",", "&", "err", ")", ";", "if", "(", "vres", "!=", "DW_DLV_OK", ")", "{", "print_error", "(", "dbg", ",", "\"Error", "accessing", "line", "context\"", "\"Something", "broken.\"", ",", "vres", ",", "err", ")", ";", "return", ";", "}", "printf", "(", "\"", "[%2\"", "DW_PR_DSd", "\"]", "\\\\\"%s\\\\\"\"", "\",", "fileindex", "%2\"", "DW_PR_DUu", "\",", "lineindex", "%2\"", "DW_PR_DUu", "\"\\\"", ",", "i", ",", "name", ",", "decl_file", ",", "decl_line", ")", ";", "}", "}'" ]