xemacs-beta: src/console.c comparison

comparison src/console.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	ec9a17fef872

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 if (decode_console_type (type, ERROR_ME_NOT))
 return 1;
 return 0;
 }
-DEFUN ("valid-console-type-p", Fvalid_console_type_p, Svalid_console_type_p,
+DEFUN ("valid-console-type-p", Fvalid_console_type_p, 1, 1, 0, /*
-1, 1, 0 /*
 Given a CONSOLE-TYPE, return t if it is valid.
 Valid types are 'x, 'tty, and 'stream.
-*/ )
+*/
-(console_type)
+(console_type))
-Lisp_Object console_type;
 {
 if (valid_console_type_p (console_type))
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("console-type-list", Fconsole_type_list, Sconsole_type_list,
+DEFUN ("console-type-list", Fconsole_type_list, 0, 0, 0, /*
-0, 0, 0 /*
 Return a list of valid console types.
-*/ )
+*/
-()
+())
 {
 return Fcopy_sequence (Vconsole_type_list);
 }
-DEFUN ("cdfw-console", Fcdfw_console, Scdfw_console, 1, 1, 0 /*
+DEFUN ("cdfw-console", Fcdfw_console, 1, 1, 0, /*
 Given a console, device, frame, or window, return the associated console.
 Return nil otherwise.
-*/ )
+*/
-(obj)
+(obj))
-Lisp_Object obj;
 {
 return CDFW_CONSOLE (obj);
 }
-DEFUN ("selected-console", Fselected_console, Sselected_console, 0, 0, 0 /*
+DEFUN ("selected-console", Fselected_console, 0, 0, 0, /*
 Return the console which is currently active.
-*/ )
+*/
-()
+())
 {
 return Vselected_console;
 }
 /* Called from selected_device_1(), called from selected_frame_1(),
 else
 #endif
 Vwindow_system = Qnil;
 }
-DEFUN ("select-console", Fselect_console, Sselect_console, 1, 1, 0 /*
+DEFUN ("select-console", Fselect_console, 1, 1, 0, /*
 Select the console CONSOLE.
 Subsequent editing commands apply to its selected device, selected frame,
 and selected window.  The selection of CONSOLE lasts until the next time
 the user does something to select a different console, or until the next
 time this function is called.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 CHECK_LIVE_CONSOLE (console);
 /* select the console's selected frame's selected window.  This will call
 selected_frame_1(). */
 				   Lisp_Object frame)
 {
 con->_last_nonminibuf_frame = frame;
 }
-DEFUN ("consolep", Fconsolep, Sconsolep, 1, 1, 0 /*
+DEFUN ("consolep", Fconsolep, 1, 1, 0, /*
 Return non-nil if OBJECT is a console.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 if (!CONSOLEP (object))
 return Qnil;
 return Qt;
 }
-DEFUN ("console-live-p", Fconsole_live_p, Sconsole_live_p, 1, 1, 0 /*
+DEFUN ("console-live-p", Fconsole_live_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a console that has not been deleted.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 if (!CONSOLEP (object) || !CONSOLE_LIVE_P (XCONSOLE (object)))
 return Qnil;
 return Qt;
 }
-DEFUN ("console-type", Fconsole_type, Sconsole_type, 0, 1, 0 /*
+DEFUN ("console-type", Fconsole_type, 0, 1, 0, /*
 Return the type of the specified console (e.g. `x' or `tty').
 Value is `tty' for a tty console (a character-only terminal),
 `x' for a console that is an X display,
 `ns' for a console that is a NeXTstep connection (not yet implemeted),
 `win32' for a console that is a Windows or Windows NT connection (not yet
 implemented),
 `pc' for a console that is a direct-write MS-DOS connection (not yet
 implemented),
 `stream' for a stream console (which acts like a stdio stream), and
 `dead' for a deleted console.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 /* don't call decode_console() because we want to allow for dead
 consoles. */
 if (NILP (console))
 console = Fselected_console ();
 CHECK_CONSOLE (console);
 return CONSOLE_TYPE (XCONSOLE (console));
 }
-DEFUN ("console-name", Fconsole_name, Sconsole_name, 0, 1, 0 /*
+DEFUN ("console-name", Fconsole_name, 0, 1, 0, /*
 Return the name of the specified console.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 return CONSOLE_NAME (decode_console (console));
 }
-DEFUN ("console-connection", Fconsole_connection, Sconsole_connection,
+DEFUN ("console-connection", Fconsole_connection, 0, 1, 0, /*
-0, 1, 0 /*
 Return the connection of the specified console.
 CONSOLE defaults to the selected console if omitted.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 return CONSOLE_CONNECTION (decode_console (console));
 }
 Lisp_Object
 }
 return Qnil;
 }
-DEFUN ("find-console", Ffind_console, Sfind_console, 1, 2, 0 /*
+DEFUN ("find-console", Ffind_console, 1, 2, 0, /*
 Look for an existing console attached to connection CONNECTION.
 Return the console if found; otherwise, return nil.
 If TYPE is specified, only return consoles of that type; otherwise,
 return consoles of any type. (It is possible, although unlikely,
 that two consoles of different types could have the same connection
 name; in such a case, the first console found is returned.)
-*/ )
+*/
-(connection, type)
+(connection, type))
-Lisp_Object connection, type;
 {
 Lisp_Object canon = Qnil;
 struct gcpro gcpro1;
 GCPRO1 (canon);
 RETURN_UNGCPRO (Qnil);
 }
 }
-DEFUN ("get-console", Fget_console, Sget_console, 1, 2, 0 /*
+DEFUN ("get-console", Fget_console, 1, 2, 0, /*
 Look for an existing console attached to connection CONNECTION.
 Return the console if found; otherwise, signal an error.
 If TYPE is specified, only return consoles of that type; otherwise,
 return consoles of any type. (It is possible, although unlikely,
 that two consoles of different types could have the same connection
 name; in such a case, the first console found is returned.)
-*/ )
+*/
-(connection, type)
+(connection, type))
-Lisp_Object connection, type;
 {
 Lisp_Object console = Ffind_console (connection, type);
 if (NILP (console))
 {
 if (NILP (type))
 io_error_delete_console (Lisp_Object console)
 {
 delete_console_internal (XCONSOLE (console), 1, 0, 1);
 }
-DEFUN ("delete-console", Fdelete_console, Sdelete_console, 1, 2, 0 /*
+DEFUN ("delete-console", Fdelete_console, 1, 2, 0, /*
 Delete CONSOLE, permanently eliminating it from use.
 Normally, you cannot delete the last non-minibuffer-only frame (you must
 use `save-buffers-kill-emacs' or `kill-emacs').  However, if optional
 second argument FORCE is non-nil, you can delete the last frame. (This
 will automatically call `save-buffers-kill-emacs'.)
-*/ )
+*/
-(console, force)
+(console, force))
-Lisp_Object console, force;
 {
 CHECK_CONSOLE (console);
 delete_console_internal (XCONSOLE (console), !NILP (force), 0, 0);
 return Qnil;
 }
-DEFUN ("console-list", Fconsole_list, Sconsole_list, 0, 0, 0 /*
+DEFUN ("console-list", Fconsole_list, 0, 0, 0, /*
 Return a list of all consoles.
-*/ )
+*/
-()
+())
 {
 return Fcopy_sequence (Vconsole_list);
 }
-DEFUN ("console-device-list", Fconsole_device_list, Sconsole_device_list,
+DEFUN ("console-device-list", Fconsole_device_list, 0, 1, 0, /*
-0, 1, 0 /*
 Return a list of all devices on CONSOLE.
 If CONSOLE is nil, the selected console will be used.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 return Fcopy_sequence (CONSOLE_DEVICE_LIST (decode_console (console)));
 }
-DEFUN ("console-enable-input", Fconsole_enable_input, Sconsole_enable_input,
+DEFUN ("console-enable-input", Fconsole_enable_input, 1, 1, 0, /*
-1, 1, 0 /*
 Enable input on console CONSOLE.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 struct console *con = decode_console (console);
 if (!con->input_enabled)
 event_stream_select_console (con);
 return Qnil;
 }
-DEFUN ("console-disable-input", Fconsole_disable_input,
+DEFUN ("console-disable-input", Fconsole_disable_input, 1, 1, 0, /*
-Sconsole_disable_input,
-1, 1, 0 /*
 Disable input on console CONSOLE.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 struct console *con = decode_console (console);
 if (con->input_enabled)
 event_stream_unselect_console (con);
 return Qnil;
 }
-DEFUN ("console-on-window-system-p", Fconsole_on_window_system_p,
+DEFUN ("console-on-window-system-p", Fconsole_on_window_system_p, 0, 1, 0, /*
-Sconsole_on_window_system_p, 0, 1, 0 /*
 Return non-nil if this console is on a window system.
 This generally means that there is support for the mouse, the menubar,
 the toolbar, glyphs, etc.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 struct console *con = decode_console (console);
 if (EQ (CONSOLE_TYPE (con), Qtty) || EQ (CONSOLE_TYPE (con), Qstream))
 return Qnil;
 		   (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (console))))));
 }
 return Qnil;
 }
-DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "" /*
+DEFUN ("suspend-emacs", Fsuspend_emacs, 0, 1, "", /*
 Stop Emacs and return to superior process.  You can resume later.
 On systems that don't have job control, run a subshell instead.
 If optional arg STUFFSTRING is non-nil, its characters are stuffed
 to be read as terminal input by Emacs's superior shell.
 Otherwise, suspend normally and after resumption call
 `suspend-resume-hook' if that is bound and non-nil.
 Some operating systems cannot stop the Emacs process and resume it later.
 On such systems, Emacs will start a subshell and wait for it to exit.
-*/ )
+*/
-(stuffstring)
+(stuffstring))
-Lisp_Object stuffstring;
 {
 int speccount = specpdl_depth ();
 struct gcpro gcpro1;
 if (!NILP (stuffstring))
 }
 # endif
 #endif /* BSD */
 }
-DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 3, 5, 0 /*
+DEFUN ("set-input-mode", Fset_input_mode, 3, 5, 0, /*
 Set mode of reading keyboard input.
 First arg is ignored, for backward compatibility.
 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
 (no effect except in CBREAK mode).
 Third arg META t means accept 8-bit input (for a Meta key).
 First three arguments only apply to TTY consoles.
 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
 Optional fifth arg CONSOLE specifies console to make changes to; nil means
 the selected console.
 See also `current-input-mode'.
-*/ )
+*/
-(ignored, flow, meta, quit, console)
+(ignored, flow, meta, quit, console))
-Lisp_Object ignored, flow, meta, quit, console;
 {
 struct console *con = decode_console (console);
 int meta_key = 1;
 if (CONSOLE_TTY_P (con))
 }
 return Qnil;
 }
-DEFUN ("current-input-mode", Fcurrent_input_mode, Scurrent_input_mode,
+DEFUN ("current-input-mode", Fcurrent_input_mode, 0, 1, 0, /*
-0, 1, 0 /*
 Return information about the way Emacs currently reads keyboard input.
 Optional arg CONSOLE specifies console to return information about; nil means
 the selected console.
 The value is a list of the form (nil FLOW META QUIT), where
 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
 all 8 bits as the character code.
 QUIT is the character Emacs currently uses to quit.
 FLOW, and META are only meaningful for TTY consoles.
 The elements of this list correspond to the arguments of
 `set-input-mode'.
-*/ )
+*/
-(console)
+(console))
-Lisp_Object console;
 {
 Lisp_Object val[4];
 struct console *con = decode_console (console);
 val[0] = Qnil;
 /************************************************************************/
 void
 syms_of_console (void)
 {
-defsubr (&Svalid_console_type_p);
+DEFSUBR (Fvalid_console_type_p);
-defsubr (&Sconsole_type_list);
+DEFSUBR (Fconsole_type_list);
-defsubr (&Scdfw_console);
+DEFSUBR (Fcdfw_console);
-defsubr (&Sselected_console);
+DEFSUBR (Fselected_console);
-defsubr (&Sselect_console);
+DEFSUBR (Fselect_console);
-defsubr (&Sconsolep);
+DEFSUBR (Fconsolep);
-defsubr (&Sconsole_live_p);
+DEFSUBR (Fconsole_live_p);
-defsubr (&Sconsole_type);
+DEFSUBR (Fconsole_type);
-defsubr (&Sconsole_name);
+DEFSUBR (Fconsole_name);
-defsubr (&Sconsole_connection);
+DEFSUBR (Fconsole_connection);
-defsubr (&Sfind_console);
+DEFSUBR (Ffind_console);
-defsubr (&Sget_console);
+DEFSUBR (Fget_console);
-defsubr (&Sdelete_console);
+DEFSUBR (Fdelete_console);
-defsubr (&Sconsole_list);
+DEFSUBR (Fconsole_list);
-defsubr (&Sconsole_device_list);
+DEFSUBR (Fconsole_device_list);
-defsubr (&Sconsole_enable_input);
+DEFSUBR (Fconsole_enable_input);
-defsubr (&Sconsole_disable_input);
+DEFSUBR (Fconsole_disable_input);
-defsubr (&Sconsole_on_window_system_p);
+DEFSUBR (Fconsole_on_window_system_p);
-defsubr (&Ssuspend_emacs);
+DEFSUBR (Fsuspend_emacs);
-defsubr (&Sset_input_mode);
+DEFSUBR (Fset_input_mode);
-defsubr (&Scurrent_input_mode);
+DEFSUBR (Fcurrent_input_mode);
 defsymbol (&Qconsolep, "consolep");
 defsymbol (&Qconsole_live_p, "console-live-p");
 defsymbol (&Qcreate_console_hook, "create-console-hook");

Mercurial > hg > xemacs-beta

comparison src/console.c @ 20:859a2309aef8 r19-15b93