- set safe_debug_print ($tmp)

- set safe_debug_print (find_symbol_value (intern ($tmp)))

- set safe_debug_print (which_symbols ($arg0, $arg1))

- * font.c, fontset.c, w32font.c, xfont.c, xftfont.c: Change

- font_assert to eassert. Use eassert where appropriate.

- * gtkutil.c (xg_get_font): Rename from xg_get_font_name. When

- using the new font chooser, use gtk_font_chooser_get_font_desc to

- extract the font descriptor instead of just the font name. In

- that case, return a font spec instead of a string.

- MARK_INTERVAL_TREE (buffer_get_intervals (buffer));

- MARK_INTERVAL_TREE (string_get_intervals (ptr->name));

- interval_set_parent (&iblk->intervals[i], interval_free_list);

- buffer_set_intervals (b, NULL);

- BSET (b, width_table, Qnil);

- BSET (b, pt_marker, Qnil);

- BSET (b, begv_marker, Qnil);

- BSET (b, zv_marker, Qnil);

- string_set_intervals (name, NULL);

- BSET (b, name, name);

- BSET (b, undo_list, (SREF (name, 0) != ' ') ? Qnil : Qt);

- BSET (b, mark, Fmake_marker ());

- obj = PER_BUFFER_VALUE (from, offset);

- PER_BUFFER_VALUE (to, offset) = obj;

- buffer_set_overlays_before (to, copy_overlays (to, from->overlays_before));

- buffer_set_overlays_after (to, copy_overlays (to, from->overlays_after));

- BSET (to, local_var_alist, buffer_lisp_local_variables (from, 1));

- BSET (b, width_table, Qnil);

- string_set_intervals (name, NULL);

- BSET (b, name, name);

- BSET (b, mark, Fmake_marker ());

- BSET (b, enable_multibyte_characters, BVAR (b->base_buffer, enable_multibyte_characters));

- BSET (b->base_buffer, pt_marker,

- build_marker (b->base_buffer, b->base_buffer->pt, b->base_buffer->pt_byte));

- BSET (b->base_buffer, begv_marker,

- build_marker (b->base_buffer, b->base_buffer->begv, b->base_buffer->begv_byte));

- BSET (b->base_buffer, zv_marker,

- build_marker (b->base_buffer, b->base_buffer->zv, b->base_buffer->zv_byte));

- BSET (b, pt_marker, build_marker (b, b->pt, b->pt_byte));

- BSET (b, begv_marker, build_marker (b, b->begv, b->begv_byte));

- BSET (b, zv_marker, build_marker (b, b->zv, b->zv_byte));

- BSET (b, filename, Qnil);

- BSET (b, file_truename, Qnil);

- BSET (b, display_count, make_number (0));

- BSET (b, backed_up, Qnil);

- BSET (b, auto_save_file_name, Qnil);

- buffer_set_overlays_before (b, NULL);

- buffer_set_overlays_after (b, NULL);

- BSET (b, filename, Qnil);

- BSET (b, file_truename, Qnil);

- BSET (b, directory,

- (current_buffer) ? BVAR (current_buffer, directory) : Qnil);

- BSET (b, backed_up, Qnil);

- BSET (b, auto_save_file_name, Qnil);

- BSET (b, read_only, Qnil);

- buffer_set_overlays_before (b, NULL);

- buffer_set_overlays_after (b, NULL);

- BSET (b, mark_active, Qnil);

- BSET (b, point_before_scroll, Qnil);

- BSET (b, file_format, Qnil);

- BSET (b, auto_save_file_format, Qt);

- BSET (b, last_selected_window, Qnil);

- BSET (b, display_count, make_number (0));

- BSET (b, display_time, Qnil);

- BSET (b, enable_multibyte_characters,

- BVAR (&buffer_defaults, enable_multibyte_characters));

- BSET (b, cursor_type, BVAR (&buffer_defaults, cursor_type));

- BSET (b, extra_line_spacing, BVAR (&buffer_defaults, extra_line_spacing));

- BSET (b, major_mode, Qfundamental_mode);

- BSET (b, keymap, Qnil);

- BSET (b, mode_name, QSFundamental);

- BSET (b, minor_modes, Qnil);

- BSET (b, downcase_table, Vascii_downcase_table);

- BSET (b, upcase_table, XCHAR_TABLE (Vascii_downcase_table)->extras[0]);

- BSET (b, case_canon_table, XCHAR_TABLE (Vascii_downcase_table)->extras[1]);

- BSET (b, case_eqv_table, XCHAR_TABLE (Vascii_downcase_table)->extras[2]);

- BSET (b, invisibility_spec, Qt);

- BSET (b, local_var_alist, Qnil);

- BSET (b, local_var_alist, XCDR (tmp));

- PER_BUFFER_VALUE (b, offset) = PER_BUFFER_DEFAULT (offset);

- result = PER_BUFFER_VALUE (buf, XBUFFER_OBJFWD (fwd)->offset);

- Lisp_Object val = PER_BUFFER_VALUE (buf, offset);

- BSET (current_buffer, name, newname);

- BSET (XBUFFER (real_buffer), undo_list, Qnil);

- buffer_set_intervals (b, NULL);

- BSET (b, name, Qnil);

- BSET (b, width_table, Qnil);

- BSET (b, undo_list, Qnil);

- FSET (f, buffer_list, Fcons (buffer, Fdelq (buffer, f->buffer_list)));

- FSET (f, buried_buffer_list, Fdelq (buffer, f->buried_buffer_list));

- FSET (f, buffer_list, Fdelq (buffer, f->buffer_list));

- FSET (f, buried_buffer_list,

- Fcons (buffer, Fdelq (buffer, f->buried_buffer_list)));

- BSET (old_buf->base_buffer, undo_list, BVAR (old_buf, undo_list));

- BSET (b, undo_list, BVAR (b->base_buffer, undo_list));

- BSET (other_buffer, field, BVAR (current_buffer, field)); \

- BSET (current_buffer, field, tmp##field); \

- BSET (current_buffer, point_before_scroll, Qnil);

- BSET (other_buffer, point_before_scroll, Qnil);

- BSET (current_buffer, undo_list, Qt);

- BSET (current_buffer, enable_multibyte_characters, Qnil);

- BSET (current_buffer, enable_multibyte_characters, Qt);

- BSET (current_buffer, undo_list,

- Fcons (list3 (Qapply,

- intern ("set-buffer-multibyte"),

- NILP (flag) ? Qt : Qnil),

- old_undo));

- buffer_set_overlays_before (buf, next);

- buffer_set_overlays_after (buf, tail);

- buffer_set_overlays_after (buf, next);

- buffer_set_overlays_before (buf, tail);

- buffer_set_overlays_before (current_buffer, tail->next);

- buffer_set_overlays_after (current_buffer, tail->next);

- buffer_set_overlays_before (current_buffer, before_list);

- buffer_set_overlays_after (current_buffer, after_list);

- buffer_set_overlays_before (bp, found);

- buffer_set_overlays_after (b, XOVERLAY (overlay));

- buffer_set_overlays_before (b, XOVERLAY (overlay));

- buffer_set_overlays_before (b, unchain_overlay (b->overlays_before, ov));

- buffer_set_overlays_after (b, unchain_overlay (b->overlays_after, ov));

- buffer_set_overlays_after (b, XOVERLAY (overlay));

- buffer_set_overlays_before (b, XOVERLAY (overlay));

- buffer_set_intervals (&buffer_defaults, NULL);

- buffer_set_intervals (&buffer_local_symbols, NULL);

- BSET (&buffer_defaults, mode_line_format, build_pure_c_string ("%-"));

- BSET (&buffer_defaults, header_line_format, Qnil);

- BSET (&buffer_defaults, abbrev_mode, Qnil);

- BSET (&buffer_defaults, overwrite_mode, Qnil);

- BSET (&buffer_defaults, case_fold_search, Qt);

- BSET (&buffer_defaults, auto_fill_function, Qnil);

- BSET (&buffer_defaults, selective_display, Qnil);

- BSET (&buffer_defaults, selective_display_ellipses, Qt);

- BSET (&buffer_defaults, abbrev_table, Qnil);

- BSET (&buffer_defaults, display_table, Qnil);

- BSET (&buffer_defaults, undo_list, Qnil);

- BSET (&buffer_defaults, mark_active, Qnil);

- BSET (&buffer_defaults, file_format, Qnil);

- BSET (&buffer_defaults, auto_save_file_format, Qt);

- buffer_set_overlays_before (&buffer_defaults, NULL);

- buffer_set_overlays_after (&buffer_defaults, NULL);

- BSET (&buffer_defaults, truncate_lines, Qnil);

- BSET (&buffer_defaults, word_wrap, Qnil);

- BSET (&buffer_defaults, ctl_arrow, Qt);

- BSET (&buffer_defaults, bidi_display_reordering, Qt);

- BSET (&buffer_defaults, bidi_paragraph_direction, Qnil);

- BSET (&buffer_defaults, cursor_type, Qt);

- BSET (&buffer_defaults, extra_line_spacing, Qnil);

- BSET (&buffer_defaults, cursor_in_non_selected_windows, Qt);

-

- BSET (&buffer_defaults, enable_multibyte_characters, Qt);

- BSET (&buffer_defaults, buffer_file_coding_system, Qnil);

- BSET (&buffer_defaults, cache_long_line_scans, Qnil);

- BSET (&buffer_defaults, file_truename, Qnil);

- BSET (&buffer_defaults, left_fringe_width, Qnil);

- BSET (&buffer_defaults, right_fringe_width, Qnil);

- BSET (&buffer_defaults, fringes_outside_margins, Qnil);

- BSET (&buffer_defaults, scroll_bar_width, Qnil);

- BSET (&buffer_defaults, vertical_scroll_bar_type, Qt);

- BSET (&buffer_defaults, indicate_empty_lines, Qnil);

- BSET (&buffer_defaults, indicate_buffer_boundaries, Qnil);

- BSET (&buffer_defaults, fringe_indicator_alist, Qnil);

- BSET (&buffer_defaults, fringe_cursor_alist, Qnil);

- BSET (&buffer_defaults, scroll_up_aggressively, Qnil);

- BSET (&buffer_defaults, scroll_down_aggressively, Qnil);

- BSET (&buffer_defaults, display_time, Qnil);

- BSET (&buffer_local_flags, filename, make_number (-1));

- BSET (&buffer_local_flags, directory, make_number (-1));

- BSET (&buffer_local_flags, backed_up, make_number (-1));

- BSET (&buffer_local_flags, save_length, make_number (-1));

- BSET (&buffer_local_flags, auto_save_file_name, make_number (-1));

- BSET (&buffer_local_flags, read_only, make_number (-1));

- BSET (&buffer_local_flags, major_mode, make_number (-1));

- BSET (&buffer_local_flags, mode_name, make_number (-1));

- BSET (&buffer_local_flags, undo_list, make_number (-1));

- BSET (&buffer_local_flags, mark_active, make_number (-1));

- BSET (&buffer_local_flags, point_before_scroll, make_number (-1));

- BSET (&buffer_local_flags, file_truename, make_number (-1));

- BSET (&buffer_local_flags, invisibility_spec, make_number (-1));

- BSET (&buffer_local_flags, file_format, make_number (-1));

- BSET (&buffer_local_flags, auto_save_file_format, make_number (-1));

- BSET (&buffer_local_flags, display_count, make_number (-1));

- BSET (&buffer_local_flags, display_time, make_number (-1));

- BSET (&buffer_local_flags, enable_multibyte_characters, make_number (-1));

- BSET (&buffer_defaults, major_mode, Qfundamental_mode);

- BSET (current_buffer, directory, make_unibyte_string (pwd, len));

- BSET (current_buffer, directory,

- string_to_multibyte (BVAR (current_buffer, directory)));

- BSET (current_buffer, directory,

- concat2 (build_string ("/:"), BVAR (current_buffer, directory)));

- BSET (XBUFFER (temp), directory, BVAR (current_buffer, directory));

-#define BSET(buf, field, value) ((buf)->INTERNAL_FIELD (field) = (value))

-buffer_get_intervals (struct buffer *b)

-buffer_set_intervals (struct buffer *b, INTERVAL i)

-/* Set an appropriate overlay of B. */

-

-BUFFER_INLINE void

-buffer_set_overlays_before (struct buffer *b, struct Lisp_Overlay *o)

-{

- b->overlays_before = o;

-}

-

-BUFFER_INLINE void

-buffer_set_overlays_after (struct buffer *b, struct Lisp_Overlay *o)

-{

- b->overlays_after = o;

-}

-

-/* Return the default value of the per-buffer variable at offset

- OFFSET in the buffer structure. */

-#define PER_BUFFER_DEFAULT(OFFSET) \

- (*(Lisp_Object *)((OFFSET) + (char *) &buffer_defaults))

-/* Return the buffer-local value of the per-buffer variable at offset

- OFFSET in the buffer structure. */

-#define PER_BUFFER_VALUE(BUFFER, OFFSET) \

- (*(Lisp_Object *)((OFFSET) + (char *) (BUFFER)))

-

- KSET (current_kboard, Vlast_command, save_last_command);

- KSET (current_kboard, Vlast_command, save_last_command);

-#ifndef USE_CRT_DLL

-extern char **environ;

-#endif

-

- XCHAR_TABLE (table)->extras[0] = up;

- XCHAR_TABLE (table)->extras[1] = canon;

- XCHAR_TABLE (table)->extras[2] = eqv;

- XCHAR_TABLE (canon)->extras[2] = eqv;

- BSET (current_buffer, downcase_table, table);

- BSET (current_buffer, upcase_table, up);

- BSET (current_buffer, case_canon_table, canon);

- BSET (current_buffer, case_eqv_table, eqv);

- XCHAR_TABLE (down)->purpose = Qcase_table;

- XCHAR_TABLE (down)->extras[1] = Fcopy_sequence (down);

- XCHAR_TABLE (down)->extras[0] = up;

- XCHAR_TABLE (down)->extras[2] = Fcopy_sequence (up);

-#include <ctype.h>

- XCHAR_TABLE (table)->extras[1]

- = make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),

- make_float (DEFAULT_REHASH_SIZE),

- make_float (DEFAULT_REHASH_THRESHOLD),

- Qnil, Qnil, Qnil);

- CATEGORY_DOCSTRING (table, XFASTINT (category)) = docstring;

- XCHAR_TABLE (table)->defalt

- = Fcopy_sequence (XCHAR_TABLE (table)->defalt);

- XCHAR_TABLE (table)->extras[0]

- = Fcopy_sequence (XCHAR_TABLE (table)->extras[0]);

- XCHAR_TABLE (val)->defalt = MAKE_CATEGORY_SET;

- XCHAR_TABLE (val)->contents[i] = MAKE_CATEGORY_SET;

- BSET (current_buffer, category_table, table);

- XCHAR_TABLE (Vstandard_category_table)->defalt = MAKE_CATEGORY_SET;

-#define CATEGORY_DOCSTRING(table, category) \

- XVECTOR (Fchar_table_extra_slot (table, make_number (0)))->contents[(category) - ' ']

-#include <ctype.h>

- while (isxdigit (c = getc (fp)))

- set_hash_value (hash_table, charset.hash_index, attrs);

- XCHAR_TABLE (vector)->parent = Qnil;

- XCHAR_TABLE (vector)->purpose = purpose;

- Lisp_Object copy;

- Lisp_Object val;

- copy = make_sub_char_table (depth, min_char, Qnil);

- val = XSUB_CHAR_TABLE (table)->contents[i];

- if (SUB_CHAR_TABLE_P (val))

- XSUB_CHAR_TABLE (copy)->contents[i] = copy_sub_char_table (val);

- else

- XSUB_CHAR_TABLE (copy)->contents[i] = val;

- XCHAR_TABLE (copy)->defalt = XCHAR_TABLE (table)->defalt;

- XCHAR_TABLE (copy)->parent = XCHAR_TABLE (table)->parent;

- XCHAR_TABLE (copy)->purpose = XCHAR_TABLE (table)->purpose;

- XCHAR_TABLE (copy)->contents[i]

- = (SUB_CHAR_TABLE_P (XCHAR_TABLE (table)->contents[i])

- ? copy_sub_char_table (XCHAR_TABLE (table)->contents[i])

- : XCHAR_TABLE (table)->contents[i]);

- XCHAR_TABLE (copy)->ascii = char_table_ascii (copy);

- XCHAR_TABLE (copy)->extras[i] = XCHAR_TABLE (table)->extras[i];

- tbl->contents[i] = val;

- tbl->contents[i] = sub;

-Lisp_Object

- {

- XSUB_CHAR_TABLE (tbl->ascii)->contents[c] = val;

- }

- tbl->contents[i] = sub;

- tbl->ascii = char_table_ascii (table);

- return val;

- tbl->contents[i] = val;

- tbl->contents[i] = sub;

-Lisp_Object

- tbl->contents[i] = val;

- tbl->contents[i] = sub;

- tbl->ascii = char_table_ascii (table);

- return val;

- XCHAR_TABLE (char_table)->parent = parent;

- return XCHAR_TABLE (char_table)->extras[XINT (n)] = value;

- XCHAR_TABLE (char_table)->ascii = value;

- XCHAR_TABLE (char_table)->contents[i] = value;

- XCHAR_TABLE (char_table)->defalt = value;

- elt = XSUB_CHAR_TABLE (table)->contents[0]

- = optimize_sub_char_table (elt, test);

- this = XSUB_CHAR_TABLE (table)->contents[i]

- = optimize_sub_char_table (this, test);

- XCHAR_TABLE (char_table)->contents[i]

- = optimize_sub_char_table (elt, test);

- XCHAR_TABLE (char_table)->ascii = char_table_ascii (char_table);

- XCHAR_TABLE (parent)->parent = Qnil;

- XCHAR_TABLE (parent)->parent = temp;

- XCHAR_TABLE (parent)->parent = Qnil;

- XCHAR_TABLE (parent)->parent = temp;

- struct Lisp_Sub_Char_Table *subtbl = XSUB_CHAR_TABLE (sub);

- XSUB_CHAR_TABLE (table)->contents[idx] = sub;

- subtbl->contents[idx++] = v > 0 ? make_number (v) : Qnil;

- subtbl->contents[idx++] = make_number (v);

- XCHAR_TABLE (table)->extras[4] = Fvconcat (2, args);

- XCHAR_TABLE (table)->ascii = char_table_ascii (table);

- BSET (current_buffer, undo_list, XCDR (BVAR (current_buffer, undo_list)));

- BSET (current_buffer, undo_list, Qt);

- BSET (current_buffer, undo_list, undo_list);

- BSET (current_buffer, undo_list, Qt);

- BSET (current_buffer, enable_multibyte_characters, multibyte ? Qt : Qnil);

- if (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK)

- TSET (term, charset_list, coding_charset_list (terminal_coding));

- else

- TSET (term, charset_list, Fcons (make_number (charset_ascii), Qnil));

- valcontents = BLV_VALUE (blv);

- return PER_BUFFER_VALUE (current_buffer,

- PER_BUFFER_VALUE (b, offset) = newval;

- PER_BUFFER_VALUE (buf, offset) = newval;

- SET_BLV_VALUE (blv, do_symval_forwarding (blv->fwd));

- blv->valcell = blv->defcell;

- blv->where = Qnil;

- SET_BLV_FOUND (blv, 0);

- SET_BLV_VALUE (blv, do_symval_forwarding (blv->fwd));

- blv->where = selected_frame;

- blv->valcell = tem1;

- store_symval_forwarding (blv->fwd, BLV_VALUE (blv), NULL);

- return blv->fwd ? do_symval_forwarding (blv->fwd) : BLV_VALUE (blv);

- SET_BLV_VALUE (blv, do_symval_forwarding (blv->fwd));

- blv->where = where;

- BSET (XBUFFER (where), local_var_alist,

- Fcons (tem1, BVAR (XBUFFER (where), local_var_alist)));

- blv->valcell = tem1;

- SET_BLV_VALUE (blv, newval);

- return PER_BUFFER_DEFAULT (offset);

- PER_BUFFER_DEFAULT (offset) = value;

- PER_BUFFER_VALUE (b, offset) = value;

- blv->where = Qnil;

- blv->defcell = tem;

- blv->valcell = tem;

- SET_BLV_FOUND (blv, 0);

- BSET (current_buffer, local_var_alist,

- Fcons (Fcons (variable, XCDR (blv->defcell)),

- BVAR (current_buffer, local_var_alist)));

- blv->where = Qnil;

- /* blv->valcell = blv->defcell;

- * SET_BLV_FOUND (blv, 0); */

- blv->found = 0;

- PER_BUFFER_VALUE (current_buffer, offset)

- = PER_BUFFER_DEFAULT (offset);

- BSET (current_buffer, local_var_alist,

- Fdelq (tem, BVAR (current_buffer, local_var_alist)));

- blv->where = Qnil;

- /* blv->valcell = blv->defcell;

- * SET_BLV_FOUND (blv, 0); */

- eassert (BLV_FOUND (blv) || !EQ (blv->where, tmp));

- eassert (!BLV_FOUND (blv) || !EQ (blv->where, tmp));

- && BLV_FOUND (SYMBOL_BLV (sym)))

-#include <ctype.h>

- WSET (w, window_end_valid, Qnil);

- WSET (w, window_end_valid, Qnil);

- WSET (root, top_line, make_number (top_margin));

- WSET (root, total_lines, make_number (frame_lines - 1 - top_margin));

- WSET (root, total_cols, make_number (frame_cols));

- WSET (mini, top_line, make_number (frame_lines - 1));

- WSET (mini, total_lines, make_number (1));

- WSET (mini, total_cols, make_number (frame_cols));

- FSET (f, menu_bar_window, make_window ());

- WSET (w, frame, frame);

- WSET (w, top_line, make_number (0));

- WSET (w, left_col, make_number (0));

- WSET (w, total_lines, make_number (FRAME_MENU_BAR_LINES (f)));

- WSET (w, total_cols, make_number (FRAME_TOTAL_COLS (f)));

- FSET (f, tool_bar_window, make_window ());

- WSET (w, frame, frame);

- WSET (w, top_line, make_number (FRAME_MENU_BAR_LINES (f)));

- WSET (w, left_col, make_number (0));

- WSET (w, total_lines, make_number (FRAME_TOOL_BAR_LINES (f)));

- WSET (w, total_cols, make_number (FRAME_TOTAL_COLS (f)));

- FSET (f, menu_bar_window, Qnil);

- FSET (f, tool_bar_window, Qnil);

- FSET (f, current_tool_bar_string, f->desired_tool_bar_string);

- FSET (f, desired_tool_bar_string, tem);

- WSET (XWINDOW (f->tool_bar_window), total_cols, make_number (newwidth));

-#include <ctype.h>

- while (*beg && isspace (*beg)) ++beg;

- for (end = beg; *end && ! isspace (*end); ++end)

-#include <ctype.h>

- FSET (f, title, name);

-#include <ctype.h>

-#ifndef USE_CRT_DLL

-extern char **environ;

-#endif

-

- BSET (current_buffer, mark_active, tem);

- return BSET (current_buffer, undo_list, arg);

- return BSET (current_buffer, filename, arg);

- BSET (current_buffer, undo_list, Qt);

- BSET (current_buffer, filename, Qnil);

- BSET (current_buffer, undo_list, tem);

- if (string_get_intervals (args[n]))

- if (string_get_intervals (args[0]) || arg_intervals)

- cur_intv = buffer_get_intervals (current_buffer);

-#ifndef USE_CRT_DLL

- extern char **environ;

-#endif

-

-

- val = eval_sub (apply1 (Fcdr (fun), original_args));

- specpdl_ptr->symbol = symbol;

- specpdl_ptr->old_value = SYMBOL_VAL (sym);

- specpdl_ptr->old_value = ovalue;

- || (BLV_FOUND (SYMBOL_BLV (sym))

- && BLV_FOUND (SYMBOL_BLV (sym)))

- specpdl_ptr->symbol = Fcons (symbol, Fcons (where, cur_buf));

- specpdl_ptr->symbol = symbol;

- specpdl_ptr->symbol = Qnil;

- specpdl_ptr->old_value = arg;

- specpdl_ptr->saved_value = Qnil;

-#include <ctype.h>

-#define IS_DRIVE(x) isalpha ((unsigned char) (x))

-#define DRIVE_LETTER(x) (tolower ((unsigned char) (x)))

- if (getdefdir (toupper ((unsigned char) *beg) - 'A' + 1, r))

- if (!getdefdir (toupper (drive) - 'A' + 1, adir))

- if (!getdefdir (toupper (drive) - 'A' + 1, adir))

- while (p != endp && (isalnum (*p) || *p == '_')) p++;

- while (p != endp && (isalnum (*p) || *p == '_')) p++;

- buffer_set_intervals (current_buffer, NULL);

- BSET (current_buffer, enable_multibyte_characters, multibyte);

- BSET (current_buffer, undo_list, undo_list);

- BSET (buf, directory, BVAR (current_buffer, directory));

- BSET (buf, read_only, Qnil);

- BSET (buf, filename, Qnil);

- BSET (buf, undo_list, Qt);

- BSET (buf, enable_multibyte_characters, Qnil);

- BSET (current_buffer, enable_multibyte_characters, Qnil);

- BSET (current_buffer, undo_list, Qt);

- BSET (current_buffer, enable_multibyte_characters, Qnil);

- BSET (current_buffer, undo_list, Qnil);

- BSET (current_buffer, filename, orig_filename);

- BSET (current_buffer, undo_list, Qt);

- BSET (current_buffer, undo_list, old_undo);

- BSET (current_buffer, undo_list, EQ (old_undo, Qt) ? Qt : Qnil);

- BSET (current_buffer, filename, visit_file);

- BSET (current_buffer, filename, visit_file);

- if (string_get_intervals (this))

- if (string_get_intervals (this))

- string_set_intervals (string, NULL);

- XCHAR_TABLE (array)->contents[i] = item;

- XCHAR_TABLE (array)->defalt = item;

- set_hash_next (h, i, make_number (i + 1));

- h->key_and_value = larger_vector (h->key_and_value,

- 2 * (new_size - old_size), -1);

- h->next = larger_vector (h->next, new_size - old_size, -1);

- h->hash = larger_vector (h->hash, new_size - old_size, -1);

- h->index = Fmake_vector (make_number (index_size), Qnil);

- set_hash_next (h, i, make_number (i + 1));

- set_hash_next (h, XFASTINT (last), make_number (old_size));

- set_hash_next (h, i, HASH_INDEX (h, start_of_bucket));

- set_hash_index (h, start_of_bucket, make_number (i));

- set_hash_key (h, i, key);

- set_hash_value (h, i, value);

- set_hash_hash (h, i, make_number (hash));

- set_hash_next (h, i, HASH_INDEX (h, start_of_bucket));

- set_hash_index (h, start_of_bucket, make_number (i));

- set_hash_index (h, start_of_bucket, HASH_NEXT (h, i));

- set_hash_next (h, XFASTINT (prev), HASH_NEXT (h, i));

- set_hash_key (h, i, Qnil);

- set_hash_value (h, i, Qnil);

- set_hash_hash (h, i, Qnil);

- set_hash_next (h, i, h->next_free);

- set_hash_next (h, i, i < size - 1 ? make_number (i + 1) : Qnil);

- set_hash_key (h, i, Qnil);

- set_hash_value (h, i, Qnil);

- set_hash_hash (h, i, Qnil);

- set_hash_index (h, bucket, next);

- set_hash_next (h, XFASTINT (prev), next);

- set_hash_next (h, i, h->next_free);

- set_hash_key (h, i, Qnil);

- set_hash_value (h, i, Qnil);

- set_hash_hash (h, i, Qnil);

- set_hash_value (h, i, value);

-#include <ctype.h>

- else if (isdigit (*p))

- if (! isdigit (*q))

- if (!isdigit (*p))

- /* Maximum bound width over all existing characters of the font. On

- X window, this is same as (font->max_bounds.width). */

- value is the average with of those glyphs. Otherwise, the value

- /* Minimum glyph width (in pixels). */

- int min_width;

-

- XCHAR_TABLE (tables[0])->extras[0] = tables[1];

- XCHAR_TABLE (tables[k])->defalt = alist;

-#include <ctype.h>

- WSET (w, top_line, make_number (XFASTINT (w->top_line) + n));

- WSET (w, total_lines, make_number (XFASTINT (w->total_lines) - n));

- FSET (f, tool_bar_position, Qtop);

- WSET (XWINDOW (root_window), next, mini_window);

- WSET (XWINDOW (mini_window), prev, root_window);

- WSET (XWINDOW (mini_window), frame, frame);

- FSET (f, minibuffer_window, mini_window);

- WSET (XWINDOW (root_window), next, Qnil);

- FSET (f, minibuffer_window, Qnil);

- WSET (XWINDOW (root_window), frame, frame);

- WSET (XWINDOW (root_window), total_cols, make_number (10));

- WSET (XWINDOW (root_window), total_lines, make_number (mini_p ? 9 : 10));

- WSET (XWINDOW (mini_window), total_cols, make_number (10));

- WSET (XWINDOW (mini_window), top_line, make_number (9));

- WSET (XWINDOW (mini_window), total_lines, make_number (1));

- WSET (XWINDOW (root_window), buffer, Qt);

- FSET (f, buffer_list, Fcons (buf, Qnil));

- WSET (XWINDOW (mini_window), buffer, Qt);

- FSET (f, root_window, root_window);

- FSET (f, selected_window, root_window);

- KSET (kb, Vdefault_minibuffer_frame,

- call1 (intern ("make-initial-minibuffer-frame"), display));

- FSET (f, minibuffer_window, mini_window);

- mini_window = FSET (f, minibuffer_window, f->root_window);

- WSET (XWINDOW (mini_window), next, Qnil);

- WSET (XWINDOW (mini_window), prev, Qnil);

- WSET (XWINDOW (mini_window), frame, frame);

- FSET (f, name, build_pure_c_string ("F1"));

- FSET (f, name, make_formatted_string (name, "F%"pMd, ++tty_frame_count));

- FSET (f, face_alist, Fcopy_alist (sf->face_alist));

- KSET (current_kboard, Vprefix_arg, Vcurrent_prefix_arg);

- FSET (f, root_window, Qnil);

- FSET (f, menu_bar_vector, Qnil);

- KSET (kb, Vdefault_minibuffer_frame, frame_with_minibuf);

- KSET (kb, Vdefault_minibuffer_frame, Qnil);

- BSET (XBUFFER (w->buffer), display_time, Fcurrent_time ());

- FSET (f, focus_frame, focus_frame);

- FSET (XFRAME (frame), buffer_list,

- Fdelq (buffer, XFRAME (frame)->buffer_list));

- FSET (XFRAME (frame), buried_buffer_list,

- Fdelq (buffer, XFRAME (frame)->buried_buffer_list));

- FSET (f, name, name);

- FSET (f, buffer_list, Fnreverse (list));

- FSET (f, buried_buffer_list, Fnreverse (list));

- if (blv->frame_local && BLV_FOUND (blv) && XFRAME (blv->where) == f)

- FSET (f, param_alist, Fcons (Fcons (prop, val), f->param_alist));

- FSET (f, buffer_predicate, val);

- FSET (f, minibuffer_window, val);

- while (*p1 && ! isspace (*p1) && *p1 != ',') p1++;

- while ((c = *++p1) && isspace (c));

-/* Most code should use this macro to set Lisp field in struct frame. */

-

-#define FSET(f, field, value) ((f)->field = (value))

-

- PSET (XPROCESS (proc), gnutls_cred_type, type);

-#include <ctype.h>

-extern Lisp_Object Qnormal;

- while (isdigit (*ep))

- Lisp_Object args[8];

- if (FRAME_X_OUTPUT (f) && FRAME_GTK_OUTER_WIDGET (f))

-#include <ctype.h>

- while (*s < end && (c = *(*s)++, isspace (c)))

- else if (isdigit (c))

- if (isdigit (c))

- else if (isdigit (c))

- && (c = *(*s)++, isdigit (c)))

- && (c = *(*s)++, isdigit (c)))

- else if (isalpha (c) || c == '_')

- && (c = *(*s)++, (isalnum (c) || c == '_')))

- while (*s < end && (c = *(*s)++, isspace (c)))

- if (isalpha (c) || c == '_' || c == '-' || c == '+')

- && (c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))

- while (*s < end && (c = *(*s)++, isspace (c)))

- else if (isdigit (c))

- while (*s < end && (c = *(*s)++, isdigit (c)))

- window_and_pixmap_id

- BSET (buf, width_table, Fmake_vector (make_number (256), make_number (0)));

- BSET (current_buffer, width_table, Qnil);

- if (buffer_get_intervals (current_buffer)

- WSET (w, buffer, Fcurrent_buffer ());

- WSET (w, buffer, old_buffer);

- if (buffer_get_intervals (current_buffer))

- if (!inherit && buffer_get_intervals (current_buffer))

- intervals = string_get_intervals (string);

- if (buffer_get_intervals (current_buffer))

- if (buffer_get_intervals (current_buffer))

- intervals = buffer_get_intervals (buf);

- if (buffer_get_intervals (current_buffer))

- intervals = string_get_intervals (new);

- BSET (buffer, point_before_scroll, Qnil);

- if (buffer_get_intervals (current_buffer))

-static INTERVAL reproduce_tree_obj (INTERVAL, Lisp_Object);

- buffer_set_intervals (XBUFFER (parent), new);

- string_set_intervals (parent, new);

- interval_set_object (new, parent);

- interval_set_plist (target, Fcopy_sequence (source->plist));

- interval_set_plist (target, Fcons (sym, Fcons (val, target->plist)));

- interval_set_left (INTERVAL_PARENT (interval), B);

- interval_set_right (INTERVAL_PARENT (interval), B);

- interval_copy_parent (B, interval);

- interval_set_right (B, interval);

- interval_set_parent (interval, B);

- interval_set_left (interval, i);

- interval_set_parent (i, interval);

- interval_set_left (INTERVAL_PARENT (interval), B);

- interval_set_right (INTERVAL_PARENT (interval), B);

- interval_copy_parent (B, interval);

- interval_set_left (B, interval);

- interval_set_parent (interval, B);

- interval_set_right (interval, i);

- interval_set_parent (i, interval);

- buffer_set_intervals (XBUFFER (parent), interval);

- string_set_intervals (parent, interval);

- i = buffer_get_intervals (b);

- buffer_set_intervals (b, balance_an_interval (i));

- interval_set_parent (new, interval);

- interval_set_right (interval, new);

- interval_set_right (new, interval->right);

- interval_set_parent (interval->right, new);

- interval_set_right (interval, new);

- interval_set_parent (new, interval);

- interval_set_left (interval, new);

- interval_set_left (new, interval->left);

- interval_set_parent (new->left, new);

- interval_set_left (interval, new);

- interval_set_plist (&newi, merge_properties_sticky (pleft, pright));

- interval_set_plist (i, newi.plist);

- interval_set_plist (prev, newi.plist);

- interval_set_left (this, migrate);

- interval_set_parent (migrate, this);

- interval_set_object (parent, owner);

- buffer_set_intervals (XBUFFER (owner), parent);

- string_set_intervals (owner, parent);

- interval_set_left (parent, delete_node (i));

- interval_set_parent (parent->left, parent);

- interval_set_right (parent, delete_node (i));

- interval_set_parent (parent->right, parent);

- register ptrdiff_t left_to_delete = length;

- register INTERVAL tree = buffer_get_intervals (buffer);

- buffer_set_intervals (buffer, NULL);

- tree = buffer_get_intervals (buffer);

- buffer_set_intervals (buffer, NULL);

- if (!buffer_get_intervals (buffer) || length == 0)

- adjust_intervals_for_insertion (buffer_get_intervals (buffer),

- register INTERVAL t = make_interval ();

-

- memcpy (t, source, sizeof *t);

- copy_properties (source, t);

- interval_set_parent (t, parent);

- if (! NULL_LEFT_CHILD (source))

- interval_set_left (t, reproduce_tree (source->left, t));

- if (! NULL_RIGHT_CHILD (source))

- interval_set_right (t, reproduce_tree (source->right, t));

-

- return t;

- register INTERVAL t = make_interval ();

-

- memcpy (t, source, sizeof *t);

- copy_properties (source, t);

- interval_set_object (t, parent);

- if (! NULL_LEFT_CHILD (source))

- interval_set_left (t, reproduce_tree (source->left, t));

- if (! NULL_RIGHT_CHILD (source))

- interval_set_right (t, reproduce_tree (source->right, t));

-

- return t;

- register INTERVAL under, over, this;

- register INTERVAL tree;

- tree = buffer_get_intervals (buffer);

-

- buffer_set_intervals (buffer, reproduce_tree_obj (source, buf));

- buffer_get_intervals (buffer)->position = BUF_BEG (buffer);

- eassert (buffer_get_intervals (buffer)->up_obj == 1);

- BSET (current_buffer, point_before_scroll, Qnil);

- if (!buffer_get_intervals (current_buffer) && ! have_overlays)

- to = find_interval (buffer_get_intervals (current_buffer), charpos);

- from = find_interval (buffer_get_intervals (current_buffer), buffer_point);

- to = find_interval (buffer_get_intervals (current_buffer), charpos);

- i = find_interval (buffer_get_intervals (current_buffer), pos);

- i = find_interval (buffer_get_intervals (XBUFFER (object)), pos);

- i = find_interval (string_get_intervals (object), pos);

- INTERVAL interval_copy = copy_intervals (buffer_get_intervals (buffer),

- interval_set_object (interval_copy, string);

- string_set_intervals (string, interval_copy);

- i1 = find_interval (string_get_intervals (s1), 0);

- i2 = find_interval (string_get_intervals (s2), 0);

- interval_set_plist (i, i->left->plist);

- interval_set_plist (i, i->right->plist);

- INTERVAL i = buffer_get_intervals (current_buffer);

-interval_set_parent (INTERVAL i, INTERVAL parent)

-interval_set_object (INTERVAL i, Lisp_Object obj)

-{

- eassert (BUFFERP (obj) || STRINGP (obj));

- i->up_obj = 1;

- i->up.obj = obj;

-}

-

-INTERVALS_INLINE void

-interval_set_left (INTERVAL i, INTERVAL left)

-{

- i->left = left;

-}

-

-INTERVALS_INLINE void

-interval_set_right (INTERVAL i, INTERVAL right)

-{

- i->right = right;

-}

-

-INTERVALS_INLINE Lisp_Object

-interval_set_plist (INTERVAL i, Lisp_Object plist)

- return plist;

-}

-

-/* Make the parent of D be whatever the parent of S is, regardless

- of the type. This is used when balancing an interval tree. */

-

-INTERVALS_INLINE void

-interval_copy_parent (INTERVAL d, INTERVAL s)

-{

- d->up = s->up;

- d->up_obj = s->up_obj;

- interval_set_parent (i, NULL); \

- interval_set_plist (i, Qnil); \

- KSET (current_kboard, echo_string,

- concat2 (echo_string, make_string (buffer, ptr - buffer)));

- KSET (current_kboard, echo_string,

- concat2 (KVAR (current_kboard, echo_string), build_string ("-")));

- KSET (current_kboard, echo_string, Qnil);

- KSET (current_kboard, echo_string,

- Fsubstring (KVAR (current_kboard, echo_string),

- make_number (0), make_number (nchars)));

- KSET (current_kboard, Vprefix_arg, Qnil);

- KSET (current_kboard, Vlast_prefix_arg, Qnil);

- KSET (current_kboard, Vprefix_arg, Qnil);

- KSET (current_kboard, Vlast_prefix_arg, Qnil);

- KSET (current_kboard, Vlast_command, Vthis_command);

- KSET (current_kboard, Vreal_last_command, Vreal_this_command);

- KSET (current_kboard, Vlast_repeatable_command, Vreal_this_command);

- KSET (current_kboard, defining_kbd_macro, Qnil);

- KSET (current_kboard, Vprefix_arg, Qnil);

- KSET (current_kboard, Vprefix_arg, Qnil);

- KSET (current_kboard, Vlast_prefix_arg, Vcurrent_prefix_arg);

- KSET (current_kboard, Vlast_command, Vthis_command);

- KSET (current_kboard, Vreal_last_command, Vreal_this_command);

- KSET (current_kboard, Vlast_repeatable_command, Vreal_this_command);

- KSET (kb, kbd_queue, Fcons (c, Qnil));

- KSET (current_kboard, kbd_queue,

- XCDR (KVAR (current_kboard, kbd_queue)));

- KSET (kb, kbd_queue, Fcons (c, Qnil));

- KSET (current_kboard, echo_string, saved_echo_string);

- KSET (kb, kbd_queue,

- Fcons (make_lispy_switch_frame (event->frame_or_window),

- Fcons (make_number (c), Qnil)));

- KSET (current_kboard, system_key_syms, Fcons (Qnil, Qnil));

- KSET (current_kboard, defining_kbd_macro, Qnil);

- KSET (current_kboard, defining_kbd_macro, orig_defn_macro);

- KSET (current_kboard, echo_string, prompt);

- KSET (interrupted_kboard, kbd_queue,

- Fcons (delayed_switch_frame,

- KVAR (interrupted_kboard, kbd_queue)));

- KSET (interrupted_kboard, kbd_queue,

- Fcons (keybuf[--t], KVAR (interrupted_kboard, kbd_queue)));

- KSET (interrupted_kboard, kbd_queue,

- Fcons (make_lispy_switch_frame (frame),

- KVAR (interrupted_kboard, kbd_queue)));

- KSET (current_kboard, Vprefix_arg, Qnil);

- struct window *w;

-

- CHECK_LIVE_WINDOW (frame_or_window);

- w = XWINDOW (frame_or_window);

- KSET (kb, Voverriding_terminal_local_map, Qnil);

- KSET (kb, Vlast_command, Qnil);

- KSET (kb, Vreal_last_command, Qnil);

- KSET (kb, Vkeyboard_translate_table, Qnil);

- KSET (kb, Vlast_repeatable_command, Qnil);

- KSET (kb, Vprefix_arg, Qnil);

- KSET (kb, Vlast_prefix_arg, Qnil);

- KSET (kb, kbd_queue, Qnil);

- KSET (kb, echo_string, Qnil);

- KSET (kb, defining_kbd_macro, Qnil);

- KSET (kb, Vlast_kbd_macro, Qnil);

- KSET (kb, Vsystem_key_alist, Qnil);

- KSET (kb, system_key_syms, Qnil);

- KSET (kb, Vwindow_system, Qt); /* Unset. */

- KSET (kb, Vinput_decode_map, Fmake_sparse_keymap (Qnil));

- KSET (kb, Vlocal_function_key_map, Fmake_sparse_keymap (Qnil));

- KSET (kb, Vdefault_minibuffer_frame, Qnil);

- KSET (current_kboard, Vwindow_system, Qnil);

-#define KSET(kboard, field, value) ((kboard)->INTERNAL_FIELD (field) = (value))

- BSET (current_buffer, keymap, keymap);

- ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] = VAL \

-struct Lisp_Sub_Char_Table;

-

-#define BLV_FOUND(blv) \

- (eassert ((blv)->found == !EQ ((blv)->defcell, (blv)->valcell)), (blv)->found)

-#define SET_BLV_FOUND(blv, v) \

- (eassert ((v) == !EQ ((blv)->defcell, (blv)->valcell)), (blv)->found = (v))

-

-#define BLV_VALUE(blv) (XCDR ((blv)->valcell))

-#define SET_BLV_VALUE(blv, v) (XSETCDR ((blv)->valcell, v))

-

-/* This macro rejects windows on the interior of the window tree as

- "dead", which is what we want; this is an argument-checking macro, and

- the user should never get access to interior windows.

-

- A window of any sort, leaf or interior, is dead if the buffer,

- vchild, and hchild members are all nil. */

-

-#define CHECK_LIVE_WINDOW(x) \

- CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer), \

-set_hash_key (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)

-set_hash_value (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)

-set_hash_next (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)

-set_hash_hash (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)

-set_hash_index (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)

-string_get_intervals (Lisp_Object s)

-string_set_intervals (Lisp_Object s, INTERVAL i)

-void duration_to_sec_usec (double, int *, int *);

-extern Lisp_Object char_table_set (Lisp_Object, int, Lisp_Object);

-extern Lisp_Object char_table_set_range (Lisp_Object, int, int,

- Lisp_Object);

-static Lisp_Object Qlexical_binding;

- INTERVAL root_interval = string_get_intervals (subtree);

- Lisp_Object arg = Fcons (object, placeholder);

- SUBSTITUTE (interval->plist, interval_set_plist (interval, true_value));

- KSET (current_kboard, defining_kbd_macro, Qt);

- KSET (current_kboard, defining_kbd_macro, Qnil);

- KSET (current_kboard, Vlast_kbd_macro,

- make_event_array ((current_kboard->kbd_macro_end

- - current_kboard->kbd_macro_buffer),

- current_kboard->kbd_macro_buffer));

- KSET (current_kboard, Vprefix_arg, Qnil);

- $(NT_INC)/stdalign.h

- BSET (current_buffer, truncate_lines, Qnil);

- BSET (current_buffer, enable_multibyte_characters, enable_multibyte);

- BSET (current_buffer, directory, ambient_dir);

- BSET (current_buffer, directory,

- BVAR (XBUFFER (other_buf), directory));

- BSET (current_buffer, keymap, map);

- BSET (current_buffer, undo_list, Qnil);

- video_mode

- = Fsymbol_value (Fintern_soft (make_formatted_string

- KSET (current_kboard, Vwindow_system, Qpc);

- FSET (f, icon_name, arg);

- FSET (f, name, name);

- FSET (f, title, name);

- FSET (f, name, name);

- FSET (f, icon_name, x_get_arg (dpyinfo, parms, Qicon_name,

- "iconName", "Title",

- RES_TYPE_STRING));

- FSET (f, icon_name, Qnil);

- FSET (f, name, build_string ([ns_app_name UTF8String]));

- FSET (f, name, name);

- KSET (kb, Vdefault_minibuffer_frame, frame);

- FSET (f, param_alist, Fcons (XCAR (tem), f->param_alist));

-/* Utility: get width of a char c in screen font sfont */

- float w;

- NSString *cstr = [NSString stringWithFormat: @"%c", c];

- NSGlyph glyph = [sfont glyphWithName: cstr];

- if (glyph)

- {

- float w = [sfont advancementForGlyph: glyph].width;

- if (w >= 1.5)

- return w;

- }

- return max (w, 2.0);

- font->min_width = ns_char_width(sfont, '|');

- font->average_width = lrint (font_info->width);

-#define hexchar(x) (isdigit (x) ? x - '0' : x - 'a' + 10)

-

-static NSModalSession popupSession;

- FSET (f, menu_bar_items, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));

- FSET (f, menu_bar_vector, menu_items);

- [NSApp endModalSession: popupSession];

-

- NSInteger ret;

- /* initiate a session that will be ended by pop_down_menu */

- popupSession = [NSApp beginModalSessionForWindow: self];

- while (popup_activated_flag

- && (ret = [NSApp runModalSession: popupSession])

- == NSRunContinuesResponse)

- /* Run this for timers.el, indep of atimers; might not return.

- TODO: use return value to avoid calling every iteration. */

- timer_check ();

- [NSThread sleepUntilDate: [NSDate dateWithTimeIntervalSinceNow: 0.1]];

-- (void)fd_handler: (NSTimer *) fdEntry;

- float width; /* this and following metrics stored as float rather than int */

-static NSTimer *fd_entry = nil;

-static fd_set select_readfds, t_readfds;

-static int select_nfds;

-static BOOL inNsSelect = 0;

-#define EV_TRAILER(e) \

- { \

- XSETFRAME (emacs_event->frame_or_window, emacsframe); \

- if (e) emacs_event->timestamp = EV_TIMESTAMP (e); \

- n_emacs_events_pending++; \

- kbd_buffer_store_event_hold (emacs_event, q_event_ptr); \

- EVENT_INIT (*emacs_event); \

- ns_send_appdefined (-1); \

- }

- FSET (dpyinfo->x_focus_frame, focus_frame, Qnil);

- /* Ditto for file descriptor poller */

- if (fd_entry)

- {

- [fd_entry invalidate];

- [fd_entry release];

- fd_entry = nil;

- }

-

-

- /* If called via ns_select, this is called once with expected=1,

- because we expect either the timeout or file descriptor activity.

- In this case the first event through will either be real input or

- one of these. read_avail_input() then calls once more with expected=0

- and in that case we need to return quickly if there is nothing.

- If we're being called outside of that, it's also OK to return quickly

- after one iteration through the event loop, since other terms do

- this and emacs expects it. */

- if (!(inNsSelect && expected))

- /* Post an application defined event on the event queue. When this is

- received the [NXApp run] will return, thus having processed all

- events which are currently queued, if any. */

- ns_send_appdefined (-1);

-

- double time;

- struct timespec select_timeout;

- if (NSApp == nil || inNsSelect == 1 /* || ([NSApp isActive] == NO &&

- [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:nil

- inMode:NSDefaultRunLoopMode dequeue:NO] == nil) */)

- /* Save file descriptor set, which gets overwritten in calls to select ()

- Note, this is called from process.c, and only readfds is ever set */

- if (readfds)

- memcpy (&select_readfds, readfds, sizeof (fd_set));

- else

- select_nfds = 0;

-

- /* Try an initial select for pending data on input files */

- select_timeout.tv_sec = select_timeout.tv_nsec = 0;

- result = pselect (nfds, readfds, writefds, exceptfds,

- &select_timeout, sigmask);

- if (result)

- return result;

-

- /* if (!timeout || timed_entry || fd_entry)

- fprintf (stderr, "assertion failed: timeout null or timed_entry/fd_entry non-null in ns_select\n"); */

-

- /* set a timeout and run the main AppKit event loop while continuing

- to monitor the files */

- time = EMACS_TIME_TO_DOUBLE (*timeout);

- timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time

- target: NSApp

- selector: @selector (timeout_handler:)

- userInfo: 0

- repeats: YES] /* for safe removal */

- retain];

-

- /* set a periodic task to try the pselect () again */

- fd_entry = [[NSTimer scheduledTimerWithTimeInterval: 0.1

- target: NSApp

- selector: @selector (fd_handler:)

- userInfo: 0

- repeats: YES]

- retain];

-

- /* Let Application dispatch events until it receives an event of the type

- NX_APPDEFINED, which should only be sent by timeout_handler.

- We tell read_avail_input() that input is "expected" because we do expect

- either the timeout or fd handler to fire, and if they don't, the original

- call from process.c that got us here expects us to wait until some input

- comes. */

- inNsSelect = 1;

- gobble_input (1);

- inNsSelect = 0;

- return 0;

- return -1;

- /* Received back from pselect () in fd_handler; copy the results */

- if (readfds)

- memcpy (readfds, &select_readfds, sizeof (fd_set));

- return t;

- /* never reached, shut compiler up */

- return 0;

- WSET (window, vertical_scroll_bar, Qnil);

- WSET (window, vertical_scroll_bar, make_save_value (bar, 0));

- KSET (terminal->kboard, Vwindow_system, Qns);

-- (void)fd_handler: (NSTimer *) fdEntry

- struct timespec select_timeout;

- /* NSTRACE (fd_handler); */

- if (select_nfds == 0)

- return;

- memcpy (&t_readfds, &select_readfds, sizeof (fd_set));

- select_timeout.tv_sec = select_timeout.tv_nsec = 0;

- result = pselect (select_nfds, &t_readfds, NULL, NULL, &select_timeout, NULL);

- if (result)

- memcpy (&select_readfds, &t_readfds, sizeof (fd_set));

- ns_send_appdefined (result);