Datasets:

AISE-TUDelft

/

Capybara

like 2

Follow

AISE research lab at TU Delft 43

[ "returns", "TRUE", "if", "command", "has", "at", "least", "one", "binding" ]

[ "'gboolean", "command_has_binding", "(", "guint", "command_id", ")", "{", "command_row", "*", "row", ";", "if", "(", "keymap_get_command_row", "(", "Denemo", ".", "map", ",", "&", "row", ",", "command_id", ")", ")", "return", "row", "->", "bindings", "!=", "NULL", ";", "return", "FALSE", ";", "}'" ]

[ "prints", "info", "on", "the", "data", "of", "the", "keymap", "relative", "to", "a", "command" ]

[ "'G_GNUC_UNUSED", "void", "dump_command_info", "(", "keymap", "*", "the_keymap", ",", "gint", "command_id", ")", "{", "gchar", "*", "cur_binding", ";", "command_row", "*", "row", ";", "GtkTreeIter", "iter", ";", "GList", "*", "cur", "=", "NULL", ";", "if", "(", "command_id", "==", "-", "1", ")", "{", "g_message", "(", "\"No", "command.\"", ")", ";", "return", ";", "}", "g_message", "(", "\"command", "%s", "(%d)\\Keyboard", "Shortcuts:\"", ",", "lookup_name_from_idx", "(", "the_keymap", ",", "command_id", ")", ",", "command_id", ")", ";", "if", "(", "!", "keymap_get_command_row", "(", "the_keymap", ",", "&", "row", ",", "command_id", ")", ")", "return", ";", "cur", "=", "row", "->", "bindings", ";", "while", "(", "cur", ")", "{", "g_debug", "(", "\"\\\\t%s", "(%d)\\\"", ",", "(", "char", "*", ")", "cur", "->", "data", ",", "lookup_command_for_keybinding_name", "(", "the_keymap", ",", "cur", "->", "data", ")", ")", ";", "cur", "=", "g_list_next", "(", "cur", ")", ";", "}", "}'" ]

[ "toggle", "hidden", "on", "action", "at", "row", "in", "command", "list" ]

[ "'static", "void", "toggle_hidden_on_action", "(", "G_GNUC_UNUSED", "GtkCellRendererToggle", "*", "cell_renderer", ",", "gchar", "*", "path", ",", "GtkTreeModel", "*", "model", ")", "{", "gint", "command_id", "=", "-", "1", ";", "command_row", "*", "row", "=", "NULL", ";", "GtkTreeIter", "iter", "=", "{", "0", ",", "NULL", ",", "NULL", ",", "NULL", "}", ";", "const", "gchar", "*", "command_name", ";", "GtkTreeSelection", "*", "selection", "=", "gtk_tree_view_get_selection", "(", "GTK_TREE_VIEW", "(", "get_command_view", "()", ")", ")", ";", "if", "(", "selection", ")", "{", "if", "(", "gtk_tree_selection_get_selected", "(", "selection", ",", "NULL", ",", "&", "iter", ")", ")", "{", "gtk_tree_model_get", "(", "model", ",", "&", "iter", ",", "COL_NAME", ",", "&", "command_name", ",", "-", "1", ")", ";", "command_id", "=", "lookup_command_from_name", "(", "Denemo", ".", "map", ",", "command_name", ")", ";", "}", "keymap_get_command_row", "(", "Denemo", ".", "map", ",", "&", "row", ",", "command_id", ")", ";", "const", "DenemoAction", "*", "action", "=", "lookup_action_from_idx", "(", "Denemo", ".", "map", ",", "command_id", ")", ";", "if", "(", "action", "&&", "row", ")", "{", "set_visibility_for_action", "(", "(", "DenemoAction", "*", ")", "action", ",", "row", "->", "hidden", ")", ";", "}", "}", "}'" ]

[ "weaker", "lookup", "of", "keybinding" ]

[ "'gint", "lookup_command_for_keyevent", "(", "GdkEventKey", "*", "event", ")", "{", "keymap", "*", "the_keymap", "=", "Denemo", ".", "map", ";", "gint", "command_id", "=", "lookup_command_for_keybinding", "(", "the_keymap", ",", "event", "->", "keyval", ",", "dnm_sanitize_key_state", "(", "event", ")", ")", ";", "return", "command_id", ";", "}'" ]

[ "implemented", "as", "last", "found", "idx" ]

[ "'static", "gboolean", "search_equal_func", "(", "GtkTreeModel", "*", "model", ",", "gint", "G_GNUC_UNUSED", "column", ",", "const", "gchar", "*", "key", ",", "GtkTreeIter", "*", "iter", ",", "G_GNUC_UNUSED", "gpointer", "search_data", ")", "{", "gchar", "*", "lookin", ";", "gboolean", "notfound", ";", "static", "gchar", "*", "last_key", ";", "static", "gchar", "*", "*", "search_strings", ";", "static", "gint", "number_of_search_terms", ";", "gboolean", "backspace", "=", "FALSE", ";", "while", "(", "*", "key", "==", "\\'", "\\'", ")", "key", "++", ";", "if", "(", "*", "key", "==", "0", "||", "strlen", "(", "key", ")", "<", "4", ")", "return", "TRUE", ";", "if", "(", "(", "!", "last_key", ")", "||", "strcmp", "(", "key", ",", "last_key", ")", ")", "{", "if", "(", "search_strings", ")", "g_strfreev", "(", "search_strings", ")", ";", "search_strings", "=", "g_strsplit", "(", "key", ",", "\"", "\"", ",", "-", "1", ")", ";", "gchar", "*", "*", "p", ";", "number_of_search_terms", "=", "0", ";", "for", "(", "p", "=", "search_strings", ";", "*", "p", "&&", "*", "*", "p", ";", "p", "++", ")", "{", "gchar", "*", "c", "=", "*", "p", ";", "*", "p", "=", "g_utf8_casefold", "(", "*", "p", ",", "-", "1", ")", ";", "g_free", "(", "c", ")", ";", "number_of_search_terms", "++", ";", "}", "backspace", "=", "last_key", "&&", "(", "strlen", "(", "key", ")", "<", "strlen", "(", "last_key", ")", ")", ";", "g_free", "(", "last_key", ")", ";", "last_key", "=", "g_strdup", "(", "key", ")", ";", "}", "if", "(", "backspace", ")", "return", "FALSE", ";", "gchar", "*", "tooltip", ";", "gtk_tree_model_get", "(", "model", ",", "iter", ",", "COL_TOOLTIP", ",", "&", "tooltip", ",", "-", "1", ")", ";", "gchar", "*", "label", ";", "gtk_tree_model_get", "(", "model", ",", "iter", ",", "COL_LABEL", ",", "&", "label", ",", "-", "1", ")", ";", "gchar", "*", "name", ";", "gtk_tree_model_get", "(", "model", ",", "iter", ",", "COL_NAME", ",", "&", "name", ",", "-", "1", ")", ";", "lookin", "=", "g_strconcat", "(", "tooltip", ",", "\"", "\"", ",", "label", ",", "\"", "\"", ",", "name", ",", "\"", "\"", ",", "NULL", ")", ";", "gchar", "*", "this", ";", "this", "=", "g_utf8_casefold", "(", "lookin", ",", "-", "1", ")", ";", "GtkTreePath", "*", "path", "=", "gtk_tree_model_get_path", "(", "model", ",", "iter", ")", ";", "gchar", "*", "thepath", "=", "path", "?", "gtk_tree_path_to_string", "(", "path", ")", ":", "NULL", ";", "gint", "rownum", "=", "thepath", "?", "atoi", "(", "thepath", ")", ":", "0", ";", "gtk_tree_path_free", "(", "path", ")", ";", "g_free", "(", "thepath", ")", ";", "//g_print", "(\"row", "%d\\\\t\",", "rownum);", "gchar", "*", "*", "p", ";", "gint", "matches", "=", "0", ";", "for", "(", "p", "=", "search_strings", ";", "*", "p", "&&", "*", "*", "p", ";", "p", "++", ")", "{", "if", "(", "g_strstr_len", "(", "this", ",", "-", "1", ",", "*", "p", ")", ")", "matches", "++", ";", "}", "//notfound", "=", "(matches", "<=", "number_of_search_terms/2);", "if", "(", "number_of_search_terms", ">", "1", ")", "notfound", "=", "(", "matches", "+", "fuzzy", "<", "number_of_search_terms", ")", ";", "else", "notfound", "=", "!", "matches", ";", "if", "(", "(", "!", "notfound", ")", "&&", "(", "rownum", "<=", "last_row", ")", ")", "notfound", "=", "TRUE", ";", "if", "(", "!", "notfound", ")", "{", "last_row", "=", "rownum", ";", "if", "(", "Denemo", ".", "prefs", ".", "immediateplayback", ")", "play_note", "(", "DEFAULT_BACKEND", ",", "0", ",", "9", ",", "67", ",", "300", ",", "127", ")", ";", "}", "g_free", "(", "this", ")", ";", "g_free", "(", "lookin", ")", ";", "return", "notfound", ";", "}'" ]

[ "looks", "up", "the", "command", "idx", "for", "the", "binding", "of", "name", "binding_name" ]

[ "'gint", "lookup_command_for_keybinding_name", "(", "keymap", "*", "the_keymap", ",", "const", "gchar", "*", "binding_name", ")", "{", "gpointer", "*", "value", "=", "g_hash_table_lookup", "(", "the_keymap", "->", "idx_from_keystring", ",", "binding_name", ")", ";", "if", "(", "value", ")", "return", "*", "(", "(", "guint", "*", ")", "value", ")", ";", "else", "return", "-", "1", ";", "}'" ]

[ "Parses", "a", "mouse", "or", "key", "binding" ]

[ "'static", "int", "ParseBinding", "(", "Display", "*", "dpy", ",", "Binding", "*", "*", "pblist", ",", "char", "*", "tline", ",", "binding_t", "type", ",", "int", "*", "nr_left_buttons", ",", "int", "*", "nr_right_buttons", ",", "unsigned", "short", "*", "buttons_grabbed", ",", "Bool", "is_silent", ")", "{", "char", "*", "action", ";", "char", "context_string", "[", "20", "]", ";", "char", "modifier_string", "[", "20", "]", ";", "char", "*", "ptr", ";", "char", "*", "token", ";", "char", "key_string", "[", "201", "]", "=", "\"\"", ";", "char", "buffer", "[", "80", "]", ";", "char", "*", "window_name", "=", "NULL", ";", "char", "*", "p", ";", "int", "button", "=", "0", ";", "int", "n1", "=", "0", ";", "int", "n2", "=", "0", ";", "int", "n3", "=", "0", ";", "int", "context", ";", "int", "modifier", ";", "int", "rc", ";", "KeySym", "keysym", "=", "NoSymbol", ";", "Bool", "is_unbind_request", "=", "False", ";", "Bool", "is_pass_through", "=", "False", ";", "Bool", "are_similar_bindings_left", ";", "Binding", "*", "b", ";", "Binding", "*", "rmlist", "=", "NULL", ";", "STROKE_CODE", "(", "char", "stroke[STROKE_MAX_SEQUENCE", "+", "1", "]", "=", "\"\"", ")", ";", "STROKE_CODE", "(", "int", "n4", "=", "0", ")", ";", "STROKE_CODE", "(", "int", "i", ")", ";", "/*", "tline", "points", "after", "the", "key", "word", "\"Mouse\"", "or", "\"Key\"", "*/", "token", "=", "p", "=", "PeekToken", "(", "tline", ",", "&", "ptr", ")", ";", "/*", "check", "to", "see", "if", "a", "window", "name", "has", "been", "specified.", "*/", "if", "(", "p", "==", "NULL", ")", "{", "fvwm_msg", "(", "ERR", ",", "\"ParseBinding\"", ",", "\"empty", "%s", "binding,", "ignored\\\"", ",", "tline", ")", ";", "return", "0", ";", "}", "if", "(", "*", "p", "==", "\\'(\\'", ")", "{", "/*", "A", "window", "name", "has", "been", "specified", "for", "the", "binding.", "*/", "sscanf", "(", "p", "+", "1", ",", "\"%79s\"", ",", "buffer", ")", ";", "p", "=", "buffer", ";", "while", "(", "*", "p", "!=", "\\')\\'", ")", "{", "if", "(", "*", "p", "==", "\\'\\\\0\\'", ")", "{", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "ERR", ",", "\"ParseBinding\"", ",", "\"Syntax", "error", "in", "line", "%s", "-\"", "\"", "missing", "\\')\\'\"", ",", "tline", ")", ";", "}", "return", "0", ";", "}", "++", "p", ";", "}", "*", "p", "++", "=", "\\'\\\\0\\'", ";", "window_name", "=", "buffer", ";", "if", "(", "*", "p", "!=", "\\'\\\\0\\'", ")", "{", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "ERR", ",", "\"ParseBinding\"", ",", "\"Syntax", "error", "in", "line", "%s", "-", "trailing\"", "\"", "text", "after", "specified", "window\"", ",", "tline", ")", ";", "}", "return", "0", ";", "}", "token", "=", "PeekToken", "(", "ptr", ",", "&", "ptr", ")", ";", "}", "if", "(", "token", "!=", "NULL", ")", "{", "if", "(", "BIND_IS_KEY_BINDING", "(", "type", ")", ")", "{", "/*", "see", "len", "of", "key_string", "above", "*/", "n1", "=", "sscanf", "(", "token", ",", "\"%200s\"", ",", "key_string", ")", ";", "}", "#", "ifdef", "HAVE_STROKE", "<if", "type=\"elseif\">", "else", "if", "(", "BIND_IS_STROKE_BINDING", "(", "type", ")", ")", "{", "int", "num", "=", "0", ";", "int", "j", ";", "n1", "=", "1", ";", "i", "=", "0", ";", "if", "(", "token", "[", "0", "]", "==", "\\'N\\'", "&&", "token", "[", "1", "]", "!=", "\\'\\\\0\\'", ")", "{", "num", "=", "1", ";", "}", "j", "=", "i", "+", "num", ";", "while", "(", "n1", "&&", "token", "[", "j", "]", "!=", "\\'\\\\0\\'", "&&", "i", "<", "STROKE_MAX_SEQUENCE", ")", "{", "if", "(", "!", "isdigit", "(", "token", "[", "j", "]", ")", ")", "{", "n1", "=", "0", ";", "}", "if", "(", "num", ")", "{", "/*", "Numeric", "pad", "to", "Telephone", "*/", "if", "(", "\\'7\\'", "<=", "token", "[", "j", "]", "&&", "token", "[", "j", "]", "<=", "\\'9\\'", ")", "{", "token", "[", "j", "]", "-=", "6", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "\\'1\\'", "<=", "token", "[", "j", "]", "&&", "token", "[", "j", "]", "<=", "\\'3\\'", ")", "{", "token", "[", "j", "]", "+=", "6", ";", "}", "}", "stroke", "[", "i", "]", "=", "token", "[", "j", "]", ";", "i", "++", ";", "j", "=", "i", "+", "num", ";", "}", "stroke", "[", "i", "]", "=", "\\'\\\\0\\'", ";", "if", "(", "strlen", "(", "token", ")", ">", "STROKE_MAX_SEQUENCE", "+", "num", ")", "{", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "WARN", ",", "\"ParseBinding\"", ",", "\"Too", "long", "stroke", "sequence", "in\"", "\"", "line", "%s.", "Only", "%i", "elements\"", "\"", "will", "be", "taken", "into\"", "\"", "account.\\\"", ",", "tline", ",", "STROKE_MAX_SEQUENCE", ")", ";", "}", "}", "}", "#", "endif", "/*", "HAVE_STROKE", "*/", "else", "{", "n1", "=", "sscanf", "(", "token", ",", "\"%d\"", ",", "&", "button", ")", ";", "if", "(", "button", "<", "0", ")", "{", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "ERR", ",", "\"ParseBinding\"", ",", "\"Illegal", "mouse", "button", "in", "line\"", "\"", "%s\"", ",", "tline", ")", ";", "}", "return", "0", ";", "}", "if", "(", "button", ">", "NUMBER_OF_MOUSE_BUTTONS", ")", "{", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "WARN", ",", "\"ParseBinding\"", ",", "\"Got", "mouse", "button", "%d", "when", "the\"", "\"", "maximum", "is", "%d.\\", "You", "can\\'t\"", "\"", "bind", "complex", "functions", "to\"", "\"", "this", "button.", "To", "suppress\"", "\"", "this", "warning,", "use:\\\"", "\"", "Silent", "Mouse", "%s\"", ",", "button", ",", "NUMBER_OF_MOUSE_BUTTONS", ",", "tline", ")", ";", "}", "}", "}", "}", "#", "ifdef", "HAVE_STROKE", "if", "(", "BIND_IS_STROKE_BINDING", "(", "type", ")", ")", "{", "token", "=", "PeekToken", "(", "ptr", ",", "&", "ptr", ")", ";", "if", "(", "token", "!=", "NULL", ")", "{", "n4", "=", "sscanf", "(", "token", ",", "\"%d\"", ",", "&", "button", ")", ";", "}", "}", "#", "endif", "/*", "HAVE_STROKE", "*/", "token", "=", "PeekToken", "(", "ptr", ",", "&", "ptr", ")", ";", "if", "(", "token", "!=", "NULL", ")", "{", "n2", "=", "sscanf", "(", "token", ",", "\"%19s\"", ",", "context_string", ")", ";", "}", "token", "=", "PeekToken", "(", "ptr", ",", "&", "action", ")", ";", "if", "(", "token", "!=", "NULL", ")", "{", "n3", "=", "sscanf", "(", "token", ",", "\"%19s\"", ",", "modifier_string", ")", ";", "}", "if", "(", "n1", "!=", "1", "||", "n2", "!=", "1", "||", "n3", "!=", "1", "STROKE_CODE", "(", "||", "(", "BIND_IS_STROKE_BINDING", "(", "type", ")", "&&", "n4", "!=", "1", ")", ")", ")", "{", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "ERR", ",", "\"ParseBinding\"", ",", "\"Syntax", "error", "in", "line", "%s\"", ",", "tline", ")", ";", "}", "return", "0", ";", "}", "if", "(", "wcontext_string_to_wcontext", "(", "context_string", ",", "&", "context", ")", "&&", "!", "is_silent", ")", "{", "fvwm_msg", "(", "WARN", ",", "\"ParseBinding\"", ",", "\"Illegal", "context", "in", "line", "%s\"", ",", "tline", ")", ";", "}", "if", "(", "modifiers_string_to_modmask", "(", "modifier_string", ",", "&", "modifier", ")", "&&", "!", "is_silent", ")", "{", "fvwm_msg", "(", "WARN", ",", "\"ParseBinding\"", ",", "\"Illegal", "modifier", "in", "line", "%s\"", ",", "tline", ")", ";", "}", "if", "(", "BIND_IS_KEY_BINDING", "(", "type", ")", ")", "{", "keysym", "=", "FvwmStringToKeysym", "(", "dpy", ",", "key_string", ")", ";", "/*", "Don\\'t", "let", "a", "0", "keycode", "go", "through,", "since", "that", "means", "AnyKey", "*", "to", "the", "XGrabKey", "call.", "*/", "if", "(", "keysym", "==", "0", ")", "{", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "ERR", ",", "\"ParseBinding\"", ",", "\"No", "such", "key:", "%s\"", ",", "key_string", ")", ";", "}", "return", "0", ";", "}", "}", "if", "(", "action", "!=", "NULL", ")", "{", "action", "=", "SkipSpaces", "(", "action", ",", "NULL", ",", "0", ")", ";", "}", "if", "(", "action", "==", "NULL", "||", "*", "action", "==", "0", "||", "(", "action", "[", "0", "]", "==", "\\'-\\'", "&&", "!", "is_pass_through", ")", ")", "{", "is_unbind_request", "=", "True", ";", "}", "else", "{", "is_pass_through", "=", "is_pass_through_action", "(", "action", ")", ";", "if", "(", "is_pass_through", ")", "{", "/*", "pass-through", "actions", "indicate", "that", "the", "event", "be", "*", "allowed", "to", "pass", "through", "to", "the", "underlying", "window.", "*/", "if", "(", "window_name", "==", "NULL", ")", "{", "/*", "It", "doesn\\'t", "make", "sense", "to", "have", "a", "pass-through", "*", "action", "on", "global", "bindings.", "*/", "if", "(", "!", "is_silent", ")", "{", "fvwm_msg", "(", "ERR", ",", "\"ParseBinding\"", ",", "\"Invalid", "action", "for", "global", "\"", "\"binding:", "%s\"", ",", "tline", ")", ";", "}", "return", "0", ";", "}", "}", "}", "/*", "short", "circuit", "menu", "bindings", "for", "now.", "*/", "if", "(", "(", "context", "&", "C_MENU", ")", "==", "C_MENU", ")", "{", "menu_binding", "(", "dpy", ",", "type", ",", "button", ",", "keysym", ",", "context", ",", "modifier", ",", "action", ",", "window_name", ")", ";", "/*", "ParseBinding", "returns", "the", "number", "of", "new", "bindings", "in", "pblist", "*", "menu", "bindings", "does", "not", "add", "to", "pblist,", "and", "should", "return", "0", "*/", "return", "0", ";", "}", "/*", "short", "circuit", "placement", "bindings", "for", "now.", "*/", "if", "(", "(", "context", "&", "C_PLACEMENT", ")", "==", "C_PLACEMENT", ")", "{", "placement_binding", "(", "button", ",", "keysym", ",", "modifier", ",", "action", ")", ";", "/*", "ParseBinding", "returns", "the", "number", "of", "new", "bindings", "in", "pblist", "*", "placement", "bindings", "does", "not", "add", "to", "pblist,", "and", "should", "*", "return", "0", "*/", "return", "0", ";", "}", "/*", "**", "Remove", "the", "\"old\"", "bindings", "if", "any", "*/", "/*", "BEGIN", "remove", "*/", "CollectBindingList", "(", "dpy", ",", "pblist", ",", "&", "rmlist", ",", "&", "are_similar_bindings_left", ",", "type", ",", "STROKE_ARG", "(", "(void", "*)stroke", ")", "button", ",", "keysym", ",", "modifier", ",", "context", ",", "window_name", ")", ";", "if", "(", "rmlist", "!=", "NULL", ")", "{", "int", "bcontext", ";", "if", "(", "is_unbind_request", "&&", "are_similar_bindings_left", "==", "False", ")", "{", "int", "rc", "=", "0", ";", "for", "(", "b", "=", "rmlist", ";", "b", "!=", "NULL", ";", "b", "=", "b", "->", "NextBinding", ")", "{", "/*", "release", "the", "grab", "*/", "rc", "|=", "activate_binding", "(", "b", ",", "type", ",", "False", ")", ";", "}", "if", "(", "rc", ")", "{", "__rebind_global_key", "(", "pblist", ",", "rmlist", "->", "Button_Key", ")", ";", "}", "}", "FreeBindingList", "(", "rmlist", ")", ";", "bcontext", "=", "bind_get_bound_button_contexts", "(", "pblist", ",", "buttons_grabbed", ")", ";", "update_nr_buttons", "(", "bcontext", ",", "nr_left_buttons", ",", "nr_right_buttons", ",", "True", ")", ";", "}", "/*", "return", "if", "it", "is", "an", "unbind", "request", "*/", "if", "(", "is_unbind_request", ")", "{", "return", "0", ";", "}", "/*", "END", "remove", "*/", "update_nr_buttons", "(", "context", ",", "nr_left_buttons", ",", "nr_right_buttons", ",", "False", ")", ";", "if", "(", "(", "modifier", "&", "AnyModifier", ")", "&&", "(", "modifier", "&", "(", "~", "AnyModifier", ")", ")", ")", "{", "fvwm_msg", "(", "WARN", ",", "\"ParseBinding\"", ",", "\"Binding", "specified", "AnyModifier\"", "\"", "and", "other", "modifers", "too.", "Excess", "modifiers", "are\"", "\"", "ignored.\"", ")", ";", "modifier", "=", "AnyModifier", ";", "}", "if", "(", "(", "BIND_IS_MOUSE_BINDING", "(", "type", ")", "||", "(", "BIND_IS_STROKE_BINDING", "(", "type", ")", "&&", "button", "!=", "0", ")", ")", "&&", "(", "context", "&", "(", "C_WINDOW", "|", "C_EWMH_DESKTOP", ")", ")", "&&", "buttons_grabbed", "!=", "NULL", ")", "{", "if", "(", "button", "==", "0", ")", "{", "*", "buttons_grabbed", "|=", "(", "(", "1", "<<", "NUMBER_OF_EXTENDED_MOUSE_BUTTONS", ")", "-", "1", ")", ";", "}", "else", "{", "*", "buttons_grabbed", "|=", "(", "1", "<<", "(", "button", "-", "1", ")", ")", ";", "}", "}", "rc", "=", "AddBinding", "(", "dpy", ",", "pblist", ",", "type", ",", "STROKE_ARG", "(", "(void", "*)stroke", ")", "button", ",", "keysym", ",", "key_string", ",", "modifier", ",", "context", ",", "(", "void", "*", ")", "action", ",", "NULL", ",", "window_name", ")", ";", "return", "rc", ";", "}'" ]

[ "File", "name", "or", "a", "list", "of", "genomic", "locations" ]

[ "'static", "bcf_sr_regions_t", "*", "_regions_init_string", "(", "const", "char", "*", "str", ")", "{", "bcf_sr_regions_t", "*", "reg", "=", "(", "bcf_sr_regions_t", "*", ")", "calloc", "(", "1", ",", "sizeof", "(", "bcf_sr_regions_t", ")", ")", ";", "reg", "->", "start", "=", "reg", "->", "end", "=", "-", "1", ";", "reg", "->", "prev_start", "=", "reg", "->", "prev_end", "=", "reg", "->", "prev_seq", "=", "-", "1", ";", "kstring_t", "tmp", "=", "{", "0", ",", "0", ",", "0", "}", ";", "const", "char", "*", "sp", "=", "str", ",", "<type", "ref=\"prev\">", "*", "ep", "=", "str", ";", "hts_pos_t", "from", ",", "<type", "ref=\"prev\"/>", "to", ";", "while", "(", "1", ")", "{", "while", "(", "*", "ep", "&&", "*", "ep", "!=", "\\',\\'", "&&", "*", "ep", "!=", "\\':\\'", ")", "ep", "++", ";", "tmp", ".", "l", "=", "0", ";", "kputsn", "(", "sp", ",", "ep", "-", "sp", ",", "&", "tmp", ")", ";", "if", "(", "*", "ep", "==", "\\':\\'", ")", "{", "sp", "=", "ep", "+", "1", ";", "from", "=", "hts_parse_decimal", "(", "sp", ",", "(", "char", "*", "*", ")", "&", "ep", ",", "0", ")", ";", "if", "(", "sp", "==", "ep", ")", "{", "hts_log_error", "(", "\"Could", "not", "parse", "the", "region(s):", "%s\"", ",", "str", ")", ";", "free", "(", "reg", ")", ";", "free", "(", "tmp", ".", "s", ")", ";", "return", "NULL", ";", "}", "if", "(", "!", "*", "ep", "||", "*", "ep", "==", "\\',\\'", ")", "{", "_regions_add", "(", "reg", ",", "tmp", ".", "s", ",", "from", ",", "from", ")", ";", "sp", "=", "ep", ";", "continue;", "}", "if", "(", "*", "ep", "!=", "\\'-\\'", ")", "{", "hts_log_error", "(", "\"Could", "not", "parse", "the", "region(s):", "%s\"", ",", "str", ")", ";", "free", "(", "reg", ")", ";", "free", "(", "tmp", ".", "s", ")", ";", "return", "NULL", ";", "}", "ep", "++", ";", "sp", "=", "ep", ";", "to", "=", "hts_parse_decimal", "(", "sp", ",", "(", "char", "*", "*", ")", "&", "ep", ",", "0", ")", ";", "if", "(", "*", "ep", "&&", "*", "ep", "!=", "\\',\\'", ")", "{", "hts_log_error", "(", "\"Could", "not", "parse", "the", "region(s):", "%s\"", ",", "str", ")", ";", "free", "(", "reg", ")", ";", "free", "(", "tmp", ".", "s", ")", ";", "return", "NULL", ";", "}", "if", "(", "sp", "==", "ep", ")", "to", "=", "MAX_CSI_COOR", "-", "1", ";", "_regions_add", "(", "reg", ",", "tmp", ".", "s", ",", "from", ",", "to", ")", ";", "if", "(", "!", "*", "ep", ")", "break;", "sp", "=", "ep", ";", "}", "else", "{", "if", "(", "tmp", ".", "l", ")", "_regions_add", "(", "reg", ",", "tmp", ".", "s", ",", "-", "1", ",", "-", "1", ")", ";", "if", "(", "!", "*", "ep", ")", "break;", "sp", "=", "++", "ep", ";", "}", "}", "free", "(", "tmp", ".", "s", ")", ";", "return", "reg", ";", "}'" ]

[ "Pass", "received", "custom", "extension", "data", "to", "the", "application", "for", "parsing" ]

[ "\"int", "custom_ext_parse", "(", "SSL", "*", "s", ",", "int", "server", ",", "unsigned", "int", "ext_type", ",", "const", "unsigned", "char", "*", "ext_data", ",", "size_t", "ext_size", ",", "int", "*", "al", ")", "{", "custom_ext_methods", "*", "exts", "=", "server", "?", "&", "s", "->", "cert", "->", "srv_ext", ":", "&", "s", "->", "cert", "->", "cli_ext", ";", "custom_ext_method", "*", "meth", ";", "meth", "=", "custom_ext_find", "(", "exts", ",", "ext_type", ")", ";", "/*", "If", "not", "found", "return", "success", "*/", "if", "(", "!", "meth", ")", "return", "1", ";", "if", "(", "!", "server", ")", "{", "/*", "*", "If", "it's", "ServerHello", "we", "can't", "have", "any", "extensions", "not", "sent", "in", "*", "ClientHello.", "*/", "if", "(", "!", "(", "meth", "->", "ext_flags", "&", "SSL_EXT_FLAG_SENT", ")", ")", "{", "*", "al", "=", "TLS1_AD_UNSUPPORTED_EXTENSION", ";", "return", "0", ";", "}", "}", "/*", "If", "already", "present", "it's", "a", "duplicate", "*/", "if", "(", "meth", "->", "ext_flags", "&", "SSL_EXT_FLAG_RECEIVED", ")", "{", "*", "al", "=", "TLS1_AD_DECODE_ERROR", ";", "return", "0", ";", "}", "meth", "->", "ext_flags", "|=", "SSL_EXT_FLAG_RECEIVED", ";", "/*", "If", "no", "parse", "function", "set", "return", "success", "*/", "if", "(", "!", "meth", "->", "parse_cb", ")", "return", "1", ";", "return", "meth", "->", "parse_cb", "(", "s", ",", "ext_type", ",", "ext_data", ",", "ext_size", ",", "al", ",", "meth", "->", "parse_arg", ")", ";", "}\"" ]

[ "Copy", "table", "of", "custom", "extensions" ]

[ "'int", "custom_exts_copy", "(", "custom_ext_methods", "*", "dst", ",", "const", "custom_ext_methods", "*", "src", ")", "{", "if", "(", "src", "->", "meths_count", ")", "{", "dst", "->", "meths", "=", "OPENSSL_memdup", "(", "src", "->", "meths", ",", "sizeof", "(", "custom_ext_method", ")", "*", "src", "->", "meths_count", ")", ";", "if", "(", "dst", "->", "meths", "==", "NULL", ")", "return", "0", ";", "dst", "->", "meths_count", "=", "src", "->", "meths_count", ";", "}", "return", "1", ";", "}'" ]

[ "Application", "level", "functions", "to", "add", "custom", "extension", "callbacks" ]

[ "\"int", "SSL_CTX_add_client_custom_ext", "(", "SSL_CTX", "*", "ctx", ",", "unsigned", "int", "ext_type", ",", "custom_ext_add_cb", "add_cb", ",", "custom_ext_free_cb", "free_cb", ",", "void", "*", "add_arg", ",", "custom_ext_parse_cb", "parse_cb", ",", "void", "*", "parse_arg", ")", "{", "#", "ifndef", "OPENSSL_NO_CT", "/*", "*", "We", "don't", "want", "applications", "registering", "callbacks", "for", "SCT", "extensions", "*", "whilst", "simultaneously", "using", "the", "built-in", "SCT", "validation", "features,", "as", "*", "these", "two", "things", "may", "not", "play", "well", "together.", "*/", "if", "(", "ext_type", "==", "TLSEXT_TYPE_signed_certificate_timestamp", "&&", "SSL_CTX_ct_is_enabled", "(", "ctx", ")", ")", "return", "0", ";", "#", "endif", "return", "custom_ext_meth_add", "(", "&", "ctx", "->", "cert", "->", "cli_ext", ",", "ext_type", ",", "add_cb", ",", "free_cb", ",", "add_arg", ",", "parse_cb", ",", "parse_arg", ")", ";", "}\"" ]

[ "Return", "true", "if", "a", "client", "custom", "extension", "exists,", "false", "otherwise" ]

[ "'int", "SSL_CTX_has_client_custom_ext", "(", "const", "SSL_CTX", "*", "ctx", ",", "unsigned", "int", "ext_type", ")", "{", "return", "custom_ext_find", "(", "&", "ctx", "->", "cert", "->", "cli_ext", ",", "ext_type", ")", "!=", "NULL", ";", "}'" ]

[ "Set", "callbacks", "for", "a", "custom", "extension" ]

[ "'static", "int", "custom_ext_meth_add", "(", "custom_ext_methods", "*", "exts", ",", "unsigned", "int", "ext_type", ",", "custom_ext_add_cb", "add_cb", ",", "custom_ext_free_cb", "free_cb", ",", "void", "*", "add_arg", ",", "custom_ext_parse_cb", "parse_cb", ",", "void", "*", "parse_arg", ")", "{", "custom_ext_method", "*", "meth", ",", "<type", "ref=\"prev\">", "*", "tmp", ";", "/*", "*", "Check", "application", "error:", "if", "add_cb", "is", "not", "set", "free_cb", "will", "never", "be", "*", "called.", "*/", "if", "(", "!", "add_cb", "&&", "free_cb", ")", "return", "0", ";", "/*", "*", "Don\\'t", "add", "if", "extension", "supported", "internally,", "but", "make", "exception", "*", "for", "extension", "types", "that", "previously", "were", "not", "supported,", "but", "now", "are.", "*/", "if", "(", "SSL_extension_supported", "(", "ext_type", ")", "&&", "ext_type", "!=", "TLSEXT_TYPE_signed_certificate_timestamp", ")", "return", "0", ";", "/*", "Extension", "type", "must", "fit", "in", "16", "bits", "*/", "if", "(", "ext_type", ">", "0xffff", ")", "return", "0", ";", "/*", "Search", "for", "duplicate", "*/", "if", "(", "custom_ext_find", "(", "exts", ",", "ext_type", ")", ")", "return", "0", ";", "tmp", "=", "OPENSSL_realloc", "(", "exts", "->", "meths", ",", "(", "exts", "->", "meths_count", "+", "1", ")", "*", "sizeof", "(", "custom_ext_method", ")", ")", ";", "if", "(", "tmp", "==", "NULL", ")", "{", "OPENSSL_free", "(", "exts", "->", "meths", ")", ";", "exts", "->", "meths", "=", "NULL", ";", "exts", "->", "meths_count", "=", "0", ";", "return", "0", ";", "}", "exts", "->", "meths", "=", "tmp", ";", "meth", "=", "exts", "->", "meths", "+", "exts", "->", "meths_count", ";", "memset", "(", "meth", ",", "0", ",", "sizeof", "(", "*", "meth", ")", ")", ";", "meth", "->", "parse_cb", "=", "parse_cb", ";", "meth", "->", "add_cb", "=", "add_cb", ";", "meth", "->", "free_cb", "=", "free_cb", ";", "meth", "->", "ext_type", "=", "ext_type", ";", "meth", "->", "add_arg", "=", "add_arg", ";", "meth", "->", "parse_arg", "=", "parse_arg", ";", "exts", "->", "meths_count", "++", ";", "return", "1", ";", "}'" ]

[ "set", "f", "to", "the", "rational", "q" ]

[ "'int", "mpfr_set_q", "(", "mpfr_ptr", "f", ",", "mpq_srcptr", "q", ",", "mpfr_rnd_t", "rnd", ")", "{", "mpz_srcptr", "num", ",", "<type", "ref=\"prev\"/>", "den", ";", "mpfr_t", "n", ",", "<type", "ref=\"prev\"/>", "d", ";", "int", "inexact", ";", "int", "cn", ",", "<type", "ref=\"prev\"/>", "cd", ";", "long", "shift", ";", "mp_size_t", "sn", ",", "<type", "ref=\"prev\"/>", "sd", ";", "MPFR_SAVE_EXPO_DECL", "(", "expo", ")", ";", "num", "=", "mpq_numref", "(", "q", ")", ";", "den", "=", "mpq_denref", "(", "q", ")", ";", "/*", "NAN", "and", "INF", "for", "mpq", "are", "not", "really", "documented,", "but", "could", "be", "found", "*/", "if", "(", "MPFR_UNLIKELY", "(", "mpz_sgn", "(", "num", ")", "==", "0", ")", ")", "{", "if", "(", "MPFR_UNLIKELY", "(", "mpz_sgn", "(", "den", ")", "==", "0", ")", ")", "{", "MPFR_SET_NAN", "(", "f", ")", ";", "MPFR_RET_NAN", ";", "}", "else", "{", "MPFR_SET_ZERO", "(", "f", ")", ";", "MPFR_SET_POS", "(", "f", ")", ";", "MPFR_RET", "(", "0", ")", ";", "}", "}", "if", "(", "MPFR_UNLIKELY", "(", "mpz_sgn", "(", "den", ")", "==", "0", ")", ")", "{", "MPFR_SET_INF", "(", "f", ")", ";", "MPFR_SET_SIGN", "(", "f", ",", "mpz_sgn", "(", "num", ")", ")", ";", "MPFR_RET", "(", "0", ")", ";", "}", "MPFR_SAVE_EXPO_MARK", "(", "expo", ")", ";", "cn", "=", "set_z", "(", "n", ",", "num", ",", "&", "sn", ")", ";", "cd", "=", "set_z", "(", "d", ",", "den", ",", "&", "sd", ")", ";", "sn", "-=", "sd", ";", "if", "(", "MPFR_UNLIKELY", "(", "sn", ">", "MPFR_EMAX_MAX", "/", "GMP_NUMB_BITS", ")", ")", "{", "MPFR_SAVE_EXPO_FREE", "(", "expo", ")", ";", "inexact", "=", "mpfr_overflow", "(", "f", ",", "rnd", ",", "MPFR_SIGN", "(", "f", ")", ")", ";", "goto", "end", ";", "}", "if", "(", "MPFR_UNLIKELY", "(", "sn", "<", "MPFR_EMIN_MIN", "/", "GMP_NUMB_BITS", "-", "1", ")", ")", "{", "MPFR_SAVE_EXPO_FREE", "(", "expo", ")", ";", "if", "(", "rnd", "==", "MPFR_RNDN", ")", "rnd", "=", "MPFR_RNDZ", ";", "inexact", "=", "mpfr_underflow", "(", "f", ",", "rnd", ",", "MPFR_SIGN", "(", "f", ")", ")", ";", "goto", "end", ";", "}", "inexact", "=", "mpfr_div", "(", "f", ",", "n", ",", "d", ",", "rnd", ")", ";", "shift", "=", "GMP_NUMB_BITS", "*", "sn", "+", "cn", "-", "cd", ";", "MPFR_ASSERTD", "(", "shift", "==", "GMP_NUMB_BITS", "*", "sn", "+", "cn", "-", "cd", ")", ";", "cd", "=", "mpfr_mul_2si", "(", "f", ",", "f", ",", "shift", ",", "rnd", ")", ";", "MPFR_SAVE_EXPO_FREE", "(", "expo", ")", ";", "if", "(", "MPFR_UNLIKELY", "(", "cd", "!=", "0", ")", ")", "inexact", "=", "cd", ";", "else", "inexact", "=", "mpfr_check_range", "(", "f", ",", "inexact", ",", "rnd", ")", ";", "end", ":", "mpfr_clear", "(", "d", ")", ";", "mpfr_clear", "(", "n", ")", ";", "MPFR_RET", "(", "inexact", ")", ";", "}'" ]

[ "Write", "\\p", "payload", "of", "\\p", "size", "at", "absolute", "offset", "\\p", "absof" ]

[ "'size_t", "rd_buf_write_update", "(", "rd_buf_t", "*", "rbuf", ",", "size_t", "absof", ",", "const", "void", "*", "payload", ",", "size_t", "size", ")", "{", "rd_segment_t", "*", "seg", ";", "const", "char", "*", "psrc", "=", "(", "const", "char", "*", ")", "payload", ";", "size_t", "of", ";", "/*", "Find", "segment", "for", "offset", "*/", "seg", "=", "rd_buf_get_segment_at_offset", "(", "rbuf", ",", "rbuf", "->", "rbuf_wpos", ",", "absof", ")", ";", "rd_assert", "(", "seg", "&&", "*", "\"invalid", "absolute", "offset\"", ")", ";", "for", "(", "of", "=", "0", ";", "of", "<", "size", ";", "seg", "=", "TAILQ_NEXT", "(", "seg", ",", "seg_link", ")", ")", "{", "rd_assert", "(", "seg", "->", "seg_absof", "<=", "rd_buf_len", "(", "rbuf", ")", ")", ";", "size_t", "wlen", "=", "rd_segment_write_update", "(", "seg", ",", "absof", "+", "of", ",", "psrc", "+", "of", ",", "size", "-", "of", ")", ";", "of", "+=", "wlen", ";", "}", "rd_dassert", "(", "of", "==", "size", ")", ";", "return", "of", ";", "}'" ]

[ "Do", "a", "writeseek,", "updating", "the", "write", "position", "to", "the", "given" ]

[ "'int", "rd_buf_write_seek", "(", "rd_buf_t", "*", "rbuf", ",", "size_t", "absof", ")", "{", "rd_segment_t", "*", "seg", ",", "<type", "ref=\"prev\">", "*", "next", ";", "size_t", "relof", ";", "seg", "=", "rd_buf_get_segment_at_offset", "(", "rbuf", ",", "rbuf", "->", "rbuf_wpos", ",", "absof", ")", ";", "if", "(", "unlikely", "(", "!", "seg", ")", ")", "return", "-", "1", ";", "relof", "=", "absof", "-", "seg", "->", "seg_absof", ";", "if", "(", "unlikely", "(", "relof", ">", "seg", "->", "seg_of", ")", ")", "return", "-", "1", ";", "/*", "Destroy", "sub-sequent", "segments", "in", "reverse", "order", "so", "that", "*", "destroy_segment()", "length", "checks", "are", "correct.", "*", "Will", "decrement", "rbuf_len", "et.al.", "*/", "for", "(", "next", "=", "TAILQ_LAST", "(", "&", "rbuf", "->", "rbuf_segments", ",", "rd_segment_head", ")", ";", "next", "!=", "seg", ";", ")", "{", "rd_segment_t", "*", "this", "=", "next", ";", "next", "=", "TAILQ_PREV", "(", "this", ",", "rd_segment_head", ",", "seg_link", ")", ";", "rd_buf_destroy_segment", "(", "rbuf", ",", "this", ")", ";", "}", "/*", "Update", "relative", "write", "offset", "*/", "seg", "->", "seg_of", "=", "relof", ";", "rbuf", "->", "rbuf_wpos", "=", "seg", ";", "rbuf", "->", "rbuf_len", "=", "seg", "->", "seg_absof", "+", "seg", "->", "seg_of", ";", "rd_assert", "(", "rbuf", "->", "rbuf_len", "==", "absof", ")", ";", "return", "0", ";", "}'" ]

[ "Ensures", "that", "at", "least", "\\p", "size", "bytes", "will", "be", "available", "for" ]

[ "'void", "rd_buf_write_ensure", "(", "rd_buf_t", "*", "rbuf", ",", "size_t", "min_size", ",", "size_t", "max_size", ")", "{", "size_t", "remains", ";", "while", "(", "(", "remains", "=", "rd_buf_write_remains", "(", "rbuf", ")", ")", "<", "min_size", ")", "rd_buf_alloc_segment", "(", "rbuf", ",", "min_size", "-", "remains", ",", "max_size", "?", "max_size", "-", "remains", ":", "0", ")", ";", "}'" ]

[ "Set", "up", "the", "iovec", "\\p", "iovs", "(of", "size", "\\p", "iov_max)", "with", "the", "readable" ]

[ "'size_t", "rd_slice_get_iov", "(", "const", "rd_slice_t", "*", "slice", ",", "struct", "iovec", "*", "iovs", ",", "size_t", "*", "iovcntp", ",", "size_t", "iov_max", ",", "size_t", "size_max", ")", "{", "const", "void", "*", "p", ";", "size_t", "rlen", ";", "size_t", "iovcnt", "=", "0", ";", "size_t", "sum", "=", "0", ";", "rd_slice_t", "copy", "=", "*", "slice", ";", "/*", "Use", "a", "copy", "of", "the", "slice", "so", "we", "dont", "*", "update", "the", "position", "for", "the", "caller.", "*/", "while", "(", "sum", "<", "size_max", "&&", "iovcnt", "<", "iov_max", "&&", "(", "rlen", "=", "rd_slice_reader", "(", "&", "copy", ",", "&", "p", ")", ")", ")", "{", "iovs", "[", "iovcnt", "]", ".", "iov_base", "=", "(", "void", "*", ")", "p", ";", "iovs", "[", "iovcnt", "++", "]", ".", "iov_len", "=", "rlen", ";", "sum", "+=", "rlen", ";", "}", "*", "iovcntp", "=", "iovcnt", ";", "return", "sum", ";", "}'" ]

[ "Compute", "CRC32C", "of", "segments", "starting", "at", "at", "buffer", "position", "\\p", "absof," ]

[ "'uint32_t", "rd_slice_crc32c", "(", "rd_slice_t", "*", "slice", ")", "{", "const", "void", "*", "p", ";", "size_t", "rlen", ";", "uint32_t", "crc", "=", "0", ";", "while", "(", "(", "rlen", "=", "rd_slice_reader", "(", "slice", ",", "&", "p", ")", ")", ")", "crc", "=", "crc32c", "(", "crc", ",", "(", "const", "char", "*", ")", "p", ",", "rlen", ")", ";", "return", "crc", ";", "}'" ]

[ "Restore", "the", "original", "\\p", "save_slice", "size", "from", "a", "previous", "call", "to" ]

[ "'void", "rd_slice_widen", "(", "rd_slice_t", "*", "slice", ",", "const", "rd_slice_t", "*", "save_slice", ")", "{", "slice", "->", "end", "=", "save_slice", "->", "end", ";", "}'" ]

[ "Initialize", "buffer,", "preallocating", "\\p", "fixed_seg_cnt", "segments" ]

[ "'void", "rd_buf_init", "(", "rd_buf_t", "*", "rbuf", ",", "size_t", "fixed_seg_cnt", ",", "size_t", "buf_size", ")", "{", "size_t", "totalloc", "=", "0", ";", "memset", "(", "rbuf", ",", "0", ",", "sizeof", "(", "*", "rbuf", ")", ")", ";", "TAILQ_INIT", "(", "&", "rbuf", "->", "rbuf_segments", ")", ";", "if", "(", "!", "fixed_seg_cnt", ")", "{", "assert", "(", "!", "buf_size", ")", ";", "return", ";", "}", "/*", "Pre-allocate", "memory", "for", "a", "fixed", "set", "of", "segments", "that", "are", "known", "*", "before-hand,", "to", "minimize", "the", "number", "of", "extra", "allocations", "*", "needed", "for", "well-known", "layouts", "(such", "as", "headers,", "etc)", "*/", "totalloc", "+=", "RD_ROUNDUP", "(", "sizeof", "(", "rd_segment_t", ")", ",", "8", ")", "*", "fixed_seg_cnt", ";", "/*", "Pre-allocate", "extra", "space", "for", "the", "backing", "buffer.", "*/", "totalloc", "+=", "buf_size", ";", "rbuf", "->", "rbuf_extra_size", "=", "totalloc", ";", "rbuf", "->", "rbuf_extra", "=", "rd_malloc", "(", "rbuf", "->", "rbuf_extra_size", ")", ";", "}'" ]

[ "Set", "up", "the", "iovecs", "in", "\\p", "iovs", "(of", "size", "\\p", "iov_max)", "with", "the", "writable" ]

[ "'size_t", "rd_buf_get_write_iov", "(", "const", "rd_buf_t", "*", "rbuf", ",", "struct", "iovec", "*", "iovs", ",", "size_t", "*", "iovcntp", ",", "size_t", "iov_max", ",", "size_t", "size_max", ")", "{", "const", "rd_segment_t", "*", "seg", ";", "size_t", "iovcnt", "=", "0", ";", "size_t", "sum", "=", "0", ";", "for", "(", "seg", "=", "rbuf", "->", "rbuf_wpos", ";", "seg", "&&", "iovcnt", "<", "iov_max", "&&", "sum", "<", "size_max", ";", "seg", "=", "TAILQ_NEXT", "(", "seg", ",", "seg_link", ")", ")", "{", "size_t", "len", ";", "void", "*", "p", ";", "len", "=", "rd_segment_write_remains", "(", "seg", ",", "&", "p", ")", ";", "if", "(", "unlikely", "(", "len", "==", "0", ")", ")", "continue;", "iovs", "[", "iovcnt", "]", ".", "iov_base", "=", "p", ";", "iovs", "[", "iovcnt", "++", "]", ".", "iov_len", "=", "len", ";", "sum", "+=", "len", ";", "}", "*", "iovcntp", "=", "iovcnt", ";", "return", "sum", ";", "}'" ]

[ "Read", "\\p", "size", "bytes", "from", "absolute", "slice", "offset", "\\p", "offset" ]

[ "'size_t", "rd_slice_peek", "(", "const", "rd_slice_t", "*", "slice", ",", "size_t", "offset", ",", "void", "*", "dst", ",", "size_t", "size", ")", "{", "rd_slice_t", "sub", "=", "*", "slice", ";", "if", "(", "unlikely", "(", "rd_slice_seek", "(", "&", "sub", ",", "offset", ")", "==", "-", "1", ")", ")", "return", "0", ";", "return", "rd_slice_read", "(", "&", "sub", ",", "dst", ",", "size", ")", ";", "}'" ]

[ "Same", "as", "rd_slice_narrow()", "but", "using", "a", "relative", "size", "\\p", "relsize" ]

[ "'int", "rd_slice_narrow_relative", "(", "rd_slice_t", "*", "slice", ",", "rd_slice_t", "*", "save_slice", ",", "size_t", "relsize", ")", "{", "return", "rd_slice_narrow", "(", "slice", ",", "save_slice", ",", "rd_slice_offset", "(", "slice", ")", "+", "relsize", ")", ";", "}'" ]

[ "Write", "\\p", "slice", "to", "\\p", "rbuf" ]

[ "'size_t", "rd_buf_write_slice", "(", "rd_buf_t", "*", "rbuf", ",", "rd_slice_t", "*", "slice", ")", "{", "const", "void", "*", "p", ";", "size_t", "rlen", ";", "size_t", "sum", "=", "0", ";", "while", "(", "(", "rlen", "=", "rd_slice_reader", "(", "slice", ",", "&", "p", ")", ")", ")", "{", "size_t", "r", ";", "r", "=", "rd_buf_write", "(", "rbuf", ",", "p", ",", "rlen", ")", ";", "rd_dassert", "(", "r", "!=", "0", ")", ";", "sum", "+=", "r", ";", "}", "return", "sum", ";", "}'" ]

[ "write_seek()", "and", "split()", "test" ]

[ "'static", "int", "do_unittest_write_split_seek", "(", "void", ")", "{", "rd_buf_t", "b", ";", "char", "ones", "[", "1024", "]", ";", "char", "twos", "[", "1024", "]", ";", "char", "threes", "[", "1024", "]", ";", "char", "fiftyfives", "[", "100", "]", ";", "/*", "0x55", "indicates", "\"untouched\"", "memory", "*/", "char", "buf", "[", "1024", "*", "3", "]", ";", "size_t", "r", ",", "<type", "ref=\"prev\"/>", "pos", ";", "rd_segment_t", "*", "seg", ",", "<type", "ref=\"prev\">", "*", "newseg", ";", "memset", "(", "ones", ",", "0x1", ",", "sizeof", "(", "ones", ")", ")", ";", "memset", "(", "twos", ",", "0x2", ",", "sizeof", "(", "twos", ")", ")", ";", "memset", "(", "threes", ",", "0x3", ",", "sizeof", "(", "threes", ")", ")", ";", "memset", "(", "fiftyfives", ",", "0x55", ",", "sizeof", "(", "fiftyfives", ")", ")", ";", "memset", "(", "buf", ",", "0x55", ",", "sizeof", "(", "buf", ")", ")", ";", "rd_buf_init", "(", "&", "b", ",", "0", ",", "0", ")", ";", "/*", "*", "Verify", "write", "*/", "r", "=", "rd_buf_write", "(", "&", "b", ",", "ones", ",", "400", ")", ";", "RD_UT_ASSERT", "(", "r", "==", "0", ",", "\"write()", "returned", "position", "%\"", "PRIusz", ",", "r", ")", ";", "pos", "=", "rd_buf_write_pos", "(", "&", "b", ")", ";", "RD_UT_ASSERT", "(", "pos", "==", "400", ",", "\"pos()", "returned", "position", "%\"", "PRIusz", ",", "pos", ")", ";", "do_unittest_read_verify", "(", "&", "b", ",", "0", ",", "400", ",", "ones", ")", ";", "/*", "*", "Seek", "and", "re-write", "*/", "r", "=", "rd_buf_write_seek", "(", "&", "b", ",", "200", ")", ";", "RD_UT_ASSERT", "(", "r", "==", "0", ",", "\"seek()", "failed\"", ")", ";", "pos", "=", "rd_buf_write_pos", "(", "&", "b", ")", ";", "RD_UT_ASSERT", "(", "pos", "==", "200", ",", "\"pos()", "returned", "position", "%\"", "PRIusz", ",", "pos", ")", ";", "r", "=", "rd_buf_write", "(", "&", "b", ",", "twos", ",", "100", ")", ";", "RD_UT_ASSERT", "(", "pos", "==", "200", ",", "\"write()", "returned", "position", "%\"", "PRIusz", ",", "r", ")", ";", "pos", "=", "rd_buf_write_pos", "(", "&", "b", ")", ";", "RD_UT_ASSERT", "(", "pos", "==", "200", "+", "100", ",", "\"pos()", "returned", "position", "%\"", "PRIusz", ",", "pos", ")", ";", "do_unittest_read_verify", "(", "&", "b", ",", "0", ",", "200", ",", "ones", ")", ";", "do_unittest_read_verify", "(", "&", "b", ",", "200", ",", "100", ",", "twos", ")", ";", "/*", "Make", "sure", "read()", "did", "not", "modify", "the", "write", "position.", "*/", "pos", "=", "rd_buf_write_pos", "(", "&", "b", ")", ";", "RD_UT_ASSERT", "(", "pos", "==", "200", "+", "100", ",", "\"pos()", "returned", "position", "%\"", "PRIusz", ",", "pos", ")", ";", "/*", "Split", "buffer,", "write", "position", "is", "now", "at", "split", "where", "writes", "*", "are", "not", "allowed", "(mid", "buffer).", "*/", "seg", "=", "rd_buf_get_segment_at_offset", "(", "&", "b", ",", "NULL", ",", "50", ")", ";", "RD_UT_ASSERT", "(", "seg", "->", "seg_of", "!=", "0", ",", "\"assumed", "mid-segment\"", ")", ";", "newseg", "=", "rd_segment_split", "(", "&", "b", ",", "seg", ",", "50", ")", ";", "rd_buf_append_segment", "(", "&", "b", ",", "newseg", ")", ";", "seg", "=", "rd_buf_get_segment_at_offset", "(", "&", "b", ",", "NULL", ",", "50", ")", ";", "RD_UT_ASSERT", "(", "seg", "!=", "NULL", ",", "\"seg\"", ")", ";", "RD_UT_ASSERT", "(", "seg", "==", "newseg", ",", "\"newseg", "%p,", "seg", "%p\"", ",", "newseg", ",", "seg", ")", ";", "RD_UT_ASSERT", "(", "seg", "->", "seg_of", ">", "0", ",", "\"assumed", "beginning", "of", "segment,", "got", "%\"", "PRIusz", ",", "seg", "->", "seg_of", ")", ";", "pos", "=", "rd_buf_write_pos", "(", "&", "b", ")", ";", "RD_UT_ASSERT", "(", "pos", "==", "200", "+", "100", ",", "\"pos()", "returned", "position", "%\"", "PRIusz", ",", "pos", ")", ";", "/*", "Re-verify", "that", "nothing", "changed", "*/", "do_unittest_read_verify", "(", "&", "b", ",", "0", ",", "200", ",", "ones", ")", ";", "do_unittest_read_verify", "(", "&", "b", ",", "200", ",", "100", ",", "twos", ")", ";", "/*", "Do", "a", "write", "seek", "at", "buffer", "boundary,", "sub-sequent", "buffers", "should", "*", "be", "destroyed.", "*/", "r", "=", "rd_buf_write_seek", "(", "&", "b", ",", "50", ")", ";", "RD_UT_ASSERT", "(", "r", "==", "0", ",", "\"seek()", "failed\"", ")", ";", "do_unittest_read_verify", "(", "&", "b", ",", "0", ",", "50", ",", "ones", ")", ";", "rd_buf_destroy", "(", "&", "b", ")", ";", "RD_UT_PASS", "()", ";", "}'" ]

[ "Free", "memory", "associated", "with", "the", "\\p", "rbuf,", "but", "not", "the", "rbuf", "itself" ]

[ "'void", "rd_buf_destroy", "(", "rd_buf_t", "*", "rbuf", ")", "{", "rd_segment_t", "*", "seg", ",", "<type", "ref=\"prev\">", "*", "tmp", ";", "#", "if", "ENABLE_DEVEL", "/*", "FIXME", "*/", "if", "(", "rbuf", "->", "rbuf_len", ">", "0", "&&", "0", ")", "{", "size_t", "overalloc", "=", "rbuf", "->", "rbuf_size", "-", "rbuf", "->", "rbuf_len", ";", "float", "fill_grade", "=", "(", "float", ")", "rbuf", "->", "rbuf_len", "/", "(", "float", ")", "rbuf", "->", "rbuf_size", ";", "printf", "(", "\"fill", "grade:", "%.2f%%", "(%\"", "PRIusz", "\"", "bytes", "over-allocated)\\\"", ",", "fill_grade", "*", "100.0f", ",", "overalloc", ")", ";", "}", "#", "endif", "TAILQ_FOREACH_SAFE", "(", "seg", ",", "&rbuf->rbuf_segments", ",", "seg_link", ",", "tmp", ")", "{", "rd_segment_destroy", "(", "seg", ")", ";", "}", "if", "(", "rbuf", "->", "rbuf_extra", ")", "rd_free", "(", "rbuf", "->", "rbuf_extra", ")", ";", "}'" ]

[ "Get", "a", "preallocated", "segment", "if", "available,", "or", "allocate", "a", "new" ]

[ "'static", "rd_segment_t", "*", "rd_buf_alloc_segment0", "(", "rd_buf_t", "*", "rbuf", ",", "size_t", "size", ")", "{", "rd_segment_t", "*", "seg", ";", "/*", "See", "if", "there", "is", "enough", "room", "in", "the", "extra", "buffer", "for", "*", "allocating", "the", "segment", "header", "and", "the", "buffer,", "*", "or", "just", "the", "segment", "header,", "else", "fall", "back", "to", "malloc.", "*/", "if", "(", "(", "seg", "=", "extra_alloc", "(", "rbuf", ",", "sizeof", "(", "*", "seg", ")", "+", "size", ")", ")", ")", "{", "rd_segment_init", "(", "seg", ",", "size", ">", "0", "?", "seg", "+", "1", ":", "NULL", ",", "size", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "seg", "=", "extra_alloc", "(", "rbuf", ",", "sizeof", "(", "*", "seg", ")", ")", ")", ")", "{", "rd_segment_init", "(", "seg", ",", "size", ">", "0", "?", "rd_malloc", "(", "size", ")", ":", "NULL", ",", "size", ")", ";", "if", "(", "size", ">", "0", ")", "seg", "->", "seg_free", "=", "rd_free", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "(", "seg", "=", "rd_malloc", "(", "sizeof", "(", "*", "seg", ")", "+", "size", ")", ")", ")", "{", "rd_segment_init", "(", "seg", ",", "size", ">", "0", "?", "seg", "+", "1", ":", "NULL", ",", "size", ")", ";", "seg", "->", "seg_flags", "|=", "RD_SEGMENT_F_FREE", ";", "}", "else", "rd_assert", "(", "!", "*", "\"segment", "allocation", "failure\"", ")", ";", "return", "seg", ";", "}'" ]

[ "Initialize", "a", "new", "slice", "of", "\\p", "size", "bytes", "starting", "at", "\\p", "seg", "with" ]

[ "'int", "rd_slice_init_seg", "(", "rd_slice_t", "*", "slice", ",", "const", "rd_buf_t", "*", "rbuf", ",", "const", "rd_segment_t", "*", "seg", ",", "size_t", "rof", ",", "size_t", "size", ")", "{", "/*", "Verify", "that", "\\\\p", "size", "bytes", "are", "indeed", "available", "in", "the", "buffer.", "*/", "if", "(", "unlikely", "(", "rbuf", "->", "rbuf_len", "<", "(", "seg", "->", "seg_absof", "+", "rof", "+", "size", ")", ")", ")", "return", "-", "1", ";", "slice", "->", "buf", "=", "rbuf", ";", "slice", "->", "seg", "=", "seg", ";", "slice", "->", "rof", "=", "rof", ";", "slice", "->", "start", "=", "seg", "->", "seg_absof", "+", "rof", ";", "slice", "->", "end", "=", "slice", "->", "start", "+", "size", ";", "rd_assert", "(", "seg", "->", "seg_absof", "+", "rof", ">=", "slice", "->", "start", "&&", "seg", "->", "seg_absof", "+", "rof", "<=", "slice", "->", "end", ")", ";", "rd_assert", "(", "slice", "->", "end", "<=", "rd_buf_len", "(", "rbuf", ")", ")", ";", "return", "0", ";", "}'" ]

[ "Sets", "the", "slice's", "read", "position" ]

[ "'int", "rd_slice_seek", "(", "rd_slice_t", "*", "slice", ",", "size_t", "offset", ")", "{", "const", "rd_segment_t", "*", "seg", ";", "size_t", "absof", "=", "slice", "->", "start", "+", "offset", ";", "if", "(", "unlikely", "(", "absof", ">=", "slice", "->", "end", ")", ")", "return", "-", "1", ";", "seg", "=", "rd_buf_get_segment_at_offset", "(", "slice", "->", "buf", ",", "slice", "->", "seg", ",", "absof", ")", ";", "rd_assert", "(", "seg", ")", ";", "slice", "->", "seg", "=", "seg", ";", "slice", "->", "rof", "=", "absof", "-", "seg", "->", "seg_absof", ";", "rd_assert", "(", "seg", "->", "seg_absof", "+", "slice", "->", "rof", ">=", "slice", "->", "start", "&&", "seg", "->", "seg_absof", "+", "slice", "->", "rof", "<=", "slice", "->", "end", ")", ";", "return", "0", ";", "}'" ]

[ "Read", "a", "varintencoded", "unsigned", "integer", "from", "\\p", "slice," ]

[ "\"size_t", "rd_slice_read_uvarint", "(", "rd_slice_t", "*", "slice", ",", "uint64_t", "*", "nump", ")", "{", "uint64_t", "num", "=", "0", ";", "int", "shift", "=", "0", ";", "size_t", "rof", "=", "slice", "->", "rof", ";", "const", "rd_segment_t", "*", "seg", ";", "/*", "Traverse", "segments,", "byte", "for", "byte,", "until", "varint", "is", "decoded", "*", "or", "no", "more", "segments", "available", "(underflow).", "*/", "for", "(", "seg", "=", "slice", "->", "seg", ";", "seg", ";", "seg", "=", "TAILQ_NEXT", "(", "seg", ",", "seg_link", ")", ")", "{", "for", "(", ";", "rof", "<", "seg", "->", "seg_of", ";", "rof", "++", ")", "{", "unsigned", "char", "oct", ";", "if", "(", "unlikely", "(", "seg", "->", "seg_absof", "+", "rof", ">=", "slice", "->", "end", ")", ")", "return", "0", ";", "/*", "Underflow", "*/", "oct", "=", "*", "(", "const", "unsigned", "char", "*", ")", "(", "seg", "->", "seg_p", "+", "rof", ")", ";", "num", "|=", "(", "uint64_t", ")", "(", "oct", "&", "0x7f", ")", "<<", "shift", ";", "shift", "+=", "7", ";", "if", "(", "!", "(", "oct", "&", "0x80", ")", ")", "{", "/*", "Done:", "no", "more", "bytes", "expected", "*/", "*", "nump", "=", "num", ";", "/*", "Update", "slice's", "read", "pointer", "and", "offset", "*/", "if", "(", "slice", "->", "seg", "!=", "seg", ")", "slice", "->", "seg", "=", "seg", ";", "slice", "->", "rof", "=", "rof", "+", "1", ";", "/*", "including", "the", "+1", "byte", "*", "that", "was", "just", "read", "*/", "return", "shift", "/", "7", ";", "}", "}", "rof", "=", "0", ";", "}", "return", "0", ";", "/*", "Underflow", "*/", "}\"" ]

[ "Read", "\\p", "size", "bytes", "from", "current", "read", "position," ]

[ "'size_t", "rd_slice_read", "(", "rd_slice_t", "*", "slice", ",", "void", "*", "dst", ",", "size_t", "size", ")", "{", "size_t", "remains", "=", "size", ";", "char", "*", "d", "=", "(", "char", "*", ")", "dst", ";", "/*", "Possibly", "NULL", "*/", "size_t", "rlen", ";", "const", "void", "*", "p", ";", "size_t", "orig_end", "=", "slice", "->", "end", ";", "if", "(", "unlikely", "(", "rd_slice_remains", "(", "slice", ")", "<", "size", ")", ")", "return", "0", ";", "/*", "Temporarily", "shrink", "slice", "to", "offset", "+", "\\\\p", "size", "*/", "slice", "->", "end", "=", "rd_slice_abs_offset", "(", "slice", ")", "+", "size", ";", "while", "(", "(", "rlen", "=", "rd_slice_reader", "(", "slice", ",", "&", "p", ")", ")", ")", "{", "rd_dassert", "(", "remains", ">=", "rlen", ")", ";", "if", "(", "dst", ")", "{", "memcpy", "(", "d", ",", "p", ",", "rlen", ")", ";", "d", "+=", "rlen", ";", "}", "remains", "-=", "rlen", ";", "}", "rd_dassert", "(", "remains", "==", "0", ")", ";", "/*", "Restore", "original", "size", "*/", "slice", "->", "end", "=", "orig_end", ";", "return", "size", ";", "}'" ]

[ "Allocate", "between", "\\p", "min_size" ]

[ "'static", "rd_segment_t", "*", "rd_buf_alloc_segment", "(", "rd_buf_t", "*", "rbuf", ",", "size_t", "min_size", ",", "size_t", "max_size", ")", "{", "rd_segment_t", "*", "seg", ";", "/*", "Over-allocate", "if", "allowed.", "*/", "if", "(", "min_size", "!=", "max_size", "||", "max_size", "==", "0", ")", "max_size", "=", "RD_MAX", "(", "sizeof", "(", "*", "seg", ")", "*", "4", ",", "RD_MAX", "(", "min_size", "*", "2", ",", "rbuf", "->", "rbuf_size", "/", "2", ")", ")", ";", "seg", "=", "rd_buf_alloc_segment0", "(", "rbuf", ",", "max_size", ")", ";", "rd_buf_append_segment", "(", "rbuf", ",", "seg", ")", ";", "return", "seg", ";", "}'" ]

[ "Write", "\\p", "payload", "of", "\\p", "size", "bytes", "to", "current", "position" ]

[ "'size_t", "rd_buf_write", "(", "rd_buf_t", "*", "rbuf", ",", "const", "void", "*", "payload", ",", "size_t", "size", ")", "{", "size_t", "remains", "=", "size", ";", "size_t", "initial_absof", ";", "const", "char", "*", "psrc", "=", "(", "const", "char", "*", ")", "payload", ";", "initial_absof", "=", "rbuf", "->", "rbuf_len", ";", "/*", "Ensure", "enough", "space", "by", "pre-allocating", "segments.", "*/", "rd_buf_write_ensure", "(", "rbuf", ",", "size", ",", "0", ")", ";", "while", "(", "remains", ">", "0", ")", "{", "void", "*", "p", ";", "rd_segment_t", "*", "seg", "=", "NULL", ";", "size_t", "segremains", "=", "rd_buf_get_writable0", "(", "rbuf", ",", "&", "seg", ",", "&", "p", ")", ";", "size_t", "wlen", "=", "RD_MIN", "(", "remains", ",", "segremains", ")", ";", "rd_dassert", "(", "seg", "==", "rbuf", "->", "rbuf_wpos", ")", ";", "rd_dassert", "(", "wlen", ">", "0", ")", ";", "rd_dassert", "(", "seg", "->", "seg_p", "+", "seg", "->", "seg_of", "<=", "(", "char", "*", ")", "p", "&&", "(", "char", "*", ")", "p", "<", "seg", "->", "seg_p", "+", "seg", "->", "seg_size", ")", ";", "if", "(", "payload", ")", "{", "memcpy", "(", "p", ",", "psrc", ",", "wlen", ")", ";", "psrc", "+=", "wlen", ";", "}", "seg", "->", "seg_of", "+=", "wlen", ";", "rbuf", "->", "rbuf_len", "+=", "wlen", ";", "remains", "-=", "wlen", ";", "}", "rd_assert", "(", "remains", "==", "0", ")", ";", "return", "initial_absof", ";", "}'" ]

[ "CRC32", "calculation", "of", "slice" ]

[ "'uint32_t", "rd_slice_crc32", "(", "rd_slice_t", "*", "slice", ")", "{", "rd_crc32_t", "crc", ";", "const", "void", "*", "p", ";", "size_t", "rlen", ";", "crc", "=", "rd_crc32_init", "()", ";", "while", "(", "(", "rlen", "=", "rd_slice_reader", "(", "slice", ",", "&", "p", ")", ")", ")", "crc", "=", "rd_crc32_update", "(", "crc", ",", "p", ",", "rlen", ")", ";", "return", "(", "uint32_t", ")", "rd_crc32_finalize", "(", "crc", ")", ";", "}'" ]

[ "Inserts", "server", "in", "to", "the", "db" ]

[ "'static", "int", "__DBInsertServer", "(", "const", "char", "*", "server", ",", "const", "char", "*", "info", ",", "const", "DBConfig", "*", "db_config", ")", "{", "char", "sql_query", "[", "OS_SIZE_1024", "]", ";", "memset", "(", "sql_query", ",", "\\'\\\\0\\'", ",", "OS_SIZE_1024", ")", ";", "/*", "Check", "if", "the", "server", "is", "present", "*/", "snprintf", "(", "sql_query", ",", "OS_SIZE_1024", "-", "1", ",", "\"SELECT", "id", "from", "server", "where", "hostname", "=", "\\'%s\\'\"", ",", "server", ")", ";", "/*", "If", "not", "present,", "insert", "*/", "if", "(", "osdb_query_select", "(", "db_config", "->", "conn", ",", "sql_query", ")", "==", "0", ")", "{", "snprintf", "(", "sql_query", ",", "OS_SIZE_1024", "-", "1", ",", "\"INSERT", "INTO", "\"", "\"server(last_contact,", "version,", "hostname,", "information)", "\"", "\"VALUES", "(\\'%u\\',", "\\'%s\\',", "\\'%s\\',", "\\'%s\\')\"", ",", "(", "unsigned", "int", ")", "time", "(", "0", ")", ",", "__version", ",", "server", ",", "info", ")", ";", "if", "(", "!", "osdb_query_insert", "(", "db_config", "->", "conn", ",", "sql_query", ")", ")", "{", "merror", "(", "DB_GENERROR", ",", "ARGV0", ")", ";", "}", "}", "/*", "If", "present,", "update", "it", "*/", "else", "{", "snprintf", "(", "sql_query", ",", "OS_SIZE_1024", "-", "1", ",", "\"UPDATE", "server", "SET", "\"", "\"last_contact=\\'%u\\',version=\\'%s\\',information=\\'%s\\'", "\"", "\"WHERE", "hostname", "=", "\\'%s\\'\"", ",", "(", "unsigned", "int", ")", "time", "(", "0", ")", ",", "__version", ",", "info", ",", "server", ")", ";", "if", "(", "!", "osdb_query_insert", "(", "db_config", "->", "conn", ",", "sql_query", ")", ")", "{", "merror", "(", "DB_GENERROR", ",", "ARGV0", ")", ";", "}", "}", "return", "(", "0", ")", ";", "}'" ]

[ "Convert", "TValue", "to", "C", "type", "(store)" ]

[ "'static", "TRef", "crec_ct_tv", "(", "jit_State", "*", "J", ",", "CType", "*", "d", ",", "TRef", "dp", ",", "TRef", "sp", ",", "cTValue", "*", "sval", ")", "{", "CTState", "*", "cts", "=", "ctype_ctsG", "(", "J2G", "(", "J", ")", ")", ";", "CTypeID", "sid", "=", "CTID_P_VOID", ";", "void", "*", "svisnz", "=", "0", ";", "CType", "*", "s", ";", "if", "(", "LJ_LIKELY", "(", "tref_isinteger", "(", "sp", ")", ")", ")", "{", "sid", "=", "CTID_INT32", ";", "svisnz", "=", "(", "void", "*", ")", "(", "intptr_t", ")", "(", "tvisint", "(", "sval", ")", "?", "(", "intV", "(", "sval", ")", "!=", "0", ")", ":", "!", "tviszero", "(", "sval", ")", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tref_isnum", "(", "sp", ")", ")", "{", "sid", "=", "CTID_DOUBLE", ";", "svisnz", "=", "(", "void", "*", ")", "(", "intptr_t", ")", "(", "tvisint", "(", "sval", ")", "?", "(", "intV", "(", "sval", ")", "!=", "0", ")", ":", "!", "tviszero", "(", "sval", ")", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tref_isbool", "(", "sp", ")", ")", "{", "sp", "=", "lj_ir_kint", "(", "J", ",", "tref_istrue", "(", "sp", ")", "?", "1", ":", "0", ")", ";", "sid", "=", "CTID_BOOL", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tref_isnil", "(", "sp", ")", ")", "{", "sp", "=", "lj_ir_kptr", "(", "J", ",", "NULL", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tref_isudata", "(", "sp", ")", ")", "{", "GCudata", "*", "ud", "=", "udataV", "(", "sval", ")", ";", "if", "(", "ud", "->", "udtype", "==", "UDTYPE_IO_FILE", ")", "{", "TRef", "tr", "=", "emitir", "(", "IRT", "(", "IR_FLOAD", ",", "IRT_U8", ")", ",", "sp", ",", "IRFL_UDATA_UDTYPE", ")", ";", "emitir", "(", "IRTGI", "(", "IR_EQ", ")", ",", "tr", ",", "lj_ir_kint", "(", "J", ",", "UDTYPE_IO_FILE", ")", ")", ";", "sp", "=", "emitir", "(", "IRT", "(", "IR_FLOAD", ",", "IRT_PTR", ")", ",", "sp", ",", "IRFL_UDATA_FILE", ")", ";", "}", "else", "{", "sp", "=", "emitir", "(", "IRT", "(", "IR_ADD", ",", "IRT_PTR", ")", ",", "sp", ",", "lj_ir_kintp", "(", "J", ",", "sizeof", "(", "GCudata", ")", ")", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tref_isstr", "(", "sp", ")", ")", "{", "if", "(", "ctype_isenum", "(", "d", "->", "info", ")", ")", "{", "/*", "Match", "string", "against", "enum", "constant.", "*/", "GCstr", "*", "str", "=", "strV", "(", "sval", ")", ";", "CTSize", "ofs", ";", "CType", "*", "cct", "=", "lj_ctype_getfield", "(", "cts", ",", "d", ",", "str", ",", "&", "ofs", ")", ";", "/*", "Specialize", "to", "the", "name", "of", "the", "enum", "constant.", "*/", "emitir", "(", "IRTG", "(", "IR_EQ", ",", "IRT_STR", ")", ",", "sp", ",", "lj_ir_kstr", "(", "J", ",", "str", ")", ")", ";", "if", "(", "cct", "&&", "ctype_isconstval", "(", "cct", "->", "info", ")", ")", "{", "lua_assert", "(", "ctype_child", "(", "cts", ",", "cct", ")", "->", "size", "==", "4", ")", ";", "svisnz", "=", "(", "void", "*", ")", "(", "intptr_t", ")", "(", "ofs", "!=", "0", ")", ";", "sp", "=", "lj_ir_kint", "(", "J", ",", "(", "int32_t", ")", "ofs", ")", ";", "sid", "=", "ctype_cid", "(", "cct", "->", "info", ")", ";", "}", "/*", "else:", "interpreter", "will", "throw.", "*/", "}", "<if", "type=\"elseif\">", "else", "if", "(", "ctype_isrefarray", "(", "d", "->", "info", ")", ")", "{", "/*", "Copy", "string", "to", "array.", "*/", "lj_trace_err", "(", "J", ",", "LJ_TRERR_BADTYPE", ")", ";", "/*", "NYI", "*/", "}", "else", "{", "/*", "Otherwise", "pass", "the", "string", "data", "as", "a", "const", "char[].", "*/", "/*", "Don\\'t", "use", "STRREF.", "It", "folds", "with", "SNEW,", "which", "loses", "the", "trailing", "NUL.", "*/", "sp", "=", "emitir", "(", "IRT", "(", "IR_ADD", ",", "IRT_PTR", ")", ",", "sp", ",", "lj_ir_kintp", "(", "J", ",", "sizeof", "(", "GCstr", ")", ")", ")", ";", "sid", "=", "CTID_A_CCHAR", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tref_islightud", "(", "sp", ")", ")", "{", "#", "if", "LJ_64", "sp", "=", "emitir", "(", "IRT", "(", "IR_BAND", ",", "IRT_P64", ")", ",", "sp", ",", "lj_ir_kint64", "(", "J", ",", "U64x", "(", "00007fff", ",", "ffffffff", ")", ")", ")", ";", "#", "endif", "}", "else", "{", "/*", "NYI:", "tref_istab(sp).", "*/", "IRType", "t", ";", "sid", "=", "argv2cdata", "(", "J", ",", "sp", ",", "sval", ")", "->", "ctypeid", ";", "s", "=", "ctype_raw", "(", "cts", ",", "sid", ")", ";", "svisnz", "=", "cdataptr", "(", "cdataV", "(", "sval", ")", ")", ";", "if", "(", "ctype_isfunc", "(", "s", "->", "info", ")", ")", "{", "sid", "=", "lj_ctype_intern", "(", "cts", ",", "CTINFO", "(", "CT_PTR", ",", "CTALIGN_PTR", "|", "sid", ")", ",", "CTSIZE_PTR", ")", ";", "s", "=", "ctype_get", "(", "cts", ",", "sid", ")", ";", "t", "=", "IRT_PTR", ";", "}", "else", "{", "t", "=", "crec_ct2irt", "(", "cts", ",", "s", ")", ";", "}", "if", "(", "ctype_isptr", "(", "s", "->", "info", ")", ")", "{", "sp", "=", "emitir", "(", "IRT", "(", "IR_FLOAD", ",", "t", ")", ",", "sp", ",", "IRFL_CDATA_PTR", ")", ";", "if", "(", "ctype_isref", "(", "s", "->", "info", ")", ")", "{", "svisnz", "=", "*", "(", "void", "*", "*", ")", "svisnz", ";", "s", "=", "ctype_rawchild", "(", "cts", ",", "s", ")", ";", "if", "(", "ctype_isenum", "(", "s", "->", "info", ")", ")", "s", "=", "ctype_child", "(", "cts", ",", "s", ")", ";", "t", "=", "crec_ct2irt", "(", "cts", ",", "s", ")", ";", "}", "else", "{", "goto", "doconv", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "t", "==", "IRT_I64", "||", "t", "==", "IRT_U64", ")", "{", "sp", "=", "emitir", "(", "IRT", "(", "IR_FLOAD", ",", "t", ")", ",", "sp", ",", "IRFL_CDATA_INT64", ")", ";", "lj_needsplit", "(", "J", ")", ";", "goto", "doconv", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "t", "==", "IRT_INT", "||", "t", "==", "IRT_U32", ")", "{", "if", "(", "ctype_isenum", "(", "s", "->", "info", ")", ")", "s", "=", "ctype_child", "(", "cts", ",", "s", ")", ";", "sp", "=", "emitir", "(", "IRT", "(", "IR_FLOAD", ",", "t", ")", ",", "sp", ",", "IRFL_CDATA_INT", ")", ";", "goto", "doconv", ";", "}", "else", "{", "sp", "=", "emitir", "(", "IRT", "(", "IR_ADD", ",", "IRT_PTR", ")", ",", "sp", ",", "lj_ir_kintp", "(", "J", ",", "sizeof", "(", "GCcdata", ")", ")", ")", ";", "}", "if", "(", "ctype_isnum", "(", "s", "->", "info", ")", "&&", "t", "!=", "IRT_CDATA", ")", "sp", "=", "emitir", "(", "IRT", "(", "IR_XLOAD", ",", "t", ")", ",", "sp", ",", "0", ")", ";", "/*", "Load", "number", "value.", "*/", "goto", "doconv", ";", "}", "s", "=", "ctype_get", "(", "cts", ",", "sid", ")", ";", "doconv", ":", "if", "(", "ctype_isenum", "(", "d", "->", "info", ")", ")", "d", "=", "ctype_child", "(", "cts", ",", "d", ")", ";", "return", "crec_ct_ct", "(", "J", ",", "d", ",", "s", ",", "dp", ",", "sp", ",", "svisnz", ")", ";", "}'" ]

[ "Record", "setting", "a", "finalizer" ]

[ "'static", "void", "crec_finalizer", "(", "jit_State", "*", "J", ",", "TRef", "trcd", ",", "TRef", "trfin", ",", "cTValue", "*", "fin", ")", "{", "if", "(", "tvisgcv", "(", "fin", ")", ")", "{", "if", "(", "!", "trfin", ")", "trfin", "=", "lj_ir_kptr", "(", "J", ",", "gcval", "(", "fin", ")", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "tvisnil", "(", "fin", ")", ")", "{", "trfin", "=", "lj_ir_kptr", "(", "J", ",", "NULL", ")", ";", "}", "else", "{", "lj_trace_err", "(", "J", ",", "LJ_TRERR_BADTYPE", ")", ";", "}", "lj_ir_call", "(", "J", ",", "IRCALL_lj_cdata_setfin", ",", "trcd", ",", "trfin", ",", "lj_ir_kint", "(", "J", ",", "(", "int32_t", ")", "itype", "(", "fin", ")", ")", ")", ";", "J", "->", "needsnap", "=", "1", ";", "}'" ]

[ "C", "library", "namespace", "metamethods" ]

[ "'void", "LJ_FASTCALL", "recff_clib_index", "(", "jit_State", "*", "J", ",", "RecordFFData", "*", "rd", ")", "{", "CTState", "*", "cts", "=", "ctype_ctsG", "(", "J2G", "(", "J", ")", ")", ";", "if", "(", "tref_isudata", "(", "J", "->", "base", "[", "0", "]", ")", "&&", "tref_isstr", "(", "J", "->", "base", "[", "1", "]", ")", "&&", "udataV", "(", "&", "rd", "->", "argv", "[", "0", "]", ")", "->", "udtype", "==", "UDTYPE_FFI_CLIB", ")", "{", "CLibrary", "*", "cl", "=", "(", "CLibrary", "*", ")", "uddata", "(", "udataV", "(", "&", "rd", "->", "argv", "[", "0", "]", ")", ")", ";", "GCstr", "*", "name", "=", "strV", "(", "&", "rd", "->", "argv", "[", "1", "]", ")", ";", "CType", "*", "ct", ";", "CTypeID", "id", "=", "lj_ctype_getname", "(", "cts", ",", "&", "ct", ",", "name", ",", "CLNS_INDEX", ")", ";", "cTValue", "*", "tv", "=", "lj_tab_getstr", "(", "cl", "->", "cache", ",", "name", ")", ";", "rd", "->", "nres", "=", "rd", "->", "data", ";", "if", "(", "id", "&&", "tv", "&&", "!", "tvisnil", "(", "tv", ")", ")", "{", "/*", "Specialize", "to", "the", "symbol", "name", "and", "make", "the", "result", "a", "constant.", "*/", "emitir", "(", "IRTG", "(", "IR_EQ", ",", "IRT_STR", ")", ",", "J", "->", "base", "[", "1", "]", ",", "lj_ir_kstr", "(", "J", ",", "name", ")", ")", ";", "if", "(", "ctype_isconstval", "(", "ct", "->", "info", ")", ")", "{", "if", "(", "ct", "->", "size", ">=", "0x80000000u", "&&", "(", "ctype_child", "(", "cts", ",", "ct", ")", "->", "info", "&", "CTF_UNSIGNED", ")", ")", "J", "->", "base", "[", "0", "]", "=", "lj_ir_knum", "(", "J", ",", "(", "lua_Number", ")", "(", "uint32_t", ")", "ct", "->", "size", ")", ";", "else", "J", "->", "base", "[", "0", "]", "=", "lj_ir_kint", "(", "J", ",", "(", "int32_t", ")", "ct", "->", "size", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "ctype_isextern", "(", "ct", "->", "info", ")", ")", "{", "CTypeID", "sid", "=", "ctype_cid", "(", "ct", "->", "info", ")", ";", "void", "*", "sp", "=", "*", "(", "void", "*", "*", ")", "cdataptr", "(", "cdataV", "(", "tv", ")", ")", ";", "TRef", "ptr", ";", "ct", "=", "ctype_raw", "(", "cts", ",", "sid", ")", ";", "if", "(", "LJ_64", "&&", "!", "checkptr32", "(", "sp", ")", ")", "ptr", "=", "lj_ir_kintp", "(", "J", ",", "(", "uintptr_t", ")", "sp", ")", ";", "else", "ptr", "=", "lj_ir_kptr", "(", "J", ",", "sp", ")", ";", "if", "(", "rd", "->", "data", ")", "{", "J", "->", "base", "[", "0", "]", "=", "crec_tv_ct", "(", "J", ",", "ct", ",", "sid", ",", "ptr", ")", ";", "}", "else", "{", "J", "->", "needsnap", "=", "1", ";", "crec_ct_tv", "(", "J", ",", "ct", ",", "ptr", ",", "J", "->", "base", "[", "2", "]", ",", "&", "rd", "->", "argv", "[", "2", "]", ")", ";", "}", "}", "else", "{", "J", "->", "base", "[", "0", "]", "=", "lj_ir_kgc", "(", "J", ",", "obj2gco", "(", "cdataV", "(", "tv", ")", ")", ",", "IRT_CDATA", ")", ";", "}", "}", "else", "{", "lj_trace_err", "(", "J", ",", "LJ_TRERR_NOCACHE", ")", ";", "}", "}", "/*", "else:", "interpreter", "will", "throw.", "*/", "}'" ]

[ "Specialize", "to", "the", "CTypeID", "held", "by", "a", "cdata", "constructor" ]

[ "'static", "CTypeID", "crec_constructor", "(", "jit_State", "*", "J", ",", "GCcdata", "*", "cd", ",", "TRef", "tr", ")", "{", "CTypeID", "id", ";", "lua_assert", "(", "tref_iscdata", "(", "tr", ")", "&&", "cd", "->", "ctypeid", "==", "CTID_CTYPEID", ")", ";", "id", "=", "*", "(", "CTypeID", "*", ")", "cdataptr", "(", "cd", ")", ";", "tr", "=", "emitir", "(", "IRT", "(", "IR_FLOAD", ",", "IRT_INT", ")", ",", "tr", ",", "IRFL_CDATA_INT", ")", ";", "emitir", "(", "IRTG", "(", "IR_EQ", ",", "IRT_INT", ")", ",", "tr", ",", "lj_ir_kint", "(", "J", ",", "(", "int32_t", ")", "id", ")", ")", ";", "return", "id", ";", "}'" ]

[ "Verify", "signed", "receipt", "after", "it", "has", "already", "passed", "normal", "CMS", "verify" ]

[ "'int", "cms_Receipt_verify", "(", "CMS_ContentInfo", "*", "cms", ",", "CMS_ContentInfo", "*", "req_cms", ")", "{", "int", "r", "=", "0", ",", "<type", "ref=\"prev\"/>", "i", ";", "CMS_ReceiptRequest", "*", "rr", "=", "NULL", ";", "CMS_Receipt", "*", "rct", "=", "NULL", ";", "STACK_OF", "(", "CMS_SignerInfo", ")", "*", "sis", ",", "*", "osis", ";", "CMS_SignerInfo", "*", "si", ",", "<type", "ref=\"prev\">", "*", "osi", "=", "NULL", ";", "ASN1_OCTET_STRING", "*", "msig", ",", "<type", "ref=\"prev\">", "*", "*", "pcont", ";", "ASN1_OBJECT", "*", "octype", ";", "unsigned", "char", "dig", "[", "EVP_MAX_MD_SIZE", "]", ";", "unsigned", "int", "diglen", ";", "/*", "Get", "SignerInfos,", "also", "checks", "SignedData", "content", "type", "*/", "osis", "=", "CMS_get0_SignerInfos", "(", "req_cms", ")", ";", "sis", "=", "CMS_get0_SignerInfos", "(", "cms", ")", ";", "if", "(", "!", "osis", "||", "!", "sis", ")", "goto", "err", ";", "if", "(", "sk_CMS_SignerInfo_num", "(", "sis", ")", "!=", "1", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_NEED_ONE_SIGNER", ")", ";", "goto", "err", ";", "}", "/*", "Check", "receipt", "content", "type", "*/", "if", "(", "OBJ_obj2nid", "(", "CMS_get0_eContentType", "(", "cms", ")", ")", "!=", "NID_id_smime_ct_receipt", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_NOT_A_SIGNED_RECEIPT", ")", ";", "goto", "err", ";", "}", "/*", "Extract", "and", "decode", "receipt", "content", "*/", "pcont", "=", "CMS_get0_content", "(", "cms", ")", ";", "if", "(", "!", "pcont", "||", "!", "*", "pcont", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_NO_CONTENT", ")", ";", "goto", "err", ";", "}", "rct", "=", "ASN1_item_unpack", "(", "*", "pcont", ",", "ASN1_ITEM_rptr", "(", "CMS_Receipt", ")", ")", ";", "if", "(", "!", "rct", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_RECEIPT_DECODE_ERROR", ")", ";", "goto", "err", ";", "}", "/*", "Locate", "original", "request", "*/", "for", "(", "i", "=", "0", ";", "i", "<", "sk_CMS_SignerInfo_num", "(", "osis", ")", ";", "i", "++", ")", "{", "osi", "=", "sk_CMS_SignerInfo_value", "(", "osis", ",", "i", ")", ";", "if", "(", "!", "ASN1_STRING_cmp", "(", "osi", "->", "signature", ",", "rct", "->", "originatorSignatureValue", ")", ")", "break;", "}", "if", "(", "i", "==", "sk_CMS_SignerInfo_num", "(", "osis", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_NO_MATCHING_SIGNATURE", ")", ";", "goto", "err", ";", "}", "si", "=", "sk_CMS_SignerInfo_value", "(", "sis", ",", "0", ")", ";", "/*", "Get", "msgSigDigest", "value", "and", "compare", "*/", "msig", "=", "CMS_signed_get0_data_by_OBJ", "(", "si", ",", "OBJ_nid2obj", "(", "NID_id_smime_aa_msgSigDigest", ")", ",", "-", "3", ",", "V_ASN1_OCTET_STRING", ")", ";", "if", "(", "!", "msig", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_NO_MSGSIGDIGEST", ")", ";", "goto", "err", ";", "}", "if", "(", "!", "cms_msgSigDigest", "(", "osi", ",", "dig", ",", "&", "diglen", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_MSGSIGDIGEST_ERROR", ")", ";", "goto", "err", ";", "}", "if", "(", "diglen", "!=", "(", "unsigned", "int", ")", "msig", "->", "length", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_MSGSIGDIGEST_WRONG_LENGTH", ")", ";", "goto", "err", ";", "}", "if", "(", "memcmp", "(", "dig", ",", "msig", "->", "data", ",", "diglen", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE", ")", ";", "goto", "err", ";", "}", "/*", "Compare", "content", "types", "*/", "octype", "=", "CMS_signed_get0_data_by_OBJ", "(", "osi", ",", "OBJ_nid2obj", "(", "NID_pkcs9_contentType", ")", ",", "-", "3", ",", "V_ASN1_OBJECT", ")", ";", "if", "(", "!", "octype", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_NO_CONTENT_TYPE", ")", ";", "goto", "err", ";", "}", "/*", "Compare", "details", "in", "receipt", "request", "*/", "if", "(", "OBJ_cmp", "(", "octype", ",", "rct", "->", "contentType", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_CONTENT_TYPE_MISMATCH", ")", ";", "goto", "err", ";", "}", "/*", "Get", "original", "receipt", "request", "details", "*/", "if", "(", "CMS_get1_ReceiptRequest", "(", "osi", ",", "&", "rr", ")", "<=", "0", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_NO_RECEIPT_REQUEST", ")", ";", "goto", "err", ";", "}", "if", "(", "ASN1_STRING_cmp", "(", "rr", "->", "signedContentIdentifier", ",", "rct", "->", "signedContentIdentifier", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_RECEIPT_VERIFY", ",", "CMS_R_CONTENTIDENTIFIER_MISMATCH", ")", ";", "goto", "err", ";", "}", "r", "=", "1", ";", "err", ":", "CMS_ReceiptRequest_free", "(", "rr", ")", ";", "M_ASN1_free_of", "(", "rct", ",", "CMS_Receipt", ")", ";", "return", "r", ";", "}'" ]

[ "ESS", "services:", "for", "now", "just", "Signed", "Receipt", "related" ]

[ "'int", "CMS_get1_ReceiptRequest", "(", "CMS_SignerInfo", "*", "si", ",", "CMS_ReceiptRequest", "*", "*", "prr", ")", "{", "ASN1_STRING", "*", "str", ";", "CMS_ReceiptRequest", "*", "rr", "=", "NULL", ";", "if", "(", "prr", ")", "*", "prr", "=", "NULL", ";", "str", "=", "CMS_signed_get0_data_by_OBJ", "(", "si", ",", "OBJ_nid2obj", "(", "NID_id_smime_aa_receiptRequest", ")", ",", "-", "3", ",", "V_ASN1_SEQUENCE", ")", ";", "if", "(", "!", "str", ")", "return", "0", ";", "rr", "=", "ASN1_item_unpack", "(", "str", ",", "ASN1_ITEM_rptr", "(", "CMS_ReceiptRequest", ")", ")", ";", "if", "(", "!", "rr", ")", "return", "-", "1", ";", "if", "(", "prr", ")", "*", "prr", "=", "rr", ";", "else", "CMS_ReceiptRequest_free", "(", "rr", ")", ";", "return", "1", ";", "}'" ]

[ "Add", "a", "msgSigDigest", "attribute", "to", "a", "SignerInfo" ]

[ "'int", "cms_msgSigDigest_add1", "(", "CMS_SignerInfo", "*", "dest", ",", "CMS_SignerInfo", "*", "src", ")", "{", "unsigned", "char", "dig", "[", "EVP_MAX_MD_SIZE", "]", ";", "unsigned", "int", "diglen", ";", "if", "(", "!", "cms_msgSigDigest", "(", "src", ",", "dig", ",", "&", "diglen", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_MSGSIGDIGEST_ADD1", ",", "CMS_R_MSGSIGDIGEST_ERROR", ")", ";", "return", "0", ";", "}", "if", "(", "!", "CMS_signed_add1_attr_by_NID", "(", "dest", ",", "NID_id_smime_aa_msgSigDigest", ",", "V_ASN1_OCTET_STRING", ",", "dig", ",", "diglen", ")", ")", "{", "CMSerr", "(", "CMS_F_CMS_MSGSIGDIGEST_ADD1", ",", "ERR_R_MALLOC_FAILURE", ")", ";", "return", "0", ";", "}", "return", "1", ";", "}'" ]

[ "Mock", "to", "catch", "transaction", "calls", "to", "the", "daemon" ]

[ "'nr_status_t", "__wrap_nr_cmd_txndata_tx", "(", "int", "daemon_fd", "NRUNUSED", ",", "const", "nrtxn_t", "*", "txn", "NRUNUSED", ")", "{", "return", "(", "nr_status_t", ")", "mock", "()", ";", "}'" ]

[ "Expand", "UBSAN_CHECK_", "internal", "function", "if", "it", "has", "vector", "operands" ]

[ "'static", "void", "expand_vector_ubsan_overflow", "(", "location_t", "loc", ",", "enum", "tree_code", "code", ",", "tree", "lhs", ",", "tree", "arg0", ",", "tree", "arg1", ")", "{", "poly_uint64", "cnt", "=", "TYPE_VECTOR_SUBPARTS", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "rtx_code_label", "*", "loop_lab", "=", "NULL", ";", "rtx", "cntvar", "=", "NULL_RTX", ";", "tree", "cntv", "=", "NULL_TREE", ";", "tree", "eltype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "tree", "sz", "=", "TYPE_SIZE", "(", "eltype", ")", ";", "tree", "data", "=", "NULL_TREE", ";", "tree", "resv", "=", "NULL_TREE", ";", "rtx", "lhsr", "=", "NULL_RTX", ";", "rtx", "resvr", "=", "NULL_RTX", ";", "unsigned", "HOST_WIDE_INT", "const_cnt", "=", "0", ";", "bool", "use_loop_p", "=", "(", "!", "cnt", ".", "is_constant", "(", "&", "const_cnt", ")", "||", "const_cnt", ">", "4", ")", ";", "if", "(", "lhs", ")", "{", "optab", "op", ";", "lhsr", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "GET_MODE", "(", "lhsr", ")", ")", "||", "(", "op", "=", "optab_for_tree_code", "(", "code", ",", "TREE_TYPE", "(", "arg0", ")", ",", "optab_default", ")", ")", "==", "unknown_optab", "||", "(", "optab_handler", "(", "op", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", "==", "CODE_FOR_nothing", ")", ")", "{", "if", "(", "MEM_P", "(", "lhsr", ")", ")", "resv", "=", "make_tree", "(", "TREE_TYPE", "(", "lhs", ")", ",", "lhsr", ")", ";", "else", "{", "resvr", "=", "assign_temp", "(", "TREE_TYPE", "(", "lhs", ")", ",", "1", ",", "1", ")", ";", "resv", "=", "make_tree", "(", "TREE_TYPE", "(", "lhs", ")", ",", "resvr", ")", ";", "}", "}", "}", "if", "(", "use_loop_p", ")", "{", "do_pending_stack_adjust", "()", ";", "loop_lab", "=", "gen_label_rtx", "()", ";", "cntvar", "=", "gen_reg_rtx", "(", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "cntv", "=", "make_tree", "(", "sizetype", ",", "cntvar", ")", ";", "emit_move_insn", "(", "cntvar", ",", "const0_rtx", ")", ";", "emit_label", "(", "loop_lab", ")", ";", "}", "if", "(", "TREE_CODE", "(", "arg0", ")", "!=", "VECTOR_CST", ")", "{", "rtx", "arg0r", "=", "expand_normal", "(", "arg0", ")", ";", "arg0", "=", "make_tree", "(", "TREE_TYPE", "(", "arg0", ")", ",", "arg0r", ")", ";", "}", "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "VECTOR_CST", ")", "{", "rtx", "arg1r", "=", "expand_normal", "(", "arg1", ")", ";", "arg1", "=", "make_tree", "(", "TREE_TYPE", "(", "arg1", ")", ",", "arg1r", ")", ";", "}", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "(", "use_loop_p", "?", "1", ":", "const_cnt", ")", ";", "i", "++", ")", "{", "tree", "op0", ",", "<type", "ref=\"prev\"/>", "op1", ",", "<type", "ref=\"prev\"/>", "res", "=", "NULL_TREE", ";", "if", "(", "use_loop_p", ")", "{", "tree", "atype", "=", "build_array_type_nelts", "(", "eltype", ",", "cnt", ")", ";", "op0", "=", "uniform_vector_p", "(", "arg0", ")", ";", "if", "(", "op0", "==", "NULL_TREE", ")", "{", "op0", "=", "fold_build1_loc", "(", "loc", ",", "VIEW_CONVERT_EXPR", ",", "atype", ",", "arg0", ")", ";", "op0", "=", "build4_loc", "(", "loc", ",", "ARRAY_REF", ",", "eltype", ",", "op0", ",", "cntv", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "}", "op1", "=", "uniform_vector_p", "(", "arg1", ")", ";", "if", "(", "op1", "==", "NULL_TREE", ")", "{", "op1", "=", "fold_build1_loc", "(", "loc", ",", "VIEW_CONVERT_EXPR", ",", "atype", ",", "arg1", ")", ";", "op1", "=", "build4_loc", "(", "loc", ",", "ARRAY_REF", ",", "eltype", ",", "op1", ",", "cntv", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "}", "if", "(", "resv", ")", "{", "res", "=", "fold_build1_loc", "(", "loc", ",", "VIEW_CONVERT_EXPR", ",", "atype", ",", "resv", ")", ";", "res", "=", "build4_loc", "(", "loc", ",", "ARRAY_REF", ",", "eltype", ",", "res", ",", "cntv", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "}", "}", "else", "{", "tree", "bitpos", "=", "bitsize_int", "(", "tree_to_uhwi", "(", "sz", ")", "*", "i", ")", ";", "op0", "=", "fold_build3_loc", "(", "loc", ",", "BIT_FIELD_REF", ",", "eltype", ",", "arg0", ",", "sz", ",", "bitpos", ")", ";", "op1", "=", "fold_build3_loc", "(", "loc", ",", "BIT_FIELD_REF", ",", "eltype", ",", "arg1", ",", "sz", ",", "bitpos", ")", ";", "if", "(", "resv", ")", "res", "=", "fold_build3_loc", "(", "loc", ",", "BIT_FIELD_REF", ",", "eltype", ",", "resv", ",", "sz", ",", "bitpos", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "PLUS_EXPR", ":", "expand_addsub_overflow", "(", "loc", ",", "PLUS_EXPR", ",", "res", ",", "op0", ",", "op1", ",", "false", ",", "false", ",", "false", ",", "true", ",", "&", "data", ")", ";", "break;", "case", "MINUS_EXPR", ":", "if", "(", "use_loop_p", "?", "integer_zerop", "(", "arg0", ")", ":", "integer_zerop", "(", "op0", ")", ")", "expand_neg_overflow", "(", "loc", ",", "res", ",", "op1", ",", "true", ",", "&", "data", ")", ";", "else", "expand_addsub_overflow", "(", "loc", ",", "MINUS_EXPR", ",", "res", ",", "op0", ",", "op1", ",", "false", ",", "false", ",", "false", ",", "true", ",", "&", "data", ")", ";", "break;", "case", "MULT_EXPR", ":", "expand_mul_overflow", "(", "loc", ",", "res", ",", "op0", ",", "op1", ",", "false", ",", "false", ",", "false", ",", "true", ",", "&", "data", ")", ";", "break;", "default:", "gcc_unreachable", "()", ";", "}", "}", "if", "(", "use_loop_p", ")", "{", "struct", "separate_ops", "ops", ";", "ops", ".", "code", "=", "PLUS_EXPR", ";", "ops", ".", "type", "=", "TREE_TYPE", "(", "cntv", ")", ";", "ops", ".", "op0", "=", "cntv", ";", "ops", ".", "op1", "=", "build_int_cst", "(", "TREE_TYPE", "(", "cntv", ")", ",", "1", ")", ";", "ops", ".", "op2", "=", "NULL_TREE", ";", "ops", ".", "location", "=", "loc", ";", "rtx", "ret", "=", "expand_expr_real_2", "(", "&", "ops", ",", "cntvar", ",", "TYPE_MODE", "(", "sizetype", ")", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "ret", "!=", "cntvar", ")", "emit_move_insn", "(", "cntvar", ",", "ret", ")", ";", "rtx", "cntrtx", "=", "gen_int_mode", "(", "cnt", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "do_compare_rtx_and_jump", "(", "cntvar", ",", "cntrtx", ",", "NE", ",", "false", ",", "TYPE_MODE", "(", "sizetype", ")", ",", "NULL_RTX", ",", "NULL", ",", "loop_lab", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "}", "if", "(", "lhs", "&&", "resv", "==", "NULL_TREE", ")", "{", "struct", "separate_ops", "ops", ";", "ops", ".", "code", "=", "code", ";", "ops", ".", "type", "=", "TREE_TYPE", "(", "arg0", ")", ";", "ops", ".", "op0", "=", "arg0", ";", "ops", ".", "op1", "=", "arg1", ";", "ops", ".", "op2", "=", "NULL_TREE", ";", "ops", ".", "location", "=", "loc", ";", "rtx", "ret", "=", "expand_expr_real_2", "(", "&", "ops", ",", "lhsr", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "ret", "!=", "lhsr", ")", "emit_move_insn", "(", "lhsr", ",", "ret", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "resvr", ")", "emit_move_insn", "(", "lhsr", ",", "resvr", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_UBSAN_NULL", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "omp_device_lower", "pass" ]

[ "'static", "void", "expand_GOMP_USE_SIMT", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Add", "mul", "overflow", "checking", "to", "the", "statement", "STMT" ]

[ "'static", "void", "expand_mul_overflow", "(", "location_t", "loc", ",", "tree", "lhs", ",", "tree", "arg0", ",", "tree", "arg1", ",", "bool", "unsr_p", ",", "bool", "uns0_p", ",", "bool", "uns1_p", ",", "bool", "is_ubsan", ",", "tree", "*", "datap", ")", "{", "rtx", "res", ",", "<type", "ref=\"prev\"/>", "op0", ",", "<type", "ref=\"prev\"/>", "op1", ";", "tree", "fn", ",", "<type", "ref=\"prev\"/>", "type", ";", "rtx_code_label", "*", "done_label", ",", "<type", "ref=\"prev\">", "*", "do_error", ";", "rtx", "target", "=", "NULL_RTX", ";", "signop", "sign", ";", "enum", "insn_code", "icode", ";", "done_label", "=", "gen_label_rtx", "()", ";", "do_error", "=", "gen_label_rtx", "()", ";", "do_pending_stack_adjust", "()", ";", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "scalar_int_mode", "mode", "=", "SCALAR_INT_TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "bool", "uns", "=", "unsr_p", ";", "if", "(", "lhs", ")", "{", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "if", "(", "!", "is_ubsan", ")", "write_complex_part", "(", "target", ",", "const0_rtx", ",", "true", ")", ";", "}", "if", "(", "is_ubsan", ")", "gcc_assert", "(", "!", "unsr_p", "&&", "!", "uns0_p", "&&", "!", "uns1_p", ")", ";", "/*", "We", "assume", "both", "operands", "and", "result", "have", "the", "same", "precision", "here", "(GET_MODE_BITSIZE", "(mode)),", "S", "stands", "for", "signed", "type", "with", "that", "precision,", "U", "for", "unsigned", "type", "with", "that", "precision,", "sgn", "for", "unsigned", "most", "significant", "bit", "in", "that", "precision.", "s1", "is", "signed", "first", "operand,", "u1", "is", "unsigned", "first", "operand,", "s2", "is", "signed", "second", "operand,", "u2", "is", "unsigned", "second", "operand,", "sr", "is", "signed", "result,", "ur", "is", "unsigned", "result", "and", "the", "following", "rules", "say", "how", "to", "compute", "result", "(which", "is", "always", "result", "of", "the", "operands", "as", "if", "both", "were", "unsigned,", "cast", "to", "the", "right", "signedness)", "and", "how", "to", "compute", "whether", "operation", "overflowed.", "main_ovf", "(false)", "stands", "for", "jump", "on", "signed", "multiplication", "overflow", "or", "the", "main", "algorithm", "with", "uns", "==", "false.", "main_ovf", "(true)", "stands", "for", "jump", "on", "unsigned", "multiplication", "overflow", "or", "the", "main", "algorithm", "with", "uns", "==", "true.", "s1", "*", "s2", "->", "sr", "res", "=", "(S)", "((U)", "s1", "*", "(U)", "s2)", "ovf", "=", "main_ovf", "(false)", "u1", "*", "u2", "->", "ur", "res", "=", "u1", "*", "u2", "ovf", "=", "main_ovf", "(true)", "s1", "*", "u2", "->", "ur", "res", "=", "(U)", "s1", "*", "u2", "ovf", "=", "(s1", "<", "0", "&&", "u2)", "||", "main_ovf", "(true)", "u1", "*", "u2", "->", "sr", "res", "=", "(S)", "(u1", "*", "u2)", "ovf", "=", "res", "<", "0", "||", "main_ovf", "(true)", "s1", "*", "u2", "->", "sr", "res", "=", "(S)", "((U)", "s1", "*", "u2)", "ovf", "=", "(S)", "u2", ">=", "0", "?", "main_ovf", "(false)", ":", "(s1", "!=", "0", "&&", "(s1", "!=", "-1", "||", "u2", "!=", "(U)", "res))", "s1", "*", "s2", "->", "ur", "t1", "=", "(s1", "&", "s2)", "<", "0", "?", "(-(U)", "s1)", ":", "((U)", "s1)", "t2", "=", "(s1", "&", "s2)", "<", "0", "?", "(-(U)", "s2)", ":", "((U)", "s2)", "res", "=", "t1", "*", "t2", "ovf", "=", "(s1", "^", "s2)", "<", "0", "?", "(s1", "&&", "s2)", ":", "main_ovf", "(true)", "*/", "if", "(", "uns0_p", "&&", "!", "uns1_p", ")", "{", "/*", "Multiplication", "is", "commutative,", "if", "operand", "signedness", "differs,", "canonicalize", "to", "the", "first", "operand", "being", "signed", "and", "second", "unsigned", "to", "simplify", "following", "code.", "*/", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "std", "::", "swap", "(", "arg0", ",", "arg1", ")", ";", "uns0_p", "=", "false", ";", "uns1_p", "=", "true", ";", "}", "int", "pos_neg0", "=", "get_range_pos_neg", "(", "arg0", ")", ";", "int", "pos_neg1", "=", "get_range_pos_neg", "(", "arg1", ")", ";", "/*", "s1", "*", "u2", "->", "ur", "*/", "if", "(", "!", "uns0_p", "&&", "uns1_p", "&&", "unsr_p", ")", "{", "switch", "(", "pos_neg0", ")", "{", "case", "1", ":", "/*", "If", "s1", "is", "non-negative,", "just", "perform", "normal", "u1", "*", "u2", "->", "ur.", "*/", "goto", "do_main", ";", "case", "2", ":", "/*", "If", "s1", "is", "negative,", "avoid", "the", "main", "code,", "just", "multiply", "and", "signal", "overflow", "if", "op1", "is", "not", "0.", "*/", "struct", "separate_ops", "ops", ";", "ops", ".", "code", "=", "MULT_EXPR", ";", "ops", ".", "type", "=", "TREE_TYPE", "(", "arg1", ")", ";", "ops", ".", "op0", "=", "make_tree", "(", "ops", ".", "type", ",", "op0", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "ops", ".", "type", ",", "op1", ")", ";", "ops", ".", "op2", "=", "NULL_TREE", ";", "ops", ".", "location", "=", "loc", ";", "res", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "do_compare_rtx_and_jump", "(", "op1", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "goto", "do_error_label", ";", "case", "3", ":", "rtx_code_label", "*", "do_main_label", ";", "do_main_label", "=", "gen_label_rtx", "()", ";", "do_compare_rtx_and_jump", "(", "op0", ",", "const0_rtx", ",", "GE", ",", "false", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "do_main_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "do_compare_rtx_and_jump", "(", "op1", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "do_main_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "expand_arith_set_overflow", "(", "lhs", ",", "target", ")", ";", "emit_label", "(", "do_main_label", ")", ";", "goto", "do_main", ";", "default:", "gcc_unreachable", "()", ";", "}", "}", "/*", "u1", "*", "u2", "->", "sr", "*/", "if", "(", "uns0_p", "&&", "uns1_p", "&&", "!", "unsr_p", ")", "{", "uns", "=", "true", ";", "/*", "Rest", "of", "handling", "of", "this", "case", "after", "res", "is", "computed.", "*/", "goto", "do_main", ";", "}", "/*", "s1", "*", "u2", "->", "sr", "*/", "if", "(", "!", "uns0_p", "&&", "uns1_p", "&&", "!", "unsr_p", ")", "{", "switch", "(", "pos_neg1", ")", "{", "case", "1", ":", "goto", "do_main", ";", "case", "2", ":", "/*", "If", "(S)", "u2", "is", "negative", "(i.e.", "u2", "is", "larger", "than", "maximum", "of", "S,", "avoid", "the", "main", "code,", "just", "multiply", "and", "signal", "overflow", "unless", "0", "*", "u2", "or", "-1", "*", "((U)", "Smin).", "*/", "struct", "separate_ops", "ops", ";", "ops", ".", "code", "=", "MULT_EXPR", ";", "ops", ".", "type", "=", "TREE_TYPE", "(", "arg1", ")", ";", "ops", ".", "op0", "=", "make_tree", "(", "ops", ".", "type", ",", "op0", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "ops", ".", "type", ",", "op1", ")", ";", "ops", ".", "op2", "=", "NULL_TREE", ";", "ops", ".", "location", "=", "loc", ";", "res", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "do_compare_rtx_and_jump", "(", "op0", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "do_compare_rtx_and_jump", "(", "op0", ",", "constm1_rtx", ",", "NE", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "do_error", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "int", "prec", ";", "prec", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "rtx", "sgn", ";", "sgn", "=", "immed_wide_int_const", "(", "wi", "::", "min_value", "(", "prec", ",", "SIGNED", ")", ",", "mode", ")", ";", "do_compare_rtx_and_jump", "(", "op1", ",", "sgn", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "goto", "do_error_label", ";", "case", "3", ":", "/*", "Rest", "of", "handling", "of", "this", "case", "after", "res", "is", "computed.", "*/", "goto", "do_main", ";", "default:", "gcc_unreachable", "()", ";", "}", "}", "/*", "s1", "*", "s2", "->", "ur", "*/", "if", "(", "!", "uns0_p", "&&", "!", "uns1_p", "&&", "unsr_p", ")", "{", "rtx", "tem", ",", "<type", "ref=\"prev\"/>", "tem2", ";", "switch", "(", "pos_neg0", "|", "pos_neg1", ")", "{", "case", "1", ":", "/*", "Both", "operands", "known", "to", "be", "non-negative.", "*/", "goto", "do_main", ";", "case", "2", ":", "/*", "Both", "operands", "known", "to", "be", "negative.", "*/", "op0", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "op0", ",", "NULL_RTX", ",", "false", ")", ";", "op1", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "op1", ",", "NULL_RTX", ",", "false", ")", ";", "/*", "Avoid", "looking", "at", "arg0/arg1", "ranges,", "as", "we\\'ve", "changed", "the", "arguments.", "*/", "arg0", "=", "error_mark_node", ";", "arg1", "=", "error_mark_node", ";", "goto", "do_main", ";", "case", "3", ":", "if", "(", "(", "pos_neg0", "^", "pos_neg1", ")", "==", "3", ")", "{", "/*", "If", "one", "operand", "is", "known", "to", "be", "negative", "and", "the", "other", "non-negative,", "this", "overflows", "always,", "unless", "the", "non-negative", "one", "is", "0.", "Just", "do", "normal", "multiply", "and", "set", "overflow", "unless", "one", "of", "the", "operands", "is", "0.", "*/", "struct", "separate_ops", "ops", ";", "ops", ".", "code", "=", "MULT_EXPR", ";", "ops", ".", "type", "=", "build_nonstandard_integer_type", "(", "GET_MODE_PRECISION", "(", "mode", ")", ",", "1", ")", ";", "ops", ".", "op0", "=", "make_tree", "(", "ops", ".", "type", ",", "op0", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "ops", ".", "type", ",", "op1", ")", ";", "ops", ".", "op2", "=", "NULL_TREE", ";", "ops", ".", "location", "=", "loc", ";", "res", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "tem", "=", "expand_binop", "(", "mode", ",", "and_optab", ",", "op0", ",", "op1", ",", "NULL_RTX", ",", "false", ",", "OPTAB_LIB_WIDEN", ")", ";", "do_compare_rtx_and_jump", "(", "tem", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "goto", "do_error_label", ";", "}", "/*", "The", "general", "case,", "do", "all", "the", "needed", "comparisons", "at", "runtime.", "*/", "rtx_code_label", "*", "do_main_label", ",", "<type", "ref=\"prev\">", "*", "after_negate_label", ";", "rtx", "rop0", ",", "<type", "ref=\"prev\"/>", "rop1", ";", "rop0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rop1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "rop0", ",", "op0", ")", ";", "emit_move_insn", "(", "rop1", ",", "op1", ")", ";", "op0", "=", "rop0", ";", "op1", "=", "rop1", ";", "do_main_label", "=", "gen_label_rtx", "()", ";", "after_negate_label", "=", "gen_label_rtx", "()", ";", "tem", "=", "expand_binop", "(", "mode", ",", "and_optab", ",", "op0", ",", "op1", ",", "NULL_RTX", ",", "false", ",", "OPTAB_LIB_WIDEN", ")", ";", "do_compare_rtx_and_jump", "(", "tem", ",", "const0_rtx", ",", "GE", ",", "false", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "after_negate_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "/*", "Both", "arguments", "negative", "here,", "negate", "them", "and", "continue", "with", "normal", "unsigned", "overflow", "checking", "multiplication.", "*/", "emit_move_insn", "(", "op0", ",", "expand_unop", "(", "mode", ",", "neg_optab", ",", "op0", ",", "NULL_RTX", ",", "false", ")", ")", ";", "emit_move_insn", "(", "op1", ",", "expand_unop", "(", "mode", ",", "neg_optab", ",", "op1", ",", "NULL_RTX", ",", "false", ")", ")", ";", "/*", "Avoid", "looking", "at", "arg0/arg1", "ranges,", "as", "we", "might", "have", "changed", "the", "arguments.", "*/", "arg0", "=", "error_mark_node", ";", "arg1", "=", "error_mark_node", ";", "emit_jump", "(", "do_main_label", ")", ";", "emit_label", "(", "after_negate_label", ")", ";", "tem2", "=", "expand_binop", "(", "mode", ",", "xor_optab", ",", "op0", ",", "op1", ",", "NULL_RTX", ",", "false", ",", "OPTAB_LIB_WIDEN", ")", ";", "do_compare_rtx_and_jump", "(", "tem2", ",", "const0_rtx", ",", "GE", ",", "false", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "do_main_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "/*", "One", "argument", "is", "negative", "here,", "the", "other", "positive.", "This", "overflows", "always,", "unless", "one", "of", "the", "arguments", "is", "0.", "But", "if", "e.g.", "s2", "is", "0,", "(U)", "s1", "*", "0", "doesn\\'t", "overflow,", "whatever", "s1", "is,", "thus", "we", "can", "keep", "do_main", "code", "oring", "in", "overflow", "as", "is.", "*/", "do_compare_rtx_and_jump", "(", "tem", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "do_main_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "expand_arith_set_overflow", "(", "lhs", ",", "target", ")", ";", "emit_label", "(", "do_main_label", ")", ";", "goto", "do_main", ";", "default:", "gcc_unreachable", "()", ";", "}", "}", "do_main", ":", "type", "=", "build_nonstandard_integer_type", "(", "GET_MODE_PRECISION", "(", "mode", ")", ",", "uns", ")", ";", "sign", "=", "uns", "?", "UNSIGNED", ":", "SIGNED", ";", "icode", "=", "optab_handler", "(", "uns", "?", "umulv4_optab", ":", "mulv4_optab", ",", "mode", ")", ";", "if", "(", "uns", "&&", "(", "integer_pow2p", "(", "arg0", ")", "||", "integer_pow2p", "(", "arg1", ")", ")", "&&", "(", "optimize_insn_for_speed_p", "()", "||", "icode", "==", "CODE_FOR_nothing", ")", ")", "{", "/*", "Optimize", "unsigned", "multiplication", "by", "power", "of", "2", "constant", "using", "2", "shifts,", "one", "for", "result,", "one", "to", "extract", "the", "shifted", "out", "bits", "to", "see", "if", "they", "are", "all", "zero.", "Don\\'t", "do", "this", "if", "optimizing", "for", "size", "and", "we", "have", "umulv4_optab,", "in", "that", "case", "assume", "multiplication", "will", "be", "shorter.", "This", "is", "heuristics", "based", "on", "the", "single", "target", "that", "provides", "umulv4", "right", "now", "(i?86/x86_64),", "if", "further", "targets", "add", "it,", "this", "might", "need", "to", "be", "revisited.", "Cases", "where", "both", "operands", "are", "constant", "should", "be", "folded", "already", "during", "GIMPLE,", "and", "cases", "where", "one", "operand", "is", "constant", "but", "not", "power", "of", "2", "are", "questionable,", "either", "the", "WIDEN_MULT_EXPR", "case", "below", "can", "be", "done", "without", "multiplication,", "just", "by", "shifts", "and", "adds,", "or", "we\\'d", "need", "to", "divide", "the", "result", "(and", "hope", "it", "actually", "doesn\\'t", "really", "divide", "nor", "multiply)", "and", "compare", "the", "result", "of", "the", "division", "with", "the", "original", "operand.", "*/", "rtx", "opn0", "=", "op0", ";", "rtx", "opn1", "=", "op1", ";", "tree", "argn0", "=", "arg0", ";", "tree", "argn1", "=", "arg1", ";", "if", "(", "integer_pow2p", "(", "arg0", ")", ")", "{", "std", "::", "swap", "(", "opn0", ",", "opn1", ")", ";", "std", "::", "swap", "(", "argn0", ",", "argn1", ")", ";", "}", "int", "cnt", "=", "tree_log2", "(", "argn1", ")", ";", "if", "(", "cnt", ">=", "0", "&&", "cnt", "<", "GET_MODE_PRECISION", "(", "mode", ")", ")", "{", "rtx", "upper", "=", "const0_rtx", ";", "res", "=", "expand_shift", "(", "LSHIFT_EXPR", ",", "mode", ",", "opn0", ",", "cnt", ",", "NULL_RTX", ",", "uns", ")", ";", "if", "(", "cnt", "!=", "0", ")", "upper", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "mode", ",", "opn0", ",", "GET_MODE_PRECISION", "(", "mode", ")", "-", "cnt", ",", "NULL_RTX", ",", "uns", ")", ";", "do_compare_rtx_and_jump", "(", "upper", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "goto", "do_error_label", ";", "}", "}", "if", "(", "icode", "!=", "CODE_FOR_nothing", ")", "{", "struct", "expand_operand", "ops", "[", "4", "]", ";", "rtx_insn", "*", "last", "=", "get_last_insn", "()", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "res", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "op0", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "2", "]", ",", "op1", ",", "mode", ")", ";", "create_fixed_operand", "(", "&", "ops", "[", "3", "]", ",", "do_error", ")", ";", "if", "(", "maybe_expand_insn", "(", "icode", ",", "4", ",", "ops", ")", ")", "{", "last", "=", "get_last_insn", "()", ";", "if", "(", "profile_status_for_fn", "(", "cfun", ")", "!=", "PROFILE_ABSENT", "&&", "JUMP_P", "(", "last", ")", "&&", "any_condjump_p", "(", "last", ")", "&&", "!", "find_reg_note", "(", "last", ",", "REG_BR_PROB", ",", "0", ")", ")", "add_reg_br_prob_note", "(", "last", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "emit_jump", "(", "done_label", ")", ";", "}", "else", "{", "delete_insns_since", "(", "last", ")", ";", "icode", "=", "CODE_FOR_nothing", ";", "}", "}", "if", "(", "icode", "==", "CODE_FOR_nothing", ")", "{", "struct", "separate_ops", "ops", ";", "int", "prec", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "scalar_int_mode", "hmode", ",", "<type", "ref=\"prev\"/>", "wmode", ";", "ops", ".", "op0", "=", "make_tree", "(", "type", ",", "op0", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "type", ",", "op1", ")", ";", "ops", ".", "op2", "=", "NULL_TREE", ";", "ops", ".", "location", "=", "loc", ";", "/*", "Optimize", "unsigned", "overflow", "check", "where", "we", "don\\'t", "use", "the", "multiplication", "result,", "just", "whether", "overflow", "happened.", "If", "we", "can", "do", "MULT_HIGHPART_EXPR,", "that", "followed", "by", "comparison", "of", "the", "result", "against", "zero", "is", "cheapest.", "We\\'ll", "still", "compute", "res,", "but", "it", "should", "be", "DCEd", "later.", "*/", "use_operand_p", "use", ";", "gimple", "*", "use_stmt", ";", "if", "(", "!", "is_ubsan", "&&", "lhs", "&&", "uns", "&&", "!", "(", "uns0_p", "&&", "uns1_p", "&&", "!", "unsr_p", ")", "&&", "can_mult_highpart_p", "(", "mode", ",", "uns", ")", "==", "1", "&&", "single_imm_use", "(", "lhs", ",", "&", "use", ",", "&", "use_stmt", ")", "&&", "is_gimple_assign", "(", "use_stmt", ")", "&&", "gimple_assign_rhs_code", "(", "use_stmt", ")", "==", "IMAGPART_EXPR", ")", "goto", "highpart", ";", "if", "(", "GET_MODE_2XWIDER_MODE", "(", "mode", ")", ".", "exists", "(", "&", "wmode", ")", "&&", "targetm", ".", "scalar_mode_supported_p", "(", "wmode", ")", "&&", "can_widen_mult_without_libcall", "(", "wmode", ",", "mode", ",", "op0", ",", "op1", ",", "uns", ")", ")", "{", "twoxwider", ":", "ops", ".", "code", "=", "WIDEN_MULT_EXPR", ";", "ops", ".", "type", "=", "build_nonstandard_integer_type", "(", "GET_MODE_PRECISION", "(", "wmode", ")", ",", "uns", ")", ";", "res", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "wmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "hipart", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "wmode", ",", "res", ",", "prec", ",", "NULL_RTX", ",", "uns", ")", ";", "hipart", "=", "convert_modes", "(", "mode", ",", "wmode", ",", "hipart", ",", "uns", ")", ";", "res", "=", "convert_modes", "(", "mode", ",", "wmode", ",", "res", ",", "uns", ")", ";", "if", "(", "uns", ")", "/*", "For", "the", "unsigned", "multiplication,", "there", "was", "overflow", "if", "HIPART", "is", "non-zero.", "*/", "do_compare_rtx_and_jump", "(", "hipart", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "else", "{", "rtx", "signbit", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "mode", ",", "res", ",", "prec", "-", "1", ",", "NULL_RTX", ",", "0", ")", ";", "/*", "RES", "is", "low", "half", "of", "the", "double", "width", "result,", "HIPART", "the", "high", "half.", "There", "was", "overflow", "if", "HIPART", "is", "different", "from", "RES", "<", "0", "?", "-1", ":", "0.", "*/", "do_compare_rtx_and_jump", "(", "signbit", ",", "hipart", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "can_mult_highpart_p", "(", "mode", ",", "uns", ")", "==", "1", ")", "{", "highpart", ":", "ops", ".", "code", "=", "MULT_HIGHPART_EXPR", ";", "ops", ".", "type", "=", "type", ";", "rtx", "hipart", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "ops", ".", "code", "=", "MULT_EXPR", ";", "res", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "uns", ")", "/*", "For", "the", "unsigned", "multiplication,", "there", "was", "overflow", "if", "HIPART", "is", "non-zero.", "*/", "do_compare_rtx_and_jump", "(", "hipart", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "else", "{", "rtx", "signbit", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "mode", ",", "res", ",", "prec", "-", "1", ",", "NULL_RTX", ",", "0", ")", ";", "/*", "RES", "is", "low", "half", "of", "the", "double", "width", "result,", "HIPART", "the", "high", "half.", "There", "was", "overflow", "if", "HIPART", "is", "different", "from", "RES", "<", "0", "?", "-1", ":", "0.", "*/", "do_compare_rtx_and_jump", "(", "signbit", ",", "hipart", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "int_mode_for_size", "(", "prec", "/", "2", ",", "1", ")", ".", "exists", "(", "&", "hmode", ")", "&&", "2", "*", "GET_MODE_PRECISION", "(", "hmode", ")", "==", "prec", ")", "{", "rtx_code_label", "*", "large_op0", "=", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "small_op0_large_op1", "=", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "one_small_one_large", "=", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "both_ops_large", "=", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "after_hipart_neg", "=", "uns", "?", "NULL", ":", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "after_lopart_neg", "=", "uns", "?", "NULL", ":", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "do_overflow", "=", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "hipart_different", "=", "uns", "?", "NULL", ":", "gen_label_rtx", "()", ";", "unsigned", "int", "hprec", "=", "GET_MODE_PRECISION", "(", "hmode", ")", ";", "rtx", "hipart0", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "mode", ",", "op0", ",", "hprec", ",", "NULL_RTX", ",", "uns", ")", ";", "hipart0", "=", "convert_modes", "(", "hmode", ",", "mode", ",", "hipart0", ",", "uns", ")", ";", "rtx", "lopart0", "=", "convert_modes", "(", "hmode", ",", "mode", ",", "op0", ",", "uns", ")", ";", "rtx", "signbit0", "=", "const0_rtx", ";", "if", "(", "!", "uns", ")", "signbit0", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "hmode", ",", "lopart0", ",", "hprec", "-", "1", ",", "NULL_RTX", ",", "0", ")", ";", "rtx", "hipart1", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "mode", ",", "op1", ",", "hprec", ",", "NULL_RTX", ",", "uns", ")", ";", "hipart1", "=", "convert_modes", "(", "hmode", ",", "mode", ",", "hipart1", ",", "uns", ")", ";", "rtx", "lopart1", "=", "convert_modes", "(", "hmode", ",", "mode", ",", "op1", ",", "uns", ")", ";", "rtx", "signbit1", "=", "const0_rtx", ";", "if", "(", "!", "uns", ")", "signbit1", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "hmode", ",", "lopart1", ",", "hprec", "-", "1", ",", "NULL_RTX", ",", "0", ")", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "/*", "True", "if", "op0", "resp.", "op1", "are", "known", "to", "be", "in", "the", "range", "of", "halfstype.", "*/", "bool", "op0_small_p", "=", "false", ";", "bool", "op1_small_p", "=", "false", ";", "/*", "True", "if", "op0", "resp.", "op1", "are", "known", "to", "have", "all", "zeros", "or", "all", "ones", "in", "the", "upper", "half", "of", "bits,", "but", "are", "not", "known", "to", "be", "op{0,1}_small_p.", "*/", "bool", "op0_medium_p", "=", "false", ";", "bool", "op1_medium_p", "=", "false", ";", "/*", "-1", "if", "op{0,1}", "is", "known", "to", "be", "negative,", "0", "if", "it", "is", "known", "to", "be", "nonnegative,", "1", "if", "unknown.", "*/", "int", "op0_sign", "=", "1", ";", "int", "op1_sign", "=", "1", ";", "if", "(", "pos_neg0", "==", "1", ")", "op0_sign", "=", "0", ";", "<if", "type=\"elseif\">", "else", "if", "(", "pos_neg0", "==", "2", ")", "op0_sign", "=", "-", "1", ";", "if", "(", "pos_neg1", "==", "1", ")", "op1_sign", "=", "0", ";", "<if", "type=\"elseif\">", "else", "if", "(", "pos_neg1", "==", "2", ")", "op1_sign", "=", "-", "1", ";", "unsigned", "int", "mprec0", "=", "prec", ";", "if", "(", "arg0", "!=", "error_mark_node", ")", "mprec0", "=", "get_min_precision", "(", "arg0", ",", "sign", ")", ";", "if", "(", "mprec0", "<=", "hprec", ")", "op0_small_p", "=", "true", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "uns", "&&", "mprec0", "<=", "hprec", "+", "1", ")", "op0_medium_p", "=", "true", ";", "unsigned", "int", "mprec1", "=", "prec", ";", "if", "(", "arg1", "!=", "error_mark_node", ")", "mprec1", "=", "get_min_precision", "(", "arg1", ",", "sign", ")", ";", "if", "(", "mprec1", "<=", "hprec", ")", "op1_small_p", "=", "true", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "uns", "&&", "mprec1", "<=", "hprec", "+", "1", ")", "op1_medium_p", "=", "true", ";", "int", "smaller_sign", "=", "1", ";", "int", "larger_sign", "=", "1", ";", "if", "(", "op0_small_p", ")", "{", "smaller_sign", "=", "op0_sign", ";", "larger_sign", "=", "op1_sign", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "op1_small_p", ")", "{", "smaller_sign", "=", "op1_sign", ";", "larger_sign", "=", "op0_sign", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "op0_sign", "==", "op1_sign", ")", "{", "smaller_sign", "=", "op0_sign", ";", "larger_sign", "=", "op0_sign", ";", "}", "if", "(", "!", "op0_small_p", ")", "do_compare_rtx_and_jump", "(", "signbit0", ",", "hipart0", ",", "NE", ",", "true", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "large_op0", ",", "profile_probability", "::", "unlikely", "()", ")", ";", "if", "(", "!", "op1_small_p", ")", "do_compare_rtx_and_jump", "(", "signbit1", ",", "hipart1", ",", "NE", ",", "true", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "small_op0_large_op1", ",", "profile_probability", "::", "unlikely", "()", ")", ";", "/*", "If", "both", "op0", "and", "op1", "are", "sign", "(!uns)", "or", "zero", "(uns)", "extended", "from", "hmode", "to", "mode,", "the", "multiplication", "will", "never", "overflow.", "We", "can", "do", "just", "one", "hmode", "x", "hmode", "=>", "mode", "widening", "multiplication.", "*/", "rtx", "lopart0s", "=", "lopart0", ",", "<type", "ref=\"prev\"/>", "lopart1s", "=", "lopart1", ";", "if", "(", "GET_CODE", "(", "lopart0", ")", "==", "SUBREG", ")", "{", "lopart0s", "=", "shallow_copy_rtx", "(", "lopart0", ")", ";", "SUBREG_PROMOTED_VAR_P", "(", "lopart0s", ")", "=", "1", ";", "SUBREG_PROMOTED_SET", "(", "lopart0s", ",", "uns", "?", "SRP_UNSIGNED", ":", "SRP_SIGNED", ")", ";", "}", "if", "(", "GET_CODE", "(", "lopart1", ")", "==", "SUBREG", ")", "{", "lopart1s", "=", "shallow_copy_rtx", "(", "lopart1", ")", ";", "SUBREG_PROMOTED_VAR_P", "(", "lopart1s", ")", "=", "1", ";", "SUBREG_PROMOTED_SET", "(", "lopart1s", ",", "uns", "?", "SRP_UNSIGNED", ":", "SRP_SIGNED", ")", ";", "}", "tree", "halfstype", "=", "build_nonstandard_integer_type", "(", "hprec", ",", "uns", ")", ";", "ops", ".", "op0", "=", "make_tree", "(", "halfstype", ",", "lopart0s", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "halfstype", ",", "lopart1s", ")", ";", "ops", ".", "code", "=", "WIDEN_MULT_EXPR", ";", "ops", ".", "type", "=", "type", ";", "rtx", "thisres", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "emit_move_insn", "(", "res", ",", "thisres", ")", ";", "emit_jump", "(", "done_label", ")", ";", "emit_label", "(", "small_op0_large_op1", ")", ";", "/*", "If", "op0", "is", "sign", "(!uns)", "or", "zero", "(uns)", "extended", "from", "hmode", "to", "mode,", "but", "op1", "is", "not,", "just", "swap", "the", "arguments", "and", "handle", "it", "as", "op1", "sign/zero", "extended,", "op0", "not.", "*/", "rtx", "larger", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "hipart", "=", "gen_reg_rtx", "(", "hmode", ")", ";", "rtx", "lopart", "=", "gen_reg_rtx", "(", "hmode", ")", ";", "emit_move_insn", "(", "larger", ",", "op1", ")", ";", "emit_move_insn", "(", "hipart", ",", "hipart1", ")", ";", "emit_move_insn", "(", "lopart", ",", "lopart0", ")", ";", "emit_jump", "(", "one_small_one_large", ")", ";", "emit_label", "(", "large_op0", ")", ";", "if", "(", "!", "op1_small_p", ")", "do_compare_rtx_and_jump", "(", "signbit1", ",", "hipart1", ",", "NE", ",", "true", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "both_ops_large", ",", "profile_probability", "::", "unlikely", "()", ")", ";", "/*", "If", "op1", "is", "sign", "(!uns)", "or", "zero", "(uns)", "extended", "from", "hmode", "to", "mode,", "but", "op0", "is", "not,", "prepare", "larger,", "hipart", "and", "lopart", "pseudos", "and", "handle", "it", "together", "with", "small_op0_large_op1.", "*/", "emit_move_insn", "(", "larger", ",", "op0", ")", ";", "emit_move_insn", "(", "hipart", ",", "hipart0", ")", ";", "emit_move_insn", "(", "lopart", ",", "lopart1", ")", ";", "emit_label", "(", "one_small_one_large", ")", ";", "/*", "lopart", "is", "the", "low", "part", "of", "the", "operand", "that", "is", "sign", "extended", "to", "mode,", "larger", "is", "the", "other", "operand,", "hipart", "is", "the", "high", "part", "of", "larger", "and", "lopart0", "and", "lopart1", "are", "the", "low", "parts", "of", "both", "operands.", "We", "perform", "lopart0", "*", "lopart1", "and", "lopart", "*", "hipart", "widening", "multiplications.", "*/", "tree", "halfutype", "=", "build_nonstandard_integer_type", "(", "hprec", ",", "1", ")", ";", "ops", ".", "op0", "=", "make_tree", "(", "halfutype", ",", "lopart0", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "halfutype", ",", "lopart1", ")", ";", "rtx", "lo0xlo1", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "ops", ".", "op0", "=", "make_tree", "(", "halfutype", ",", "lopart", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "halfutype", ",", "hipart", ")", ";", "rtx", "loxhi", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "tem", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "emit_move_insn", "(", "loxhi", ",", "tem", ")", ";", "if", "(", "!", "uns", ")", "{", "/*", "if", "(hipart", "<", "0)", "loxhi", "-=", "lopart", "<<", "(bitsize", "/", "2);", "*/", "if", "(", "larger_sign", "==", "0", ")", "emit_jump", "(", "after_hipart_neg", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "larger_sign", "!=", "-", "1", ")", "do_compare_rtx_and_jump", "(", "hipart", ",", "const0_rtx", ",", "GE", ",", "false", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "after_hipart_neg", ",", "profile_probability", "::", "even", "()", ")", ";", "tem", "=", "convert_modes", "(", "mode", ",", "hmode", ",", "lopart", ",", "1", ")", ";", "tem", "=", "expand_shift", "(", "LSHIFT_EXPR", ",", "mode", ",", "tem", ",", "hprec", ",", "NULL_RTX", ",", "1", ")", ";", "tem", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "loxhi", ",", "tem", ",", "NULL_RTX", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "loxhi", ",", "tem", ")", ";", "emit_label", "(", "after_hipart_neg", ")", ";", "/*", "if", "(lopart", "<", "0)", "loxhi", "-=", "larger;", "*/", "if", "(", "smaller_sign", "==", "0", ")", "emit_jump", "(", "after_lopart_neg", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "smaller_sign", "!=", "-", "1", ")", "do_compare_rtx_and_jump", "(", "lopart", ",", "const0_rtx", ",", "GE", ",", "false", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "after_lopart_neg", ",", "profile_probability", "::", "even", "()", ")", ";", "tem", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "loxhi", ",", "larger", ",", "NULL_RTX", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "loxhi", ",", "tem", ")", ";", "emit_label", "(", "after_lopart_neg", ")", ";", "}", "/*", "loxhi", "+=", "(uns)", "lo0xlo1", ">>", "(bitsize", "/", "2);", "*/", "tem", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "mode", ",", "lo0xlo1", ",", "hprec", ",", "NULL_RTX", ",", "1", ")", ";", "tem", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "loxhi", ",", "tem", ",", "NULL_RTX", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "loxhi", ",", "tem", ")", ";", "/*", "if", "(loxhi", ">>", "(bitsize", "/", "2)", "==", "(hmode)", "loxhi", ">>", "(bitsize", "/", "2", "-", "1))", "(if", "!uns)", "if", "(loxhi", ">>", "(bitsize", "/", "2)", "==", "0", "(if", "uns).", "*/", "rtx", "hipartloxhi", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "mode", ",", "loxhi", ",", "hprec", ",", "NULL_RTX", ",", "0", ")", ";", "hipartloxhi", "=", "convert_modes", "(", "hmode", ",", "mode", ",", "hipartloxhi", ",", "0", ")", ";", "rtx", "signbitloxhi", "=", "const0_rtx", ";", "if", "(", "!", "uns", ")", "signbitloxhi", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "hmode", ",", "convert_modes", "(", "hmode", ",", "mode", ",", "loxhi", ",", "0", ")", ",", "hprec", "-", "1", ",", "NULL_RTX", ",", "0", ")", ";", "do_compare_rtx_and_jump", "(", "signbitloxhi", ",", "hipartloxhi", ",", "NE", ",", "true", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "do_overflow", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "/*", "res", "=", "(loxhi", "<<", "(bitsize", "/", "2))", "|", "(hmode)", "lo0xlo1;", "*/", "rtx", "loxhishifted", "=", "expand_shift", "(", "LSHIFT_EXPR", ",", "mode", ",", "loxhi", ",", "hprec", ",", "NULL_RTX", ",", "1", ")", ";", "tem", "=", "convert_modes", "(", "mode", ",", "hmode", ",", "convert_modes", "(", "hmode", ",", "mode", ",", "lo0xlo1", ",", "1", ")", ",", "1", ")", ";", "tem", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "loxhishifted", ",", "tem", ",", "res", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "if", "(", "tem", "!=", "res", ")", "emit_move_insn", "(", "res", ",", "tem", ")", ";", "emit_jump", "(", "done_label", ")", ";", "emit_label", "(", "both_ops_large", ")", ";", "/*", "If", "both", "operands", "are", "large", "(not", "sign", "(!uns)", "or", "zero", "(uns)", "extended", "from", "hmode),", "then", "perform", "the", "full", "multiplication", "which", "will", "be", "the", "result", "of", "the", "operation.", "The", "only", "cases", "which", "don\\'t", "overflow", "are", "for", "signed", "multiplication", "some", "cases", "where", "both", "hipart0", "and", "highpart1", "are", "0", "or", "-1.", "For", "unsigned", "multiplication", "when", "high", "parts", "are", "both", "non-zero", "this", "overflows", "always.", "*/", "ops", ".", "code", "=", "MULT_EXPR", ";", "ops", ".", "op0", "=", "make_tree", "(", "type", ",", "op0", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "type", ",", "op1", ")", ";", "tem", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "emit_move_insn", "(", "res", ",", "tem", ")", ";", "if", "(", "!", "uns", ")", "{", "if", "(", "!", "op0_medium_p", ")", "{", "tem", "=", "expand_simple_binop", "(", "hmode", ",", "PLUS", ",", "hipart0", ",", "const1_rtx", ",", "NULL_RTX", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "do_compare_rtx_and_jump", "(", "tem", ",", "const1_rtx", ",", "GTU", ",", "true", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "do_error", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "}", "if", "(", "!", "op1_medium_p", ")", "{", "tem", "=", "expand_simple_binop", "(", "hmode", ",", "PLUS", ",", "hipart1", ",", "const1_rtx", ",", "NULL_RTX", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "do_compare_rtx_and_jump", "(", "tem", ",", "const1_rtx", ",", "GTU", ",", "true", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "do_error", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "}", "/*", "At", "this", "point", "hipart{0,1}", "are", "both", "in", "[-1,", "0].", "If", "they", "are", "the", "same,", "overflow", "happened", "if", "res", "is", "non-positive,", "if", "they", "are", "different,", "overflow", "happened", "if", "res", "is", "positive.", "*/", "if", "(", "op0_sign", "!=", "1", "&&", "op1_sign", "!=", "1", "&&", "op0_sign", "!=", "op1_sign", ")", "emit_jump", "(", "hipart_different", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "op0_sign", "==", "1", "||", "op1_sign", "==", "1", ")", "do_compare_rtx_and_jump", "(", "hipart0", ",", "hipart1", ",", "NE", ",", "true", ",", "hmode", ",", "NULL_RTX", ",", "NULL", ",", "hipart_different", ",", "profile_probability", "::", "even", "()", ")", ";", "do_compare_rtx_and_jump", "(", "res", ",", "const0_rtx", ",", "LE", ",", "false", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "do_error", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "emit_jump", "(", "done_label", ")", ";", "emit_label", "(", "hipart_different", ")", ";", "do_compare_rtx_and_jump", "(", "res", ",", "const0_rtx", ",", "GE", ",", "false", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "do_error", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "emit_jump", "(", "done_label", ")", ";", "}", "emit_label", "(", "do_overflow", ")", ";", "/*", "Overflow,", "do", "full", "multiplication", "and", "fallthru", "into", "do_error.", "*/", "ops", ".", "op0", "=", "make_tree", "(", "type", ",", "op0", ")", ";", "ops", ".", "op1", "=", "make_tree", "(", "type", ",", "op1", ")", ";", "tem", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "emit_move_insn", "(", "res", ",", "tem", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "GET_MODE_2XWIDER_MODE", "(", "mode", ")", ".", "exists", "(", "&", "wmode", ")", "&&", "targetm", ".", "scalar_mode_supported_p", "(", "wmode", ")", ")", "/*", "Even", "emitting", "a", "libcall", "is", "better", "than", "not", "detecting", "overflow", "at", "all.", "*/", "goto", "twoxwider", ";", "else", "{", "gcc_assert", "(", "!", "is_ubsan", ")", ";", "ops", ".", "code", "=", "MULT_EXPR", ";", "ops", ".", "type", "=", "type", ";", "res", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "emit_jump", "(", "done_label", ")", ";", "}", "}", "do_error_label", ":", "emit_label", "(", "do_error", ")", ";", "if", "(", "is_ubsan", ")", "{", "/*", "Expand", "the", "ubsan", "builtin", "call.", "*/", "push_temp_slots", "()", ";", "fn", "=", "ubsan_build_overflow_builtin", "(", "MULT_EXPR", ",", "loc", ",", "TREE_TYPE", "(", "arg0", ")", ",", "arg0", ",", "arg1", ",", "datap", ")", ";", "expand_normal", "(", "fn", ")", ";", "pop_temp_slots", "()", ";", "do_pending_stack_adjust", "()", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "lhs", ")", "expand_arith_set_overflow", "(", "lhs", ",", "target", ")", ";", "/*", "We\\'re", "done.", "*/", "emit_label", "(", "done_label", ")", ";", "/*", "u1", "*", "u2", "->", "sr", "*/", "if", "(", "uns0_p", "&&", "uns1_p", "&&", "!", "unsr_p", ")", "{", "rtx_code_label", "*", "all_done_label", "=", "gen_label_rtx", "()", ";", "do_compare_rtx_and_jump", "(", "res", ",", "const0_rtx", ",", "GE", ",", "false", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "all_done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "expand_arith_set_overflow", "(", "lhs", ",", "target", ")", ";", "emit_label", "(", "all_done_label", ")", ";", "}", "/*", "s1", "*", "u2", "->", "sr", "*/", "if", "(", "!", "uns0_p", "&&", "uns1_p", "&&", "!", "unsr_p", "&&", "pos_neg1", "==", "3", ")", "{", "rtx_code_label", "*", "all_done_label", "=", "gen_label_rtx", "()", ";", "rtx_code_label", "*", "set_noovf", "=", "gen_label_rtx", "()", ";", "do_compare_rtx_and_jump", "(", "op1", ",", "const0_rtx", ",", "GE", ",", "false", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "all_done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "expand_arith_set_overflow", "(", "lhs", ",", "target", ")", ";", "do_compare_rtx_and_jump", "(", "op0", ",", "const0_rtx", ",", "EQ", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "set_noovf", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "do_compare_rtx_and_jump", "(", "op0", ",", "constm1_rtx", ",", "NE", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "all_done_label", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "do_compare_rtx_and_jump", "(", "op1", ",", "res", ",", "NE", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "all_done_label", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "emit_label", "(", "set_noovf", ")", ";", "write_complex_part", "(", "target", ",", "const0_rtx", ",", "true", ")", ";", "emit_label", "(", "all_done_label", ")", ";", "}", "if", "(", "lhs", ")", "{", "if", "(", "is_ubsan", ")", "expand_ubsan_result_store", "(", "target", ",", "res", ")", ";", "else", "expand_arith_overflow_result_store", "(", "lhs", ",", "target", ",", "mode", ",", "res", ")", ";", "}", "}'" ]

[ "Expand", "atomic", "bit", "test", "and", "reset" ]

[ "'static", "void", "expand_ATOMIC_BIT_TEST_AND_RESET", "(", "internal_fn", ",", "gcall", "*", "call", ")", "{", "expand_ifn_atomic_bit_test_and", "(", "call", ")", ";", "}'" ]

[ "Expand", "MASK_LOAD{,_LANES}", "call", "STMT", "using", "optab", "OPTAB" ]

[ "'static", "void", "expand_mask_load_optab_fn", "(", "internal_fn", ",", "gcall", "*", "stmt", ",", "convert_optab", "optab", ")", "{", "struct", "expand_operand", "ops", "[", "3", "]", ";", "tree", "type", ",", "<type", "ref=\"prev\"/>", "lhs", ",", "<type", "ref=\"prev\"/>", "rhs", ",", "<type", "ref=\"prev\"/>", "maskt", ";", "rtx", "mem", ",", "<type", "ref=\"prev\"/>", "target", ",", "<type", "ref=\"prev\"/>", "mask", ";", "insn_code", "icode", ";", "maskt", "=", "gimple_call_arg", "(", "stmt", ",", "2", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "if", "(", "lhs", "==", "NULL_TREE", ")", "return", ";", "type", "=", "TREE_TYPE", "(", "lhs", ")", ";", "rhs", "=", "expand_call_mem_ref", "(", "type", ",", "stmt", ",", "0", ")", ";", "if", "(", "optab", "==", "vec_mask_load_lanes_optab", ")", "icode", "=", "get_multi_vector_move", "(", "type", ",", "optab", ")", ";", "else", "icode", "=", "convert_optab_handler", "(", "optab", ",", "TYPE_MODE", "(", "type", ")", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "maskt", ")", ")", ")", ";", "mem", "=", "expand_expr", "(", "rhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mask", "=", "expand_normal", "(", "maskt", ")", ";", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "TYPE_MODE", "(", "type", ")", ")", ";", "create_fixed_operand", "(", "&", "ops", "[", "1", "]", ",", "mem", ")", ";", "create_input_operand", "(", "&", "ops", "[", "2", "]", ",", "mask", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "maskt", ")", ")", ")", ";", "expand_insn", "(", "icode", ",", "3", ",", "ops", ")", ";", "}'" ]

[ "This", "is", "expanded", "by", "oacc_device_lower", "pass" ]

[ "'static", "void", "expand_GOACC_TILE", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "is", "expanded", "by", "oacc_device_lower", "pass" ]

[ "'static", "void", "expand_GOACC_REDUCTION", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "The", "position", "of", "an", "OpenACC", "execution", "engine", "along", "one", "compute", "axis" ]

[ "'static", "void", "expand_GOACC_DIM_POS", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "if", "(", "!", "lhs", ")", "return", ";", "rtx", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "if", "(", "targetm", ".", "have_oacc_dim_pos", "()", ")", "{", "rtx", "dim", "=", "expand_expr", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "emit_insn", "(", "targetm", ".", "gen_oacc_dim_pos", "(", "target", ",", "dim", ")", ")", ";", "}", "else", "emit_move_insn", "(", "target", ",", "const0_rtx", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "omp_device_lower", "pass" ]

[ "'static", "void", "expand_GOMP_SIMT_ENTER", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Return", "the", "optab", "used", "by", "internal", "function", "FN" ]

[ "'static", "optab", "direct_internal_fn_optab", "(", "internal_fn", "fn", ")", "{", "switch", "(", "fn", ")", "{", "#", "define", "DEF_INTERNAL_FN", "(", "CODE", ",", "FLAGS", ",", "FNSPEC", ")", "\\\\", "case", "IFN_##CODE:", "break;", "#", "define", "DEF_INTERNAL_OPTAB_FN", "(", "CODE", ",", "FLAGS", ",", "OPTAB", ",", "TYPE", ")", "\\\\", "case", "IFN_##CODE:", "return", "OPTAB##_optab;", "#", "include", "\"internal-fn.def\"", "case", "IFN_LAST", ":", "break;", "}", "gcc_unreachable", "()", ";", "}'" ]

[ "Expand", "UBSAN_CHECK_MUL", "call", "STMT" ]

[ "'static", "void", "expand_UBSAN_CHECK_MUL", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "location_t", "loc", "=", "gimple_location", "(", "stmt", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "0", ")", ";", "tree", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "1", ")", ";", "if", "(", "VECTOR_TYPE_P", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", "expand_vector_ubsan_overflow", "(", "loc", ",", "MULT_EXPR", ",", "lhs", ",", "arg0", ",", "arg1", ")", ";", "else", "expand_mul_overflow", "(", "loc", ",", "lhs", ",", "arg0", ",", "arg1", ",", "false", ",", "false", ",", "false", ",", "true", ",", "NULL", ")", ";", "}'" ]

[ "Return", "true", "if", "IFN_SET_EDOM", "is", "supported" ]

[ "'bool", "set_edom_supported_p", "(", "void", ")", "{", "#", "ifdef", "TARGET_EDOM", "return", "true", ";", "#", "else", "return", "false", ";", "#", "endif", "}'" ]

[ "Add", "negate", "overflow", "checking", "to", "the", "statement", "STMT" ]

[ "'static", "void", "expand_neg_overflow", "(", "location_t", "loc", ",", "tree", "lhs", ",", "tree", "arg1", ",", "bool", "is_ubsan", ",", "tree", "*", "datap", ")", "{", "rtx", "res", ",", "<type", "ref=\"prev\"/>", "op1", ";", "tree", "fn", ";", "rtx_code_label", "*", "done_label", ",", "<type", "ref=\"prev\">", "*", "do_error", ";", "rtx", "target", "=", "NULL_RTX", ";", "done_label", "=", "gen_label_rtx", "()", ";", "do_error", "=", "gen_label_rtx", "()", ";", "do_pending_stack_adjust", "()", ";", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "scalar_int_mode", "mode", "=", "SCALAR_INT_TYPE_MODE", "(", "TREE_TYPE", "(", "arg1", ")", ")", ";", "if", "(", "lhs", ")", "{", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "if", "(", "!", "is_ubsan", ")", "write_complex_part", "(", "target", ",", "const0_rtx", ",", "true", ")", ";", "}", "enum", "insn_code", "icode", "=", "optab_handler", "(", "negv3_optab", ",", "mode", ")", ";", "if", "(", "icode", "!=", "CODE_FOR_nothing", ")", "{", "struct", "expand_operand", "ops", "[", "3", "]", ";", "rtx_insn", "*", "last", "=", "get_last_insn", "()", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "res", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "op1", ",", "mode", ")", ";", "create_fixed_operand", "(", "&", "ops", "[", "2", "]", ",", "do_error", ")", ";", "if", "(", "maybe_expand_insn", "(", "icode", ",", "3", ",", "ops", ")", ")", "{", "last", "=", "get_last_insn", "()", ";", "if", "(", "profile_status_for_fn", "(", "cfun", ")", "!=", "PROFILE_ABSENT", "&&", "JUMP_P", "(", "last", ")", "&&", "any_condjump_p", "(", "last", ")", "&&", "!", "find_reg_note", "(", "last", ",", "REG_BR_PROB", ",", "0", ")", ")", "add_reg_br_prob_note", "(", "last", ",", "profile_probability", "::", "very_unlikely", "()", ")", ";", "emit_jump", "(", "done_label", ")", ";", "}", "else", "{", "delete_insns_since", "(", "last", ")", ";", "icode", "=", "CODE_FOR_nothing", ";", "}", "}", "if", "(", "icode", "==", "CODE_FOR_nothing", ")", "{", "/*", "Compute", "the", "operation.", "On", "RTL", "level,", "the", "addition", "is", "always", "unsigned.", "*/", "res", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "op1", ",", "NULL_RTX", ",", "false", ")", ";", "/*", "Compare", "the", "operand", "with", "the", "most", "negative", "value.", "*/", "rtx", "minv", "=", "expand_normal", "(", "TYPE_MIN_VALUE", "(", "TREE_TYPE", "(", "arg1", ")", ")", ")", ";", "do_compare_rtx_and_jump", "(", "op1", ",", "minv", ",", "NE", ",", "true", ",", "mode", ",", "NULL_RTX", ",", "NULL", ",", "done_label", ",", "profile_probability", "::", "very_likely", "()", ")", ";", "}", "emit_label", "(", "do_error", ")", ";", "if", "(", "is_ubsan", ")", "{", "/*", "Expand", "the", "ubsan", "builtin", "call.", "*/", "push_temp_slots", "()", ";", "fn", "=", "ubsan_build_overflow_builtin", "(", "NEGATE_EXPR", ",", "loc", ",", "TREE_TYPE", "(", "arg1", ")", ",", "arg1", ",", "NULL_TREE", ",", "datap", ")", ";", "expand_normal", "(", "fn", ")", ";", "pop_temp_slots", "()", ";", "do_pending_stack_adjust", "()", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "lhs", ")", "expand_arith_set_overflow", "(", "lhs", ",", "target", ")", ";", "/*", "We\\'re", "done.", "*/", "emit_label", "(", "done_label", ")", ";", "if", "(", "lhs", ")", "{", "if", "(", "is_ubsan", ")", "expand_ubsan_result_store", "(", "target", ",", "res", ")", ";", "else", "expand_arith_overflow_result_store", "(", "lhs", ",", "target", ",", "mode", ",", "res", ")", ";", "}", "}'" ]

[ "Expand", "the", "IFN_UNIQUE", "function", "according", "to", "its", "first", "argument" ]

[ "'static", "void", "expand_UNIQUE", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "rtx", "pattern", "=", "NULL_RTX", ";", "enum", "ifn_unique_kind", "kind", "=", "(", "enum", "ifn_unique_kind", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ")", ";", "switch", "(", "kind", ")", "{", "default:", "gcc_unreachable", "()", ";", "case", "IFN_UNIQUE_UNSPEC", ":", "if", "(", "targetm", ".", "have_unique", "()", ")", "pattern", "=", "targetm", ".", "gen_unique", "()", ";", "break;", "case", "IFN_UNIQUE_OACC_FORK", ":", "case", "IFN_UNIQUE_OACC_JOIN", ":", "if", "(", "targetm", ".", "have_oacc_fork", "()", "&&", "targetm", ".", "have_oacc_join", "()", ")", "{", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "rtx", "target", "=", "const0_rtx", ";", "if", "(", "lhs", ")", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "rtx", "data_dep", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "1", ")", ")", ";", "rtx", "axis", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "2", ")", ")", ";", "if", "(", "kind", "==", "IFN_UNIQUE_OACC_FORK", ")", "pattern", "=", "targetm", ".", "gen_oacc_fork", "(", "target", ",", "data_dep", ",", "axis", ")", ";", "else", "pattern", "=", "targetm", ".", "gen_oacc_join", "(", "target", ",", "data_dep", ",", "axis", ")", ";", "}", "else", "gcc_unreachable", "()", ";", "break;", "}", "if", "(", "pattern", ")", "emit_insn", "(", "pattern", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_UBSAN_VPTR", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "folded", "in", "treevectorizer" ]

[ "'static", "void", "expand_LOOP_VECTORIZED", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_ASAN_CHECK", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "adjust_simduid_builtins" ]

[ "'static", "void", "expand_GOMP_SIMD_ORDERED_START", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Exchange", "between", "SIMT", "lanes", "according", "to", "given", "source", "lane", "index" ]

[ "'static", "void", "expand_GOMP_SIMT_XCHG_IDX", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "if", "(", "!", "lhs", ")", "return", ";", "rtx", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "rtx", "src", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ")", ";", "rtx", "idx", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "1", ")", ")", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "lhs", ")", ")", ";", "struct", "expand_operand", "ops", "[", "3", "]", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "src", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "2", "]", ",", "idx", ",", "SImode", ")", ";", "gcc_assert", "(", "targetm", ".", "have_omp_simt_xchg_idx", "()", ")", ";", "expand_insn", "(", "targetm", ".", "code_for_omp_simt_xchg_idx", ",", "3", ",", "ops", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_UBSAN_BOUNDS", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Expand", "atomic", "bit", "test", "and", "set" ]

[ "'static", "void", "expand_ATOMIC_BIT_TEST_AND_SET", "(", "internal_fn", ",", "gcall", "*", "call", ")", "{", "expand_ifn_atomic_bit_test_and", "(", "call", ")", ";", "}'" ]

[ "Return", "true", "if", "IFN", "is", "some", "form", "of", "store", "to", "memory" ]

[ "'bool", "internal_store_fn_p", "(", "internal_fn", "fn", ")", "{", "switch", "(", "fn", ")", "{", "case", "IFN_MASK_STORE", ":", "case", "IFN_STORE_LANES", ":", "case", "IFN_MASK_STORE_LANES", ":", "case", "IFN_SCATTER_STORE", ":", "case", "IFN_MASK_SCATTER_STORE", ":", "return", "true", ";", "default:", "return", "false", ";", "}", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_UBSAN_PTR", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_ASAN_POISON", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_ASAN_POISON_USE", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Return", "true", "if", "IFN", "is", "some", "form", "of", "load", "from", "memory" ]

[ "'bool", "internal_load_fn_p", "(", "internal_fn", "fn", ")", "{", "switch", "(", "fn", ")", "{", "case", "IFN_MASK_LOAD", ":", "case", "IFN_LOAD_LANES", ":", "case", "IFN_MASK_LOAD_LANES", ":", "case", "IFN_GATHER_LOAD", ":", "case", "IFN_MASK_GATHER_LOAD", ":", "return", "true", ";", "default:", "return", "false", ";", "}", "}'" ]

[ "This", "should", "get", "expanded", "in", "adjust_simduid_builtins" ]

[ "'static", "void", "expand_GOMP_SIMD_LAST_LANE", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Allocate", "perlane", "storage", "and", "begin", "nonuniform", "execution", "region" ]

[ "'static", "void", "expand_GOMP_SIMT_ENTER_ALLOC", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "rtx", "target", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "if", "(", "lhs", ")", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "else", "target", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "size", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ")", ";", "rtx", "align", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "1", ")", ")", ";", "struct", "expand_operand", "ops", "[", "3", "]", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "Pmode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "size", ",", "Pmode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "2", "]", ",", "align", ",", "Pmode", ")", ";", "gcc_assert", "(", "targetm", ".", "have_omp_simt_enter", "()", ")", ";", "expand_insn", "(", "targetm", ".", "code_for_omp_simt_enter", ",", "3", ",", "ops", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "adjust_simduid_builtins" ]

[ "'static", "void", "expand_GOMP_SIMD_VF", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "adjust_simduid_builtins" ]

[ "'static", "void", "expand_GOMP_SIMD_ORDERED_END", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Deallocate", "perlane", "storage", "and", "leave", "nonuniform", "execution", "region" ]

[ "'static", "void", "expand_GOMP_SIMT_EXIT", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "gcc_checking_assert", "(", "!", "gimple_call_lhs", "(", "stmt", ")", ")", ";", "rtx", "arg", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ")", ";", "struct", "expand_operand", "ops", "[", "1", "]", ";", "create_input_operand", "(", "&", "ops", "[", "0", "]", ",", "arg", ",", "Pmode", ")", ";", "gcc_assert", "(", "targetm", ".", "have_omp_simt_exit", "()", ")", ";", "expand_insn", "(", "targetm", ".", "code_for_omp_simt_exit", ",", "1", ",", "ops", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "adjust_simduid_builtins" ]

[ "'static", "void", "expand_GOMP_SIMD_LANE", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "is", "expanded", "by", "oacc_device_lower", "pass" ]

[ "'static", "void", "expand_GOACC_LOOP", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "omp_device_lower", "pass" ]

[ "'static", "void", "expand_GOMP_SIMT_VF", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "folded", "in", "treevectorizer" ]

[ "'static", "void", "expand_LOOP_DIST_ALIAS", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_UBSAN_OBJECT_SIZE", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Nontransparent", "predicate", "used", "in", "SIMT", "lowering", "of", "OpenMP", "\"ordered\"" ]

[ "'static", "void", "expand_GOMP_SIMT_ORDERED_PRED", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "if", "(", "!", "lhs", ")", "return", ";", "rtx", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "rtx", "ctr", "=", "expand_normal", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ")", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "lhs", ")", ")", ";", "struct", "expand_operand", "ops", "[", "2", "]", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "ctr", ",", "mode", ")", ";", "gcc_assert", "(", "targetm", ".", "have_omp_simt_ordered", "()", ")", ";", "expand_insn", "(", "targetm", ".", "code_for_omp_simt_ordered", ",", "2", ",", "ops", ")", ";", "}'" ]

[ "The", "size", "of", "an", "OpenACC", "compute", "dimension" ]

[ "'static", "void", "expand_GOACC_DIM_SIZE", "(", "internal_fn", ",", "gcall", "*", "stmt", ")", "{", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "if", "(", "!", "lhs", ")", "return", ";", "rtx", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "if", "(", "targetm", ".", "have_oacc_dim_size", "()", ")", "{", "rtx", "dim", "=", "expand_expr", "(", "gimple_call_arg", "(", "stmt", ",", "0", ")", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "emit_insn", "(", "targetm", ".", "gen_oacc_dim_size", "(", "target", ",", "dim", ")", ")", ";", "}", "else", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "1", ")", ")", ";", "}'" ]

[ "Helper", "function", "for", "{ADD,SUB,MUL}_OVERFLOW", "call", "stmt", "expansion" ]

[ "'static", "void", "expand_arith_overflow", "(", "enum", "tree_code", "code", ",", "gimple", "*", "stmt", ")", "{", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "if", "(", "lhs", "==", "NULL_TREE", ")", "return", ";", "tree", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "0", ")", ";", "tree", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "1", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "lhs", ")", ")", ";", "int", "uns0_p", "=", "TYPE_UNSIGNED", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "int", "uns1_p", "=", "TYPE_UNSIGNED", "(", "TREE_TYPE", "(", "arg1", ")", ")", ";", "int", "unsr_p", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "int", "prec0", "=", "TYPE_PRECISION", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "int", "prec1", "=", "TYPE_PRECISION", "(", "TREE_TYPE", "(", "arg1", ")", ")", ";", "int", "precres", "=", "TYPE_PRECISION", "(", "type", ")", ";", "location_t", "loc", "=", "gimple_location", "(", "stmt", ")", ";", "if", "(", "!", "uns0_p", "&&", "get_range_pos_neg", "(", "arg0", ")", "==", "1", ")", "uns0_p", "=", "true", ";", "if", "(", "!", "uns1_p", "&&", "get_range_pos_neg", "(", "arg1", ")", "==", "1", ")", "uns1_p", "=", "true", ";", "int", "pr", "=", "get_min_precision", "(", "arg0", ",", "uns0_p", "?", "UNSIGNED", ":", "SIGNED", ")", ";", "prec0", "=", "MIN", "(", "prec0", ",", "pr", ")", ";", "pr", "=", "get_min_precision", "(", "arg1", ",", "uns1_p", "?", "UNSIGNED", ":", "SIGNED", ")", ";", "prec1", "=", "MIN", "(", "prec1", ",", "pr", ")", ";", "/*", "If", "uns0_p", "&&", "uns1_p,", "precop", "is", "minimum", "needed", "precision", "of", "unsigned", "type", "to", "hold", "the", "exact", "result,", "otherwise", "precop", "is", "minimum", "needed", "precision", "of", "signed", "type", "to", "hold", "the", "exact", "result.", "*/", "int", "precop", ";", "if", "(", "code", "==", "MULT_EXPR", ")", "precop", "=", "prec0", "+", "prec1", "+", "(", "uns0_p", "!=", "uns1_p", ")", ";", "else", "{", "if", "(", "uns0_p", "==", "uns1_p", ")", "precop", "=", "MAX", "(", "prec0", ",", "prec1", ")", "+", "1", ";", "<if", "type=\"elseif\">", "else", "if", "(", "uns0_p", ")", "precop", "=", "MAX", "(", "prec0", "+", "1", ",", "prec1", ")", "+", "1", ";", "else", "precop", "=", "MAX", "(", "prec0", ",", "prec1", "+", "1", ")", "+", "1", ";", "}", "int", "orig_precres", "=", "precres", ";", "do", "{", "if", "(", "(", "uns0_p", "&&", "uns1_p", ")", "?", "(", "(", "precop", "+", "!", "unsr_p", ")", "<=", "precres", "/*", "u1", "-", "u2", "->", "ur", "can", "overflow,", "no", "matter", "what", "precision", "the", "result", "has.", "*/", "&&", "(", "code", "!=", "MINUS_EXPR", "||", "!", "unsr_p", ")", ")", ":", "(", "!", "unsr_p", "&&", "precop", "<=", "precres", ")", ")", "{", "/*", "The", "infinity", "precision", "result", "will", "always", "fit", "into", "result.", "*/", "rtx", "target", "=", "expand_expr", "(", "lhs", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_WRITE", ")", ";", "write_complex_part", "(", "target", ",", "const0_rtx", ",", "true", ")", ";", "scalar_int_mode", "mode", "=", "SCALAR_INT_TYPE_MODE", "(", "type", ")", ";", "struct", "separate_ops", "ops", ";", "ops", ".", "code", "=", "code", ";", "ops", ".", "type", "=", "type", ";", "ops", ".", "op0", "=", "fold_convert_loc", "(", "loc", ",", "type", ",", "arg0", ")", ";", "ops", ".", "op1", "=", "fold_convert_loc", "(", "loc", ",", "type", ",", "arg1", ")", ";", "ops", ".", "op2", "=", "NULL_TREE", ";", "ops", ".", "location", "=", "loc", ";", "rtx", "tem", "=", "expand_expr_real_2", "(", "&", "ops", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "expand_arith_overflow_result_store", "(", "lhs", ",", "target", ",", "mode", ",", "tem", ")", ";", "return", ";", "}", "/*", "For", "operations", "with", "low", "precision,", "if", "target", "doesn\\'t", "have", "them,", "start", "with", "precres", "widening", "right", "away,", "otherwise", "do", "it", "only", "if", "the", "most", "simple", "cases", "can\\'t", "be", "used.", "*/", "const", "int", "min_precision", "=", "targetm", ".", "min_arithmetic_precision", "()", ";", "if", "(", "orig_precres", "==", "precres", "&&", "precres", "<", "min_precision", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "(", "uns0_p", "&&", "uns1_p", "&&", "unsr_p", "&&", "prec0", "<=", "precres", "&&", "prec1", "<=", "precres", ")", "||", "(", "(", "!", "uns0_p", "||", "!", "uns1_p", ")", "&&", "!", "unsr_p", "&&", "prec0", "+", "uns0_p", "<=", "precres", "&&", "prec1", "+", "uns1_p", "<=", "precres", ")", ")", "{", "arg0", "=", "fold_convert_loc", "(", "loc", ",", "type", ",", "arg0", ")", ";", "arg1", "=", "fold_convert_loc", "(", "loc", ",", "type", ",", "arg1", ")", ";", "switch", "(", "code", ")", "{", "case", "MINUS_EXPR", ":", "if", "(", "integer_zerop", "(", "arg0", ")", "&&", "!", "unsr_p", ")", "{", "expand_neg_overflow", "(", "loc", ",", "lhs", ",", "arg1", ",", "false", ",", "NULL", ")", ";", "return", ";", "}", "/*", "FALLTHRU", "*/", "case", "PLUS_EXPR", ":", "expand_addsub_overflow", "(", "loc", ",", "code", ",", "lhs", ",", "arg0", ",", "arg1", ",", "unsr_p", ",", "unsr_p", ",", "unsr_p", ",", "false", ",", "NULL", ")", ";", "return", ";", "case", "MULT_EXPR", ":", "expand_mul_overflow", "(", "loc", ",", "lhs", ",", "arg0", ",", "arg1", ",", "unsr_p", ",", "unsr_p", ",", "unsr_p", ",", "false", ",", "NULL", ")", ";", "return", ";", "default:", "gcc_unreachable", "()", ";", "}", "}", "/*", "For", "sub-word", "operations,", "retry", "with", "a", "wider", "type", "first.", "*/", "if", "(", "orig_precres", "==", "precres", "&&", "precop", "<=", "BITS_PER_WORD", ")", "{", "int", "p", "=", "MAX", "(", "min_precision", ",", "precop", ")", ";", "scalar_int_mode", "m", "=", "smallest_int_mode_for_size", "(", "p", ")", ";", "tree", "optype", "=", "build_nonstandard_integer_type", "(", "GET_MODE_PRECISION", "(", "m", ")", ",", "uns0_p", "&&", "uns1_p", "&&", "unsr_p", ")", ";", "p", "=", "TYPE_PRECISION", "(", "optype", ")", ";", "if", "(", "p", ">", "precres", ")", "{", "precres", "=", "p", ";", "unsr_p", "=", "TYPE_UNSIGNED", "(", "optype", ")", ";", "type", "=", "optype", ";", "continue;", "}", "}", "if", "(", "prec0", "<=", "precres", "&&", "prec1", "<=", "precres", ")", "{", "tree", "types", "[", "2", "]", ";", "if", "(", "unsr_p", ")", "{", "types", "[", "0", "]", "=", "build_nonstandard_integer_type", "(", "precres", ",", "0", ")", ";", "types", "[", "1", "]", "=", "type", ";", "}", "else", "{", "types", "[", "0", "]", "=", "type", ";", "types", "[", "1", "]", "=", "build_nonstandard_integer_type", "(", "precres", ",", "1", ")", ";", "}", "arg0", "=", "fold_convert_loc", "(", "loc", ",", "types", "[", "uns0_p", "]", ",", "arg0", ")", ";", "arg1", "=", "fold_convert_loc", "(", "loc", ",", "types", "[", "uns1_p", "]", ",", "arg1", ")", ";", "if", "(", "code", "!=", "MULT_EXPR", ")", "expand_addsub_overflow", "(", "loc", ",", "code", ",", "lhs", ",", "arg0", ",", "arg1", ",", "unsr_p", ",", "uns0_p", ",", "uns1_p", ",", "false", ",", "NULL", ")", ";", "else", "expand_mul_overflow", "(", "loc", ",", "lhs", ",", "arg0", ",", "arg1", ",", "unsr_p", ",", "uns0_p", ",", "uns1_p", ",", "false", ",", "NULL", ")", ";", "return", ";", "}", "/*", "Retry", "with", "a", "wider", "type.", "*/", "if", "(", "orig_precres", "==", "precres", ")", "{", "int", "p", "=", "MAX", "(", "prec0", ",", "prec1", ")", ";", "scalar_int_mode", "m", "=", "smallest_int_mode_for_size", "(", "p", ")", ";", "tree", "optype", "=", "build_nonstandard_integer_type", "(", "GET_MODE_PRECISION", "(", "m", ")", ",", "uns0_p", "&&", "uns1_p", "&&", "unsr_p", ")", ";", "p", "=", "TYPE_PRECISION", "(", "optype", ")", ";", "if", "(", "p", ">", "precres", ")", "{", "precres", "=", "p", ";", "unsr_p", "=", "TYPE_UNSIGNED", "(", "optype", ")", ";", "type", "=", "optype", ";", "continue;", "}", "}", "gcc_unreachable", "()", ";", "}", "while", "(", "1", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "sanopt", "pass" ]

[ "'static", "void", "expand_ASAN_MARK", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "Expand", "LAUNDER", "to", "assignment,", "lhs", "arg0" ]

[ "'static", "void", "expand_LAUNDER", "(", "internal_fn", ",", "gcall", "*", "call", ")", "{", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "if", "(", "!", "lhs", ")", "return", ";", "expand_assignment", "(", "lhs", ",", "gimple_call_arg", "(", "call", ",", "0", ")", ",", "false", ")", ";", "}'" ]

[ "Expand", "atomic", "bit", "test", "and", "set" ]

[ "'static", "void", "expand_ATOMIC_COMPARE_EXCHANGE", "(", "internal_fn", ",", "gcall", "*", "call", ")", "{", "expand_ifn_atomic_compare_exchange", "(", "call", ")", ";", "}'" ]

[ "Return", "true", "if", "IFN", "is", "some", "form", "of", "gather", "load", "or", "scatter", "store" ]

[ "'bool", "internal_gather_scatter_fn_p", "(", "internal_fn", "fn", ")", "{", "switch", "(", "fn", ")", "{", "case", "IFN_GATHER_LOAD", ":", "case", "IFN_MASK_GATHER_LOAD", ":", "case", "IFN_SCATTER_STORE", ":", "case", "IFN_MASK_SCATTER_STORE", ":", "return", "true", ";", "default:", "return", "false", ";", "}", "}'" ]

[ "Expand", "STMT,", "which", "is", "a", "call", "to", "internal", "function", "FN" ]

[ "'void", "expand_internal_call", "(", "gcall", "*", "stmt", ")", "{", "expand_internal_call", "(", "gimple_call_internal_fn", "(", "stmt", ")", ",", "stmt", ")", ";", "}'" ]

[ "Expand", "atomic", "bit", "test", "and", "complement" ]

[ "'static", "void", "expand_ATOMIC_BIT_TEST_AND_COMPLEMENT", "(", "internal_fn", ",", "gcall", "*", "call", ")", "{", "expand_ifn_atomic_bit_test_and", "(", "call", ")", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "tsan", "pass" ]

[ "'static", "void", "expand_TSAN_FUNC_EXIT", "(", "internal_fn", ",", "gcall", "*", ")", "{", "gcc_unreachable", "()", ";", "}'" ]

[ "This", "should", "get", "expanded", "in", "the", "lower", "pass" ]

[ "'static", "void", "expand_FALLTHROUGH", "(", "internal_fn", ",", "gcall", "*", "call", ")", "{", "error_at", "(", "gimple_location", "(", "call", ")", ",", "\"invalid", "use", "of", "attribute", "%<fallthrough%>\"", ")", ";", "}'" ]

[ "Store", "the", "last", "item", "that", "was", "added", "with", "'+'" ]

[ "'void", "set_last_added_item", "(", "last_added_item_t", "type", ",", "void", "*", "item", ")", "{", "Scr", ".", "last_added_item", ".", "type", "=", "type", ";", "Scr", ".", "last_added_item", ".", "item", "=", "item", ";", "return", ";", "}'" ]

[ "some", "fancy", "font", "handling", "stuff" ]

[ "'void", "NewFontAndColor", "(", "FlocaleFont", "*", "flf", ",", "Pixel", "color", ",", "Pixel", "backcolor", ")", "{", "Globalgcm", "=", "GCForeground", "|", "GCBackground", ";", "if", "(", "flf", "->", "font", ")", "{", "Globalgcm", "|=", "GCFont", ";", "Globalgcv", ".", "font", "=", "flf", "->", "font", "->", "fid", ";", "}", "Globalgcv", ".", "foreground", "=", "color", ";", "Globalgcv", ".", "background", "=", "backcolor", ";", "XChangeGC", "(", "dpy", ",", "Scr", ".", "TitleGC", ",", "Globalgcm", ",", "&", "Globalgcv", ")", ";", "return", ";", "}'" ]

[ "returns", "the", "FvwmWindow", "that", "contains", "the", "pointer", "or", "NULL", "if", "none" ]

[ "'FvwmWindow", "*", "get_pointer_fvwm_window", "(", "void", ")", "{", "int", "x", ",", "<type", "ref=\"prev\"/>", "y", ";", "Window", "win", ";", "Window", "ancestor", ";", "FvwmWindow", "*", "t", ";", "if", "(", "FQueryPointer", "(", "dpy", ",", "Scr", ".", "Root", ",", "&", "JunkRoot", ",", "&", "win", ",", "&", "JunkX", ",", "&", "JunkY", ",", "&", "x", ",", "&", "y", ",", "&", "JunkMask", ")", "==", "False", ")", "{", "/*", "pointer", "is", "on", "a", "different", "screen", "*/", "return", "NULL", ";", "}", "for", "(", "t", "=", "NULL", ";", "win", "!=", "Scr", ".", "Root", "&&", "win", "!=", "None", ";", "win", "=", "ancestor", ")", "{", "Window", "root", "=", "None", ";", "Window", "*", "children", ";", "unsigned", "int", "nchildren", ";", "if", "(", "XFindContext", "(", "dpy", ",", "win", ",", "FvwmContext", ",", "(", "caddr_t", "*", ")", "&", "t", ")", "!=", "XCNOENT", ")", "{", "/*", "found", "a", "matching", "window", "context", "*/", "return", "t", ";", "}", "/*", "get", "next", "higher", "ancestor", "window", "*/", "children", "=", "NULL", ";", "if", "(", "!", "XQueryTree", "(", "dpy", ",", "win", ",", "&", "root", ",", "&", "ancestor", ",", "&", "children", ",", "&", "nchildren", ")", ")", "{", "return", "NULL", ";", "}", "if", "(", "children", ")", "{", "XFree", "(", "children", ")", ";", "}", "}", "return", "t", ";", "}'" ]

[ "Returns", "the", "current", "X", "server", "time" ]

[ "'Time", "get_server_time", "(", "void", ")", "{", "XEvent", "xev", ";", "XSetWindowAttributes", "attr", ";", "/*", "add", "PropChange", "to", "NoFocusWin", "events", "*/", "attr", ".", "event_mask", "=", "PropertyChangeMask", ";", "XChangeWindowAttributes", "(", "dpy", ",", "Scr", ".", "NoFocusWin", ",", "CWEventMask", ",", "&", "attr", ")", ";", "/*", "provoke", "an", "event", "*/", "XChangeProperty", "(", "dpy", ",", "Scr", ".", "NoFocusWin", ",", "XA_WM_CLASS", ",", "XA_STRING", ",", "8", ",", "PropModeAppend", ",", "NULL", ",", "0", ")", ";", "FWindowEvent", "(", "dpy", ",", "Scr", ".", "NoFocusWin", ",", "PropertyChangeMask", ",", "&", "xev", ")", ";", "attr", ".", "event_mask", "=", "XEVMASK_NOFOCUSW", ";", "XChangeWindowAttributes", "(", "dpy", ",", "Scr", ".", "NoFocusWin", ",", "CWEventMask", ",", "&", "attr", ")", ";", "return", "xev", ".", "xproperty", ".", "time", ";", "}'" ]

[ "callback", "for", "Prefences", "command" ]

[ "'void", "preferences_change", "(", "GtkAction", "*", "action", ",", "DenemoScriptParam", "*", "param", ")", "{", "DenemoProject", "*", "gui", "=", "Denemo", ".", "project", ";", "GtkWidget", "*", "dialog", ";", "GtkWidget", "*", "label", ";", "GtkWidget", "*", "separator", ";", "GtkWidget", "*", "main_vbox", ";", "GtkWidget", "*", "autosave", ";", "GtkWidget", "*", "autosave_timeout", ";", "//", "GtkWidget", "*tooltip_timeout;", "//", "GtkWidget", "*tooltip_browse_timeout;", "//", "GtkWidget", "*tooltip_browse_mode_timeout;", "//", "GtkWidget", "*maxhistory;", "GtkWidget", "*", "notebook", ";", "GtkWidget", "*", "hbox", ";", "#", "ifdef", "_HAVE_JACK_", "GtkWidget", "*", "jack_audio_settings", ";", "GtkWidget", "*", "jack_midi_settings", ";", "#", "endif", "#", "ifdef", "_HAVE_PORTAUDIO_", "GtkWidget", "*", "portaudio_settings", ";", "#", "endif", "#", "ifdef", "_HAVE_PORTMIDI_", "GtkWidget", "*", "portmidi_settings", ";", "#", "endif", "GList", "*", "g", ";", "gint", "i", ";", "static", "struct", "callbackdata", "cbdata", ";", "//g_assert", "(gui", "!=", "NULL);", "cbdata", ".", "audio_backend_list", "=", "NULL", ";", "cbdata", ".", "audio_driver_option_list", "=", "NULL", ";", "cbdata", ".", "midi_backend_list", "=", "NULL", ";", "cbdata", ".", "midi_driver_option_list", "=", "NULL", ";", "//", "these", "lists", "need", "to", "be", "initialized", "the", "first", "time", "this", "function", "is", "called", "//", "The", "order", "is", "chose", "to", "default", "to", "portaudio,", "alsa,", "jack", "if", "present", "if", "(", "!", "cbdata", ".", "audio_backend_list", ")", "{", "#", "ifdef", "_HAVE_PORTAUDIO_", "cbdata", ".", "audio_backend_list", "=", "g_list_append", "(", "cbdata", ".", "audio_backend_list", ",", "(", "gpointer", ")", "\"portaudio\"", ")", ";", "cbdata", ".", "audio_driver_option_list", "=", "g_list_append", "(", "cbdata", ".", "audio_driver_option_list", ",", "(", "gpointer", ")", "\"PortAudio\"", ")", ";", "#", "endif", "#", "ifdef", "_HAVE_JACK_", "cbdata", ".", "audio_backend_list", "=", "g_list_append", "(", "cbdata", ".", "audio_backend_list", ",", "(", "gpointer", ")", "\"jack\"", ")", ";", "cbdata", ".", "audio_driver_option_list", "=", "g_list_append", "(", "cbdata", ".", "audio_driver_option_list", ",", "(", "gpointer", ")", "\"JACK\"", ")", ";", "#", "endif", "cbdata", ".", "audio_backend_list", "=", "g_list_append", "(", "cbdata", ".", "audio_backend_list", ",", "(", "gpointer", ")", "\"dummy\"", ")", ";", "cbdata", ".", "audio_driver_option_list", "=", "g_list_append", "(", "cbdata", ".", "audio_driver_option_list", ",", "(", "gpointer", ")", "\"none\"", ")", ";", "#", "ifdef", "_HAVE_PORTMIDI_", "cbdata", ".", "midi_backend_list", "=", "g_list_append", "(", "cbdata", ".", "midi_backend_list", ",", "(", "gpointer", ")", "\"portmidi\"", ")", ";", "cbdata", ".", "midi_driver_option_list", "=", "g_list_append", "(", "cbdata", ".", "midi_driver_option_list", ",", "(", "gpointer", ")", "\"PortMidi\"", ")", ";", "#", "endif", "#", "ifdef", "_HAVE_ALSA_", "cbdata", ".", "midi_backend_list", "=", "g_list_append", "(", "cbdata", ".", "midi_backend_list", ",", "(", "gpointer", ")", "\"alsa\"", ")", ";", "cbdata", ".", "midi_driver_option_list", "=", "g_list_append", "(", "cbdata", ".", "midi_driver_option_list", ",", "(", "gpointer", ")", "\"ALSA\"", ")", ";", "#", "endif", "#", "ifdef", "_HAVE_JACK_", "cbdata", ".", "midi_backend_list", "=", "g_list_append", "(", "cbdata", ".", "midi_backend_list", ",", "(", "gpointer", ")", "\"jack\"", ")", ";", "cbdata", ".", "midi_driver_option_list", "=", "g_list_append", "(", "cbdata", ".", "midi_driver_option_list", ",", "(", "gpointer", ")", "\"JACK\"", ")", ";", "#", "endif", "cbdata", ".", "midi_backend_list", "=", "g_list_append", "(", "cbdata", ".", "midi_backend_list", ",", "(", "gpointer", ")", "\"dummy\"", ")", ";", "cbdata", ".", "midi_driver_option_list", "=", "g_list_append", "(", "cbdata", ".", "midi_driver_option_list", ",", "(", "gpointer", ")", "\"none\"", ")", ";", "}", "dialog", "=", "gtk_dialog_new_with_buttons", "(", "_", "(", "\"Preferences", "-", "Denemo\"", ")", ",", "GTK_WINDOW", "(", "Denemo", ".", "window", ")", ",", "(", "GtkDialogFlags", ")", "(", "GTK_DIALOG_MODAL", "|", "GTK_DIALOG_DESTROY_WITH_PARENT", ")", ",", "_", "(", "\"_OK\"", ")", ",", "GTK_RESPONSE_ACCEPT", ",", "_", "(", "\"_Cancel\"", ")", ",", "GTK_RESPONSE_REJECT", ",", "NULL", ")", ";", "//gtk_dialog_set_has_separator", "(GTK_DIALOG", "(dialog),", "FALSE);", "GtkWidget", "*", "content_area", "=", "gtk_dialog_get_content_area", "(", "GTK_DIALOG", "(", "dialog", ")", ")", ";", "GtkWidget", "*", "warning_message", "=", "gtk_label_new", "(", "\"\"", ")", ";", "use_markup", "(", "warning_message", ")", ";", "gtk_label_set_markup", "(", "GTK_LABEL", "(", "warning_message", ")", ",", "_", "(", "\"<span", "foreground=\\\\\"red\\\\\"weight=\\\\\"bold\\\\\">A", "few", "options", "may", "require", "re-start", "of", "Denemo!</span>\"", ")", ")", ";", "gtk_container_add", "(", "GTK_CONTAINER", "(", "content_area", ")", ",", "warning_message", ")", ";", "notebook", "=", "gtk_notebook_new", "()", ";", "gtk_container_add", "(", "GTK_CONTAINER", "(", "content_area", ")", ",", "notebook", ")", ";", "#", "define", "VBOX", "main_vbox", "#", "define", "NEWPAGE", "(", "thelabel", ")", "\\\\", "main_vbox", "=", "gtk_vbox_new", "(FALSE,", "1);\\\\", "gtk_notebook_append_page", "(GTK_NOTEBOOK", "(notebook),", "main_vbox,", "NULL);\\\\", "gtk_notebook_set_tab_label_text", "(GTK_NOTEBOOK", "(notebook),", "main_vbox,", "thelabel);", "#", "define", "BOOLEANENTRY", "(", "thelabel", ",", "field", ")", "\\\\", "GtkWidget", "*field", "=\\\\", "gtk_check_button_new_with_label", "(thelabel);", "\\\\", "gtk_toggle_button_set_active", "(GTK_TOGGLE_BUTTON", "(field),\\\\", "(gboolean)Denemo.prefs.field);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "field,", "FALSE,", "TRUE,", "0);\\\\", "cbdata.field", "=", "field;", "#", "define", "TEXTENTRY", "(", "thelabel", ",", "field", ")", "\\\\", "hbox", "=", "gtk_hbox_new", "(FALSE,", "8);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "hbox,", "FALSE,", "TRUE,", "0);\\\\", "label", "=", "gtk_label_new", "(thelabel);\\\\", "gtk_misc_set_alignment", "(GTK_MISC", "(label),", "1,", "0.5);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "label,", "FALSE,", "FALSE,", "0);\\\\", "GtkWidget", "*field", "=", "gtk_entry_new", "();\\\\", "gtk_entry_set_text", "(GTK_ENTRY", "(field),", "Denemo.prefs.field->str);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "field,", "TRUE,", "TRUE,", "0);\\\\", "cbdata.field", "=", "field;", "#", "define", "PASSWORDENTRY", "(", "thelabel", ",", "field", ")", "\\\\", "hbox", "=", "gtk_hbox_new", "(FALSE,", "8);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "hbox,", "FALSE,", "TRUE,", "0);\\\\", "label", "=", "gtk_label_new", "(thelabel);\\\\", "gtk_misc_set_alignment", "(GTK_MISC", "(label),", "1,", "0.5);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "label,", "FALSE,", "FALSE,", "0);\\\\", "GtkWidget", "*field", "=", "gtk_entry_new", "();\\\\", "gtk_entry_set_visibility(GTK_ENTRY(field),", "FALSE);\\\\", "gtk_entry_set_invisible_char(GTK_ENTRY(field),", "\\'*\\');\\\\", "gtk_entry_set_text", "(GTK_ENTRY", "(field),", "Denemo.prefs.field->str);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "field,", "TRUE,", "TRUE,", "0);\\\\", "cbdata.field", "=", "field;", "#", "define", "INTENTRY", "(", "thelabel", ",", "field", ")", "\\\\", "hbox", "=", "gtk_hbox_new", "(FALSE,", "8);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "hbox,", "FALSE,", "TRUE,", "0);\\\\", "label", "=", "gtk_label_new", "(thelabel);\\\\", "gtk_misc_set_alignment", "(GTK_MISC", "(label),", "1,", "0.5);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "label,", "FALSE,", "FALSE,", "0);\\\\", "field", "=", "gtk_spin_button_new_with_range", "(1,", "50,", "1.0);\\\\", "gtk_spin_button_set_value", "(GTK_SPIN_BUTTON", "(field),", "Denemo.prefs.field);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "field,", "FALSE,", "FALSE,", "0);\\\\", "cbdata.field", "=", "field;", "#", "define", "ENTRY_LIMITS", "(", "thelabel", ",", "field", ",", "min", ",", "max", ",", "step", ")", "\\\\", "hbox", "=", "gtk_hbox_new", "(FALSE,", "8);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "hbox,", "FALSE,", "TRUE,", "0);\\\\", "label", "=", "gtk_label_new", "(thelabel);\\\\", "gtk_misc_set_alignment", "(GTK_MISC", "(label),", "1,", "0.5);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "label,", "FALSE,", "FALSE,", "0);\\\\", "GtkWidget", "*field", "=", "gtk_spin_button_new_with_range", "(min,", "max,", "step);\\\\", "gtk_spin_button_set_value", "(GTK_SPIN_BUTTON", "(field),", "Denemo.prefs.field);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "field,", "FALSE,", "FALSE,", "0);\\\\", "cbdata.field", "=", "field;", "#", "define", "INTENTRY_LIMITS", "(", "thelabel", ",", "field", ",", "min", ",", "max", ")", "ENTRY_LIMITS(thelabel,", "field,", "min,", "max,", "1)", "#", "define", "DOUBLEENTRY_LIMITS", "ENTRY_LIMITS", "#", "define", "BUTTON", "(", "thelabel", ",", "field", ",", "thecallback", ",", "data", ")", "\\\\", "hbox", "=", "gtk_hbox_new", "(FALSE,", "8);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(vbox1),", "hbox,", "FALSE,", "FALSE,", "0);\\\\", "GtkWidget", "*field", "=", "gtk_button_new_with_label(thelabel);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(vbox1),", "field,", "FALSE,", "FALSE,", "0);\\\\", "g_signal_connect", "(G_OBJECT", "(field),", "\"clicked\",\\\\", "G_CALLBACK", "(thecallback),", "(gpointer)", "data);", "#", "define", "CBOX", "(", "thelabel", ",", "field", ",", "thelist", ",", "settext", ")", "\\\\", "GtkWidget", "*field", "=", "gtk_combo_box_text_new_with_entry", "();\\\\", "i=0;\\\\", "for", "(g=thelist;g;g=g->next){\\\\", "gtk_combo_box_text_append_text", "(GTK_COMBO_BOX_TEXT(field),", "g->data);\\\\", "if", "(0==strcmp(g->data,", "settext))\\\\", "gtk_combo_box_set_active(GTK_COMBO_BOX(field),", "i);\\\\", "i++;\\\\", "}", "#", "define", "COMBOBOX", "(", "thelabel", ",", "field", ",", "thelist", ",", "settext", ",", "editable", ")", "\\\\", "hbox", "=", "gtk_hbox_new", "(FALSE,", "8);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "hbox,", "FALSE,", "TRUE,", "0);\\\\", "label", "=", "gtk_label_new", "(thelabel);\\\\", "gtk_misc_set_alignment", "(GTK_MISC", "(label),", "1,", "0.5);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "label,", "FALSE,", "FALSE,", "0);\\\\", "hbox", "=", "gtk_hbox_new", "(FALSE,", "8);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "hbox,", "FALSE,", "TRUE,", "0);\\\\", "CBOX(thelable,", "field,", "thelist,", "settext)\\\\", "gtk_box_pack_start", "(GTK_BOX", "(hbox),", "field,", "FALSE,", "FALSE,", "0);\\\\", "gtk_widget_show", "(field);\\\\", "cbdata.field", "=", "field;", "#", "if", "GTK_MAJOR_VERSION", "==", "2", "#", "define", "SEPARATOR", "()", "\\\\", "separator", "=", "gtk_hseparator_new();\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "separator,", "FALSE,", "TRUE,", "4);", "#", "else", "#", "define", "SEPARATOR", "()", "\\\\", "separator", "=", "gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);\\\\", "gtk_box_pack_start", "(GTK_BOX", "(VBOX),", "separator,", "FALSE,", "TRUE,", "4);", "#", "endif", "/*", "*", "Note", "entry", "settings", "*/", "NEWPAGE", "(", "_", "(", "\"View\"", ")", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Highlight", "the", "cursor\"", ")", ",", "cursor_highlight", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Display", "general", "toolbar\"", ")", ",", "toolbar", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Display", "Controls", "for", "Incoming", "MIDI", "signals\"", ")", ",", "midi_in_controls", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Display", "Controls", "for", "Playback\"", ")", ",", "playback_controls", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Display", "console", "pane\"", ")", ",", "console_pane", ")", ";", "//BOOLEANENTRY", "(_(\"Display", "lyrics", "pane\"),", "lyrics_pane);", "BOOLEANENTRY", "(", "_", "(", "\"Display", "titles,", "controls", "etc\"", ")", ",", "visible_directive_buttons", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Display", "Music", "Snippets\"", ")", ",", "rhythm_palette", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Display", "menu", "of", "objects", "toolbar\"", ")", ",", "object_palette", ")", ";", "//xgettext:no-c-format", "INTENTRY_LIMITS", "(", "_", "(", "\"%", "Zoom\"", ")", ",", "zoom", ",", "1", ",", "100", ")", ";", "//xgettext:no-c-format", "INTENTRY_LIMITS", "(", "_", "(", "\"%", "of", "display", "height", "per", "system\"", ")", ",", "system_height", ",", "1", ",", "100", ")", ";", "/*", "*", "Preferences", "to", "do", "with", "commands", "*/", "NEWPAGE", "(", "_", "(", "\"Command", "Behavior\"", ")", ")", ";", "TEXTENTRY", "(", "_(", "\"Profile\"", ")", ",", "profile", ")", "//", "TEXTENTRY(_(\"Strict\"),", "strictshortcuts)", "BOOLEANENTRY", "(", "_", "(", "\"Apply", "commands", "to", "selection", "if", "present\"", ")", ",", "applytoselection", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Spill", "notes", "over", "into", "next", "measure\"", ")", ",", "spillover", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"(Chord", "Entry)", "Do", "not", "fill", "in", "tied", "note", "pitches\"", ")", ",", "ignore_ties", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Allow", "Quick", "Setting", "of", "Shortcuts\"", ")", ",", "quickshortcuts", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Strict", "Shortcuts\"", ")", ",", "strictshortcuts", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Menu", "Navigation", "by", "Keypress\"", ")", ",", "menunavigation", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Treat", "Return", "key", "as", "Movable", "Shortcut\"", ")", ",", "return_key_is_special", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Turn", "on", "all", "Tooltips\"", ")", ",", "newbie", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Show", "Shortcuts", "Used\"", ")", ",", "learning", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Tooltip", "timeout", "in", "ms.", "(0", "for", "default,", "-1", "to", "use", "GTK", "tooltips", "-", "restart", "needed)\"", ")", ",", "tooltip_timeout", ",", "-", "1", ",", "1000000", ")", ";", "#", "ifndef", "FAKE_TOOLTIPS", "INTENTRY_LIMITS", "(", "_", "(", "\"Tooltip", "browse", "timeout", "in", "ms\"", ")", ",", "tooltip_browse_timeout", ",", "0", ",", "1000000", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Tooltip", "browse", "mode", "timeout", "in", "ms\"", ")", ",", "tooltip_browse_mode_timeout", ",", "0", ",", "1000000", ")", ";", "#", "endif", "/*", "*", "External", "(Helper)", "Programs", "*/", "NEWPAGE", "(", "_", "(", "\"Externals\"", ")", ")", ";", "TEXTENTRY", "(", "_(", "\"Path", "to", "Lilypond\"", ")", ",", "lilypath", ")", "TEXTENTRY", "(", "_(", "\"File/Internet", "Browser\"", ")", ",", "browser", ")", "TEXTENTRY", "(", "_(", "\"Image", "Viewer\"", ")", ",", "imageviewer", ")", "TEXTENTRY", "(", "_(", "\"Graphics", "Editor\"", ")", ",", "graphicseditor", ")", "TEXTENTRY", "(", "_(", "\"Default", "Save", "Path\"", ")", ",", "denemopath", ")", "BOOLEANENTRY", "(", "_", "(", "\"Update", "the", "command", "set", "on", "startup\"", ")", ",", "autoupdate", ")", ";", "/*", "*", "Misc", "Menu", "*/", "NEWPAGE", "(", "_", "(", "\"Auto-Typeset\"", ")", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Manually", "update", "the", "typeset", "score\"", ")", ",", "manualtypeset", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Rate", "of", "re-typeset", "in", "ms\"", ")", ",", "typesetrefresh", ",", "0", ",", "10000", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Type:", "(0=Range,", "1=Movement,", "2=Whole", "Score)\"", ")", ",", "typesettype", ",", "TYPESET_EXCERPT", ",", "TYPESET_ALL_MOVEMENTS", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Measures", "before", "cursor\"", ")", ",", "firstmeasure", ",", "0", ",", "100", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Measures", "after", "cursor\"", ")", ",", "lastmeasure", ",", "0", ",", "100", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Staffs", "before", "cursor\"", ")", ",", "firststaff", ",", "0", ",", "100", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Staffs", "after", "cursor\"", ")", ",", "laststaff", ",", "0", ",", "100", ")", ";", "/*", "*", "Misc", "Menu", "*/", "NEWPAGE", "(", "_", "(", "\"Miscellaneous\"", ")", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Re-use", "last", "settings", "on", "startup\"", ")", ",", "persistence", ")", ";", "TEXTENTRY", "(", "_", "(", "\"Default", "Font", "Name", "(Denemo)\"", ")", ",", "fontname", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Default", "Font", "Size\"", ")", ",", "fontsize", ",", "4", ",", "48", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Maximum", "Menu", "Size\"", ")", ",", "max_menu_size", ",", "4", ",", "100", ")", ";", "DOUBLEENTRY_LIMITS", "(", "_", "(", "\"Playback", "Display", "Refresh\"", ")", ",", "display_refresh", ",", "0.001", ",", "0.5", ",", "0.002", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Page", "Turn", "Steps\"", ")", ",", "animation_steps", ",", "1", ",", "200", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Excerpt", "Resolution\"", ")", ",", "resolution", ",", "72", ",", "600", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Enable", "Thumbnails\"", ")", ",", "enable_thumbnails", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Auto", "Open", "Sources", "on", "File", "Load\"", ")", ",", "opensources", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Ignore", "Scheme", "Scripts", "on", "File", "Load\"", ")", ",", "ignorescripts", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Max", "recent", "files\"", ")", ",", "maxhistory", ",", "0", ",", "100", ")", ";", "TEXTENTRY", "(", "_(", "\"User", "Name\"", ")", ",", "username", ")", "//PASSWORDENTRY", "(_(\"Password", "for", "Denemo.org\"),", "password)", "BOOLEANENTRY", "(", "_", "(", "\"Create", "Parts", "Layouts\"", ")", ",", "saveparts", ")", ";", "hbox", "=", "gtk_hbox_new", "(", "FALSE", ",", "8", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "main_vbox", ")", ",", "hbox", ",", "FALSE", ",", "TRUE", ",", "0", ")", ";", "autosave", "=", "gtk_check_button_new_with_label", "(", "_", "(", "\"Autosave", "every\"", ")", ")", ";", "gtk_toggle_button_set_active", "(", "GTK_TOGGLE_BUTTON", "(", "autosave", ")", ",", "Denemo", ".", "prefs", ".", "autosave", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "hbox", ")", ",", "autosave", ",", "FALSE", ",", "FALSE", ",", "0", ")", ";", "autosave_timeout", "=", "gtk_spin_button_new_with_range", "(", "1", ",", "600", ",", "1.0", ")", ";", "gtk_spin_button_set_value", "(", "GTK_SPIN_BUTTON", "(", "autosave_timeout", ")", ",", "Denemo", ".", "prefs", ".", "autosave_timeout", ")", ";", "gtk_widget_set_sensitive", "(", "autosave_timeout", ",", "Denemo", ".", "prefs", ".", "autosave", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "hbox", ")", ",", "autosave_timeout", ",", "FALSE", ",", "FALSE", ",", "0", ")", ";", "g_debug", "(", "\"autosave", "%p\\\"", ",", "autosave", ")", ";", "label", "=", "gtk_label_new", "(", "_", "(", "\"second(s)\"", ")", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "hbox", ")", ",", "label", ",", "FALSE", ",", "FALSE", ",", "0", ")", ";", "g_signal_connect", "(", "G_OBJECT", "(", "autosave", ")", ",", "\"toggled\"", ",", "G_CALLBACK", "(", "toggle_autosave", ")", ",", "autosave_timeout", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Compression\"", ")", ",", "compression", ",", "0", ",", "9", ")", ";", "static", "struct", "audio_callback_data", "audio_cbdata", ";", "NEWPAGE", "(", "_", "(", "\"Audio\"", ")", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Play", "back", "entered", "notes", "immediately\"", ")", ",", "immediateplayback", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"MIDI", "key", "sound", "on", "measure", "end\\", "(0", "=", "Off)\"", ")", ",", "measureswitchsound", ",", "0", ",", "127", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Pitch", "Spelling", "Channel\"", ")", ",", "pitchspellingchannel", ",", "0", ",", "15", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Pitch", "Spelling", "Program\"", ")", ",", "pitchspellingprogram", ",", "0", ",", "127", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"%", "MIDI-in", "Dynamic", "Compression\"", ")", ",", "dynamic_compression", ",", "0", ",", "100", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Avoid", "abrupt", "damping\"", ")", ",", "damping", ")", ";", "GList", "*", "item", "=", "g_list_find_custom", "(", "cbdata", ".", "audio_backend_list", ",", "Denemo", ".", "prefs", ".", "audio_driver", "->", "str", ",", "(", "GCompareFunc", ")", "strcmp", ")", ";", "gint", "index", "=", "g_list_position", "(", "cbdata", ".", "audio_backend_list", ",", "item", ")", ";", "if", "(", "index", "<", "0", ")", "index", "=", "0", ";", "gchar", "*", "driver", "=", "g_list_nth_data", "(", "cbdata", ".", "audio_driver_option_list", ",", "index", ")", ";", "SEPARATOR", "()", ";", "COMBOBOX", "(", "\"Audio", "backend\"", ",", "audio_driver", ",", "cbdata", ".", "audio_driver_option_list", ",", "driver", ",", "FALSE", ")", ";", "g_signal_connect", "(", "G_OBJECT", "(", "GTK_COMBO_BOX", "(", "audio_driver", ")", ")", ",", "\"changed\"", ",", "G_CALLBACK", "(", "midi_audio_tab_update", ")", ",", "&", "audio_cbdata", ")", ";", "/*", "*", "JACK", "settings", "*/", "#", "ifdef", "_HAVE_JACK_", "#", "undef", "VBOX", "#", "define", "VBOX", "jack_audio_settings", "jack_audio_settings", "=", "gtk_vbox_new", "(", "FALSE", ",", "1", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "main_vbox", ")", ",", "jack_audio_settings", ",", "FALSE", ",", "TRUE", ",", "0", ")", ";", "GList", "*", "jack_audio_output_ports", "=", "get_jack_ports", "(", "FALSE", ",", "FALSE", ")", ";", "COMBOBOX", "(", "_", "(", "\"Connect", "to", "port", "(left)\"", ")", ",", "jack_connect_ports_l", ",", "jack_audio_output_ports", ",", "Denemo", ".", "prefs", ".", "jack_connect_ports_l", "->", "str", ",", "TRUE", ")", ";", "COMBOBOX", "(", "_", "(", "\"Connect", "to", "port", "(right)\"", ")", ",", "jack_connect_ports_r", ",", "jack_audio_output_ports", ",", "Denemo", ".", "prefs", ".", "jack_connect_ports_r", "->", "str", ",", "TRUE", ")", ";", "#", "undef", "VBOX", "#", "define", "VBOX", "main_vbox", "#", "endif", "//", "_HAVE_JACK_", "/*", "*", "PortAudio", "settings", "*/", "#", "ifdef", "_HAVE_PORTAUDIO_", "#", "undef", "VBOX", "#", "define", "VBOX", "portaudio_settings", "portaudio_settings", "=", "gtk_vbox_new", "(", "FALSE", ",", "1", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "main_vbox", ")", ",", "portaudio_settings", ",", "FALSE", ",", "TRUE", ",", "0", ")", ";", "GList", "*", "devices", "=", "get_portaudio_devices", "()", ";", "#", "ifndef", "G_OS_WIN32", "/*", "if", "default", "is", "requested", "choose", "first", "in", "portaudio", "list,", "rather", "than", "rely", "on", "portaudio", "which", "fails", "to", "select", "a", "default", "*/", "if", "(", "(", "!", "strcmp", "(", "Denemo", ".", "prefs", ".", "portaudio_device", "->", "str", ",", "\"default\"", ")", ")", "&&", "(", "g_list_length", "(", "devices", ")", ">", "1", ")", ")", "g_string_assign", "(", "Denemo", ".", "prefs", ".", "portaudio_device", ",", "(", "gchar", "*", ")", "(", "devices", "->", "next", "->", "data", ")", ")", ";", "#", "endif", "COMBOBOX", "(", "_", "(", "\"Output", "device\"", ")", ",", "portaudio_device", ",", "devices", ",", "Denemo", ".", "prefs", ".", "portaudio_device", "->", "str", ",", "FALSE", ")", ";", "free_portaudio_devices", "(", "devices", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Sample", "rate\"", ")", ",", "portaudio_sample_rate", ",", "0", ",", "96000", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Period", "size\"", ")", ",", "portaudio_period_size", ",", "0", ",", "2048", ")", ";", "INTENTRY_LIMITS", "(", "_", "(", "\"Maximum", "Recording", "Time", "(Secs)\"", ")", ",", "maxrecordingtime", ",", "0", ",", "G_MAXINT", ")", ";", "#", "undef", "VBOX", "#", "define", "VBOX", "main_vbox", "#", "endif", "//", "_HAVE_PORTAUDIO_", "item", "=", "g_list_find_custom", "(", "cbdata", ".", "midi_backend_list", ",", "Denemo", ".", "prefs", ".", "midi_driver", "->", "str", ",", "(", "GCompareFunc", ")", "strcmp", ")", ";", "index", "=", "g_list_position", "(", "cbdata", ".", "midi_backend_list", ",", "item", ")", ";", "if", "(", "index", "<", "0", ")", "index", "=", "0", ";", "driver", "=", "g_list_nth_data", "(", "cbdata", ".", "midi_driver_option_list", ",", "index", ")", ";", "NEWPAGE", "(", "_", "(", "\"MIDI\"", ")", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Rhythm", "Entry", "for", "MIDI", "in\"", ")", ",", "startmidiin", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Ignore", "MIDI", "in", "except", "for", "Note", "On/Off", "messages\"", ")", ",", "notesonlymidiin", ")", ";", "COMBOBOX", "(", "_", "(", "\"MIDI", "backend\"", ")", ",", "midi_driver", ",", "cbdata", ".", "midi_driver_option_list", ",", "driver", ",", "FALSE", ")", ";", "g_signal_connect", "(", "G_OBJECT", "(", "GTK_COMBO_BOX", "(", "midi_driver", ")", ")", ",", "\"changed\"", ",", "G_CALLBACK", "(", "midi_audio_tab_update", ")", ",", "&", "audio_cbdata", ")", ";", "/*", "*", "JACK", "settings", "*/", "#", "ifdef", "_HAVE_JACK_", "#", "undef", "VBOX", "#", "define", "VBOX", "jack_midi_settings", "jack_midi_settings", "=", "gtk_vbox_new", "(", "FALSE", ",", "1", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "main_vbox", ")", ",", "jack_midi_settings", ",", "FALSE", ",", "TRUE", ",", "0", ")", ";", "GList", "*", "jack_midi_input_ports", "=", "get_jack_ports", "(", "TRUE", ",", "FALSE", ")", ";", "GList", "*", "jack_midi_output_ports", "=", "get_jack_ports", "(", "TRUE", ",", "TRUE", ")", ";", "COMBOBOX", "(", "_", "(", "\"Connect", "input", "to", "port\"", ")", ",", "jack_connect_midi_in_port", ",", "jack_midi_output_ports", ",", "Denemo", ".", "prefs", ".", "jack_connect_midi_in_port", "->", "str", ",", "TRUE", ")", ";", "COMBOBOX", "(", "_", "(", "\"Connect", "output", "to", "port\"", ")", ",", "jack_connect_midi_out_port", ",", "jack_midi_input_ports", ",", "Denemo", ".", "prefs", ".", "jack_connect_midi_out_port", "->", "str", ",", "TRUE", ")", ";", "free_jack_ports", "(", "jack_midi_output_ports", ")", ";", "free_jack_ports", "(", "jack_midi_input_ports", ")", ";", "#", "undef", "VBOX", "#", "define", "VBOX", "main_vbox", "#", "endif", "//", "_HAVE_JACK_", "/*", "*", "PortMidi", "settings", "*/", "#", "ifdef", "_HAVE_PORTMIDI_", "#", "undef", "VBOX", "#", "define", "VBOX", "portmidi_settings", "portmidi_settings", "=", "gtk_vbox_new", "(", "FALSE", ",", "1", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "main_vbox", ")", ",", "portmidi_settings", ",", "FALSE", ",", "TRUE", ",", "0", ")", ";", "GList", "*", "input_devices", "=", "get_portmidi_devices", "(", "FALSE", ")", ";", "GList", "*", "output_devices", "=", "get_portmidi_devices", "(", "TRUE", ")", ";", "COMBOBOX", "(", "_", "(", "\"Input", "device\"", ")", ",", "portmidi_input_device", ",", "input_devices", ",", "Denemo", ".", "prefs", ".", "portmidi_input_device", "->", "str", ",", "FALSE", ")", ";", "COMBOBOX", "(", "_", "(", "\"Output", "device\"", ")", ",", "portmidi_output_device", ",", "output_devices", ",", "Denemo", ".", "prefs", ".", "portmidi_output_device", "->", "str", ",", "FALSE", ")", ";", "free_portmidi_devices", "(", "input_devices", ")", ";", "free_portmidi_devices", "(", "output_devices", ")", ";", "#", "undef", "VBOX", "#", "define", "VBOX", "main_vbox", "#", "endif", "SEPARATOR", "()", ";", "#", "ifdef", "_HAVE_FLUIDSYNTH_", "/*", "*", "FluidSynth", "settings", "*/", "TEXTENTRY", "(", "_(", "\"Soundfont\"", ")", ",", "fluidsynth_soundfont", ")", "hbox", "=", "gtk_hbox_new", "(", "FALSE", ",", "8", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "VBOX", ")", ",", "hbox", ",", "FALSE", ",", "TRUE", ",", "0", ")", ";", "GtkWidget", "*", "button", "=", "gtk_button_new_with_label", "(", "_", "(", "\"Choose", "Soundfont\"", ")", ")", ";", "gtk_box_pack_start", "(", "GTK_BOX", "(", "hbox", ")", ",", "button", ",", "FALSE", ",", "FALSE", ",", "0", ")", ";", "g_signal_connect", "(", "G_OBJECT", "(", "button", ")", ",", "\"clicked\"", ",", "G_CALLBACK", "(", "choose_sound_font", ")", ",", "fluidsynth_soundfont", ")", ";", "gtk_widget_show", "(", "button", ")", ";", "BOOLEANENTRY", "(", "_(", "\"Enable", "Reverb", "on", "soundfont\"", ")", ",", "fluidsynth_reverb", ")", "BOOLEANENTRY", "(", "_(", "\"Enable", "Chorus", "on", "soundfont\"", ")", ",", "fluidsynth_chorus", ")", "#", "endif", "/*", "*", "Pitch", "Entry", "Parameters", "*/", "NEWPAGE", "(", "_", "(", "\"Pitch", "Entry\"", ")", ")", ";", "TEXTENTRY", "(", "_(", "\"Temperament\"", ")", ",", "temperament", ")", "BOOLEANENTRY", "(", "_", "(", "\"Use", "Overlays\"", ")", ",", "overlays", ")", ";", "BOOLEANENTRY", "(", "_", "(", "\"Continuous", "Entry\"", ")", ",", "continuous", ")", ";", "gtk_widget_show_all", "(", "dialog", ")", ";", "audio_cbdata", ".", "dialog", "=", "dialog", ";", "audio_cbdata", ".", "audio_driver", "=", "cbdata", ".", "audio_driver", ";", "audio_cbdata", ".", "midi_driver", "=", "cbdata", ".", "midi_driver", ";", "#", "ifdef", "_HAVE_JACK_", "audio_cbdata", ".", "jack_audio_settings", "=", "jack_audio_settings", ";", "audio_cbdata", ".", "jack_midi_settings", "=", "jack_midi_settings", ";", "#", "endif", "#", "ifdef", "_HAVE_PORTAUDIO_", "audio_cbdata", ".", "portaudio_settings", "=", "portaudio_settings", ";", "#", "endif", "#", "ifdef", "_HAVE_PORTMIDI_", "audio_cbdata", ".", "portmidi_settings", "=", "portmidi_settings", ";", "#", "endif", "midi_audio_tab_update", "(", "NULL", ",", "(", "gpointer", "*", ")", "&", "audio_cbdata", ")", ";", "#", "define", "SETCALLBACKDATA", "(", "field", ")", "\\\\", "cbdata.field", "=", "field;", "cbdata", ".", "prefs", "=", "&", "Denemo", ".", "prefs", ";", "SETCALLBACKDATA", "(", "autosave", ")", ";", "SETCALLBACKDATA", "(", "autosave_timeout", ")", ";", "//", "SETCALLBACKDATA", "(maxhistory);", "if", "(", "gtk_dialog_run", "(", "GTK_DIALOG", "(", "dialog", ")", ")", "==", "GTK_RESPONSE_ACCEPT", ")", "{", "set_preferences", "(", "&", "cbdata", ")", ";", "#", "ifndef", "G_OS_WIN32", "//under", "windows", "we", "have:", "<http://savannah.gnu.org/bugs/?36968>", "//", "stop", "playback", "and", "restart", "audio", "subsystem", "//", "FIXME:", "only", "do", "this", "when", "audio", "settings", "actually", "changed", "if", "(", "Denemo", ".", "project", "->", "notsaved", ")", "infodialog", "(", "_", "(", "\"Any", "changes", "to", "MIDI", "or", "AUDIO", "will", "not", "be", "effected", "until", "re-starting", "Denemo\"", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "confirm", "(", "_", "(", "\"Audio/MIDI", "Subsystem\"", ")", ",", "_", "(", "\"Attempt", "to", "re-start", "the", "audio", "subsystem", "now?\"", ")", ")", ")", "{", "midi_stop", "()", ";", "audio_shutdown", "()", ";", "audio_initialize", "(", "cbdata", ".", "prefs", ")", ";", "}", "#", "endif", "free_g_lists", "(", "&", "cbdata", ")", ";", "}", "else", "{", "free_g_lists", "(", "&", "cbdata", ")", ";", "}", "gtk_widget_destroy", "(", "dialog", ")", ";", "}'" ]

[ "Verify", "that", "the", "r_debug", "variable", "is", "visible" ]

[ "'void", "r_debugCheck", "()", "{", "assert", "(", "_r_debug", ".", "r_map", ")", ";", "}'" ]

[ "Called", "by", "the", "assembly", "function", "panic_save_current_state()" ]

[ "\"void", "panic_save_current_task_state", "(", "regs_t", "*", "r", ")", "{", "/*", "*", "Clear", "the", "higher", "(unused)", "bits", "of", "the", "segment", "registers", "for", "a", "nicer", "*", "panic", "regs_t", "dump.", "*/", "r", "->", "ss", "&=", "0xffff", ";", "r", "->", "cs", "&=", "0xffff", ";", "r", "->", "ds", "&=", "0xffff", ";", "r", "->", "es", "&=", "0xffff", ";", "r", "->", "fs", "&=", "0xffff", ";", "r", "->", "gs", "&=", "0xffff", ";", "/*", "*", "Since", "in", "panic", "we", "need", "just", "to", "save", "the", "state", "without", "doing", "a", "context", "*", "switch,", "just", "saving", "the", "ESP", "in", "state_regs", "won't", "work,", "because", "*", "we'll", "going", "to", "continue", "using", "the", "same", "stack.", "In", "this", "particular", "corner", "*", "case,", "just", "store", "the", "regs", "in", "a", "static", "regs_t", "instance.", "*/", "memcpy", "(", "&", "panic_state_regs", ",", "r", ",", "sizeof", "(", "regs_t", ")", ")", ";", "struct", "task", "*", "curr", "=", "get_curr_task", "()", ";", "if", "(", "curr", ")", "curr", "->", "state_regs", "=", "&", "panic_state_regs", ";", "}\"" ]

[ "org_bluez_device1_set_service_data:", "(skip)", "@object:", "A", "#OrgBluezDevice1" ]

[ "'void", "org_bluez_device1_set_service_data", "(", "OrgBluezDevice1", "*", "object", ",", "GVariant", "*", "value", ")", "{", "g_object_set", "(", "G_OBJECT", "(", "object", ")", ",", "\"service-data\"", ",", "value", ",", "NULL", ")", ";", "}'" ]