xemacs-beta: src/console.c comparison

comparison src/console.c @ 398:74fd4e045ea6 r21-2-29

Import from CVS: tag r21-2-29

author	cvs
date	Mon, 13 Aug 2007 11:13:30 +0200
parents	8626e4521993
children	a86b2b5e0111

comparison

equal deleted inserted replaced

-:f4aeb21a5bad
+:74fd4e045ea6
 in this structure as an individual console's value occupies in
 that console.  Setting the default value also goes through the
 list of consoles and stores into each console that does not say
 it has a local value.  */
 Lisp_Object Vconsole_defaults;
+static void *console_defaults_saved_slots;
 /* This structure marks which slots in a console have corresponding
 default values in console_defaults.
 Each such slot has a nonzero value in this structure.
 The value has only one nonzero bit.
 for the slot, but there is no default value for it; the corresponding
 slot in console_defaults is not used except to initialize newly-created
 consoles.
 If a slot is -1, then there is a DEFVAR_CONSOLE_LOCAL for it
 as well as a default value which is used to initialize newly-created
 consoles and as a reset-value when local-vars are killed.
 If a slot is -2, there is no DEFVAR_CONSOLE_LOCAL for it.
 (The slot is always local, but there's no lisp variable for it.)
 The default value is only used to initialize newly-creation consoles.
 struct console console_local_flags;
 /* This structure holds the names of symbols whose values may be
 console-local.  It is indexed and accessed in the same way as the above. */
 static Lisp_Object Vconsole_local_symbols;
+static void *console_local_symbols_saved_slots;
 DEFINE_CONSOLE_TYPE (dead);
 Lisp_Object Vconsole_type_list;
 console_type_entry_dynarr *the_console_type_entry_dynarr;
 static Lisp_Object
-mark_console (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_console (Lisp_Object obj)
 {
 struct console *con = XCONSOLE (obj);
-#define MARKED_SLOT(x) ((void) (markobj (con->x)));
+#define MARKED_SLOT(x) mark_object (con->x)
 #include "conslots.h"
 #undef MARKED_SLOT
 /* Can be zero for Vconsole_defaults, Vconsole_local_symbols */
 if (con->conmeths)
 {
-markobj (con->conmeths->symbol);
+mark_object (con->conmeths->symbol);
-MAYBE_CONMETH (con, mark_console, (con, markobj));
+MAYBE_CONMETH (con, mark_console, (con));
 }
 return Qnil;
 }
 	   XSTRING_DATA (con->name), con->header.uid);
 sprintf (buf, "#<%s-console", !CONSOLE_LIVE_P (con) ? "dead" :
 	   CONSOLE_TYPE_NAME (con));
 write_c_string (buf, printcharfun);
-if (CONSOLE_LIVE_P (con))
+if (CONSOLE_LIVE_P (con) && !NILP (CONSOLE_CONNECTION (con)))
 {
 write_c_string (" on ", printcharfun);
 print_internal (CONSOLE_CONNECTION (con), printcharfun, 1);
 }
 sprintf (buf, " 0x%x>", con->header.uid);
 write_c_string (buf, printcharfun);
 }
 DEFINE_LRECORD_IMPLEMENTATION ("console", console,
-			       mark_console, print_console, 0, 0, 0,
+			       mark_console, print_console, 0, 0, 0, 0,
 			       struct console);
 static struct console *
 allocate_console (void)
 {
 Lisp_Object console;
-struct console *con = alloc_lcrecord_type (struct console, lrecord_console);
+struct console *con = alloc_lcrecord_type (struct console, &lrecord_console);
 struct gcpro gcpro1;
 copy_lcrecord (con, XCONSOLE (Vconsole_defaults));
 XSETCONSOLE (console, con);
 static Lisp_Object
 semi_canonicalize_console_connection (struct console_methods *meths,
 				      Lisp_Object name, Error_behavior errb)
 {
-return CONTYPE_METH_OR_GIVEN (meths, semi_canonicalize_console_connection,
+if (HAS_CONTYPE_METH_P (meths, semi_canonicalize_console_connection))
-				(name, errb), name);
+return CONTYPE_METH (meths, semi_canonicalize_console_connection,
+			 (name, errb));
+else
+return CONTYPE_METH_OR_GIVEN (meths, canonicalize_console_connection,
+				  (name, errb), name);
 }
 static Lisp_Object
 canonicalize_console_connection (struct console_methods *meths,
 				 Lisp_Object name, Error_behavior errb)
 {
-return CONTYPE_METH_OR_GIVEN (meths, canonicalize_console_connection,
+if (HAS_CONTYPE_METH_P (meths, canonicalize_console_connection))
-				(name, errb), name);
+return CONTYPE_METH (meths, canonicalize_console_connection,
+			 (name, errb));
+else
+return CONTYPE_METH_OR_GIVEN (meths, semi_canonicalize_console_connection,
+				  (name, errb), name);
 }
 static Lisp_Object
 find_console_of_type (struct console_methods *meths, Lisp_Object canon)
 {
 MAYBE_CONMETH (con, init_console, (con, props));
 /* Do it this way so that the console list is in order of creation */
 Vconsole_list = nconc2 (Vconsole_list, Fcons (console, Qnil));
-if (CONMETH (con, initially_selected_for_input, (con)))
+if (CONMETH_OR_GIVEN (con, initially_selected_for_input, (con), 0))
 event_stream_select_console (con);
 UNGCPRO;
 return console;
 }
 if (STRINGP (stuffstring))
 {
 Extcount count;
 Extbyte *p;
-GET_STRING_EXT_DATA_ALLOCA (stuffstring, FORMAT_KEYBOARD, p, count);
+TO_EXTERNAL_FORMAT (LISP_STRING, stuffstring,
+			  ALLOCA, (p, count),
+			  Qkeyboard);
 while (count-- > 0)
 	stuff_char (XCONSOLE (Vcontrolling_terminal), *p++);
 stuff_char (XCONSOLE (Vcontrolling_terminal), '\n');
 }
 /* Anything we have read ahead, put back for the shell to read.  */
 defsymbol (&Qsuspend_hook, "suspend-hook");
 defsymbol (&Qsuspend_resume_hook, "suspend-resume-hook");
 }
+static const struct lrecord_description cte_description_1[] = {
+{ XD_LISP_OBJECT, offsetof (console_type_entry, symbol) },
+{ XD_STRUCT_PTR,  offsetof (console_type_entry, meths), 1, &console_methods_description },
+{ XD_END }
+};
+static const struct struct_description cte_description = {
+sizeof (console_type_entry),
+cte_description_1
+};
+static const struct lrecord_description cted_description_1[] = {
+XD_DYNARR_DESC (console_type_entry_dynarr, &cte_description),
+{ XD_END }
+};
+const struct struct_description cted_description = {
+sizeof (console_type_entry_dynarr),
+cted_description_1
+};
+static const struct lrecord_description console_methods_description_1[] = {
+{ XD_LISP_OBJECT, offsetof (struct console_methods, symbol) },
+{ XD_LISP_OBJECT, offsetof (struct console_methods, predicate_symbol) },
+{ XD_LISP_OBJECT, offsetof (struct console_methods, image_conversion_list) },
+{ XD_END }
+};
+const struct struct_description console_methods_description = {
+sizeof (struct console_methods),
+console_methods_description_1
+};
 void
 console_type_create (void)
 {
 the_console_type_entry_dynarr = Dynarr_new (console_type_entry);
+dumpstruct(&the_console_type_entry_dynarr, &cted_description);
 Vconsole_type_list = Qnil;
 staticpro (&Vconsole_type_list);
 /* Initialize the dead console type */
 Dynarr_reset (the_console_type_entry_dynarr);
 Vconsole_type_list = Qnil;
 }
 void
+reinit_vars_of_console (void)
+{
+staticpro_nodump (&Vconsole_list);
+Vconsole_list = Qnil;
+staticpro_nodump (&Vselected_console);
+Vselected_console = Qnil;
+}
+void
 vars_of_console (void)
 {
+reinit_vars_of_console ();
 DEFVAR_LISP ("create-console-hook", &Vcreate_console_hook /*
 Function or functions to call when a console is created.
 One argument, the newly-created console.
 This is called after the first frame has been created, but before
 calling the `create-device-hook' or `create-frame-hook'.
 Function or functions to call when a console is deleted.
 One argument, the to-be-deleted console.
 */ );
 Vdelete_console_hook = Qnil;
-staticpro (&Vconsole_list);
-Vconsole_list = Qnil;
-staticpro (&Vselected_console);
-Vselected_console = Qnil;
 #ifdef HAVE_WINDOW_SYSTEM
 Fprovide (intern ("window-system"));
 #endif
 }
 /* Declaring this stuff as const produces 'Cannot reinitialize' messages
 from SunPro C's fix-and-continue feature (a way neato feature that
 makes debugging unbelievably more bearable) */
 #define DEFVAR_CONSOLE_LOCAL_1(lname, field_name, forward_type, magicfun) do {	\
-static CONST_IF_NOT_DEBUG struct symbol_value_forward I_hate_C		\
+static CONST_IF_NOT_DEBUG struct symbol_value_forward I_hate_C =		\
-= { { { symbol_value_forward_lheader_initializer,				\
+{ /* struct symbol_value_forward */						\
-	    (struct lcrecord_header *) &(console_local_flags.field_name), 69 },	\
+{ /* struct symbol_value_magic */						\
-	  forward_type }, magicfun };						\
+{ /* struct lcrecord_header */						\
+	{ /* struct lrecord_header */						\
+	  1, /* type - index into lrecord_implementations_table */		\
+	  0, /* mark bit */							\
+	  0, /* c_readonly bit */						\
+	  0  /* lisp_readonly bit */						\
+	},									\
+	0, /* next */								\
+	0, /* uid  */								\
+	0  /* free */								\
+},									\
+&(console_local_flags.field_name), 					\
+forward_type								\
+},										\
+magicfun									\
+};										\
+										\
 {										\
 int offset = ((char *)symbol_value_forward_forward (&I_hate_C)		\
 		  - (char *)&console_local_flags);				\
 										\
 defvar_magic (lname, &I_hate_C);						\
 static void
 nuke_all_console_slots (struct console *con, Lisp_Object zap)
 {
 zero_lcrecord (con);
-#define MARKED_SLOT(x)	con->x = (zap);
+#define MARKED_SLOT(x)	con->x = zap
 #include "conslots.h"
 #undef MARKED_SLOT
 }
-void
+static void
-complex_vars_of_console (void)
+common_init_complex_vars_of_console (void)
 {
 /* Make sure all markable slots in console_defaults
 are initialized reasonably, so mark_console won't choke.
 */
-struct console *defs = alloc_lcrecord_type (struct console, lrecord_console);
+struct console *defs = alloc_lcrecord_type (struct console, &lrecord_console);
-struct console *syms = alloc_lcrecord_type (struct console, lrecord_console);
+struct console *syms = alloc_lcrecord_type (struct console, &lrecord_console);
-staticpro (&Vconsole_defaults);
+staticpro_nodump (&Vconsole_defaults);
-staticpro (&Vconsole_local_symbols);
+staticpro_nodump (&Vconsole_local_symbols);
 XSETCONSOLE (Vconsole_defaults, defs);
 XSETCONSOLE (Vconsole_local_symbols, syms);
 nuke_all_console_slots (syms, Qnil);
 nuke_all_console_slots (defs, Qnil);
 /* #### Warning, 0x4000000 (that's six zeroes) is the largest number
 currently allowable due to the XINT() handling of this value.
 With some rearrangement you can get 4 more bits. */
 }
+}
+#define CONSOLE_SLOTS_SIZE (offsetof (struct console, CONSOLE_SLOTS_LAST_NAME) - offsetof (struct console, CONSOLE_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
+#define CONSOLE_SLOTS_COUNT (CONSOLE_SLOTS_SIZE / sizeof (Lisp_Object))
+void
+reinit_complex_vars_of_console (void)
+{
+struct console *defs, *syms;
+common_init_complex_vars_of_console ();
+defs = XCONSOLE (Vconsole_defaults);
+syms = XCONSOLE (Vconsole_local_symbols);
+memcpy (&defs->CONSOLE_SLOTS_FIRST_NAME,
+	  console_defaults_saved_slots,
+	  CONSOLE_SLOTS_SIZE);
+memcpy (&syms->CONSOLE_SLOTS_FIRST_NAME,
+	  console_local_symbols_saved_slots,
+	  CONSOLE_SLOTS_SIZE);
+}
+static const struct lrecord_description console_slots_description_1[] = {
+{ XD_LISP_OBJECT_ARRAY, 0, CONSOLE_SLOTS_COUNT },
+{ XD_END }
+};
+static const struct struct_description console_slots_description = {
+CONSOLE_SLOTS_SIZE,
+console_slots_description_1
+};
+void
+complex_vars_of_console (void)
+{
+struct console *defs, *syms;
+common_init_complex_vars_of_console ();
+defs = XCONSOLE (Vconsole_defaults);
+syms = XCONSOLE (Vconsole_local_symbols);
+console_defaults_saved_slots      = &defs->CONSOLE_SLOTS_FIRST_NAME;
+console_local_symbols_saved_slots = &syms->CONSOLE_SLOTS_FIRST_NAME;
+dumpstruct (&console_defaults_saved_slots,      &console_slots_description);
+dumpstruct (&console_local_symbols_saved_slots, &console_slots_description);
 DEFVAR_CONSOLE_DEFAULTS ("default-function-key-map", function_key_map /*
 Default value of `function-key-map' for consoles that don't override it.
 This is the same as (default-value 'function-key-map).
 */ );
 were a prefix key, typing `ESC O P x' would return
 \[#<keypress-event f1> #<keypress-event x>].
 */ );
 #ifdef HAVE_TTY
-/* ### Should this somehow go to TTY data?  How do we make it
+/* #### Should this somehow go to TTY data?  How do we make it
 accessible from Lisp, then?  */
 DEFVAR_CONSOLE_LOCAL ("tty-erase-char", tty_erase_char /*
 The ERASE character as set by the user with stty.
 When this value cannot be determined or would be meaningless (on non-TTY
 consoles, for example), it is set to nil.
 */ );
 #endif
-/* While this should be CONST it can't be because some things
+/* While this should be const it can't be because some things
 (i.e. edebug) do manipulate it. */
 DEFVAR_CONSOLE_LOCAL ("defining-kbd-macro", defining_kbd_macro /*
 Non-nil while a console macro is being defined.  Don't set this!
 */ );

Mercurial > hg > xemacs-beta

comparison src/console.c @ 398:74fd4e045ea6 r21-2-29