xemacs-beta: src/tooltalk.c comparison

comparison src/tooltalk.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	e04119814345

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 {
 CHECK_TOOLTALK_MESSAGE (msg);
 return XTOOLTALK_MESSAGE (msg)->m;
 }
-DEFUN ("tooltalk-message-p", Ftooltalk_message_p, Stooltalk_message_p, 1, 1, 0 /*
+DEFUN ("tooltalk-message-p", Ftooltalk_message_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a tooltalk message.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (TOOLTALK_MESSAGEP (object) ? Qt : Qnil);
 }
 {
 CHECK_TOOLTALK_PATTERN (pattern);
 return XTOOLTALK_PATTERN (pattern)->p;
 }
-DEFUN ("tooltalk-pattern-p", Ftooltalk_pattern_p, Stooltalk_pattern_p, 1, 1, 0 /*
+DEFUN ("tooltalk-pattern-p", Ftooltalk_pattern_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a tooltalk pattern.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (TOOLTALK_PATTERNP (object) ? Qt : Qnil);
 }
 if (tt_is_err (st))
 signal_error (Qtooltalk_error,
 		  Fcons (build_string (tt_status_message (st)), Qnil));
 }
-DEFUN ("receive-tooltalk-message",
+DEFUN ("receive-tooltalk-message", Freceive_tooltalk_message, 0, 2, 0, /*
-Freceive_tooltalk_message,
-Sreceive_tooltalk_message,
-0, 2, 0 /*
 Run tt_message_receive().
 This function is the process handler for the ToolTalk connection process.
-*/ )
+*/
-(ignore1, ignore2)
+(ignore1, ignore2))
-Lisp_Object ignore1, ignore2; /* filters are called with two arguments. */
 {
 /* This function can GC */
 Tt_message mess = tt_message_receive ();
 Lisp_Object msg = make_tooltalk_message (mess);
 struct gcpro gcpro1;
 check_status (tt_message_arg_bval (m, n, &value, &len));
 return make_string (value, len);
 }
-DEFUN ("get-tooltalk-message-attribute",
+DEFUN ("get-tooltalk-message-attribute", Fget_tooltalk_message_attribute, 2, 3, 0, /*
-Fget_tooltalk_message_attribute,
-Sget_tooltalk_message_attribute,
-2, 3, 0 /*
 Return the indicated Tooltalk message attribute.  Attributes are
 identified by symbols with the same name (underscores and all) as the
 suffix of the Tooltalk tt_message_<attribute> function that extracts the value.
 String attribute values are copied, enumerated type values (except disposition)
 are converted to symbols - e.g. TT_HANDLER is 'TT_HANDLER, uid and gid are
 can be retrieved with the 'arg_type attribute; however, Tooltalk doesn't
 define any semantics for the string value of 'arg_type.  Conventionally
 \"string\" is used for strings and \"int\" for 32 bit integers.  Note that
 Emacs Lisp stores the lengths of strings explicitly (unlike C) so treating the
 value returned by 'arg_bval like a string is fine.
-*/ )
+*/
-(msg, attribute, argn)
+(msg, attribute, argn))
-Lisp_Object msg;
-Lisp_Object attribute;
-Lisp_Object argn;
 {
 Tt_message m = unbox_tooltalk_message (msg);
 int n = 0;
 CHECK_SYMBOL (attribute);
 			 attribute);
 return Qnil;
 }
 DEFUN ("set-tooltalk-message-attribute",
-Fset_tooltalk_message_attribute,
+Fset_tooltalk_message_attribute, 3, 4, 0, /*
-Sset_tooltalk_message_attribute,
-3, 4, 0 /*
 Initialize one Tooltalk message attribute.
 Attribute names and values are the same as for
 `get-tooltalk-message-attribute'.  A property list is provided for user
 data (instead of the 'user message attribute); see
 can be used.
 If one of the argument attributes is specified, 'arg_val, 'arg_ival, or
 'arg_bval then argn must be the number of an already created argument.
 New arguments can be added to a message with add-tooltalk-message-arg.
-*/ )
+*/
-(value, msg, attribute, argn)
+(value, msg, attribute, argn))
-Lisp_Object value;
-Lisp_Object msg;
-Lisp_Object attribute;
-Lisp_Object argn;
 {
 Tt_message m = unbox_tooltalk_message (msg);
 int n = 0;
 CHECK_SYMBOL (attribute);
 signal_simple_error ("invalid value for `set-tooltalk-message-attribute'",
 			 attribute);
 return Qnil;
 }
-DEFUN ("return-tooltalk-message",
+DEFUN ("return-tooltalk-message", Freturn_tooltalk_message, 1, 2, 0, /*
-Freturn_tooltalk_message,
-Sreturn_tooltalk_message,
-1, 2, 0 /*
 Send a reply to this message.  The second argument can be
 'reply, 'reject or 'fail; the default is 'reply.  Before sending
 a reply all message arguments whose mode is TT_INOUT or TT_OUT should
 have been filled in - see set-tooltalk-message-attribute.
-*/ )
+*/
-(msg, mode)
+(msg, mode))
-Lisp_Object msg, mode;
 {
 Tt_message m = unbox_tooltalk_message (msg);
 if (NILP (mode))
 mode = Qtt_reply;
 tt_message_fail (m);
 return Qnil;
 }
-DEFUN ("create-tooltalk-message",
+DEFUN ("create-tooltalk-message", Fcreate_tooltalk_message, 0, 1, 0, /*
-Fcreate_tooltalk_message,
-Screate_tooltalk_message,
-0, 1, 0 /*
 Create a new tooltalk message.
 The messages session attribute is initialized to the default session.
 Other attributes can be initialized with `set-tooltalk-message-attribute'.
 `make-tooltalk-message' is the preferred to create and initialize a message.
 Optional arg NO-CALLBACK says don't add a C-level callback at all.
 Normally don't do that; just don't specify the Lisp callback when
 calling `make-tooltalk-message'.
-*/ )
+*/
-(no_callback)
+(no_callback))
-Lisp_Object no_callback;
 {
 Tt_message m = tt_message_create ();
 Lisp_Object msg = make_tooltalk_message (m);
 if (NILP (no_callback))
 {
 tt_message_session_set (m, tt_default_session ());
 tt_message_user_set (m, TOOLTALK_MESSAGE_KEY, LISP_TO_VOID (msg));
 return msg;
 }
-DEFUN ("destroy-tooltalk-message",
+DEFUN ("destroy-tooltalk-message", Fdestroy_tooltalk_message, 1, 1, 0, /*
-Fdestroy_tooltalk_message,
-Sdestroy_tooltalk_message,
-1, 1, 0 /*
 Apply tt_message_destroy() to the message.
 It's not necessary to destroy messages after they've been processed by
 a message or pattern callback; the Lisp/Tooltalk callback machinery does
 this for you.
-*/ )
+*/
-(msg)
+(msg))
-Lisp_Object msg;
 {
 Tt_message m = unbox_tooltalk_message (msg);
 if (VALID_TOOLTALK_MESSAGEP (m))
 /* #### Should we call Fremhash() here?  It seems that
 return Qnil;
 }
-DEFUN ("add-tooltalk-message-arg",
+DEFUN ("add-tooltalk-message-arg", Fadd_tooltalk_message_arg, 3, 4, 0, /*
-Fadd_tooltalk_message_arg,
-Sadd_tooltalk_message_arg,
-3, 4, 0 /*
 Append one new argument to the message.
 MODE must be one of TT_IN, TT_INOUT, or TT_OUT; VTYPE must be a string;
 and VALUE can be a string or an integer.   Tooltalk doesn't
 define any semantics for VTYPE, so only the participants in the
 protocol you're using need to agree what types mean (if anything).
 Conventionally \"string\" is used for strings and \"int\" for 32 bit integers.
 Arguments can initialized by providing a value or with
 `set-tooltalk-message-attribute'.  The latter is neccessary if you
 want to initialize the argument with a string that can contain
 embedded nulls (use 'arg_bval).
-*/ )
+*/
-(msg, mode, vtype, value)
+(msg, mode, vtype, value))
-Lisp_Object msg, mode, vtype, value;
 {
 Tt_message m = unbox_tooltalk_message (msg);
 Tt_mode n;
 CHECK_STRING (vtype);
 }
 return Qnil;
 }
-DEFUN ("send-tooltalk-message",
+DEFUN ("send-tooltalk-message", Fsend_tooltalk_message, 1, 1, 0, /*
-Fsend_tooltalk_message,
-Ssend_tooltalk_message,
-1, 1, 0 /*
 Send the message on its way.
 Once the message has been sent it's almost always a good idea to get rid of
 it with `destroy-tooltalk-message'.
-*/ )
+*/
-(msg)
+(msg))
-Lisp_Object msg;
 {
 Tt_message m = unbox_tooltalk_message (msg);
 if (VALID_TOOLTALK_MESSAGEP (m))
 {
 }
 return Qnil;
 }
-DEFUN ("create-tooltalk-pattern",
+DEFUN ("create-tooltalk-pattern", Fcreate_tooltalk_pattern, 0, 0, 0, /*
-Fcreate_tooltalk_pattern,
-Screate_tooltalk_pattern,
-0, 0, 0 /*
 Create a new Tooltalk pattern.
 Its session attribute is initialized to be the default session.
-*/ )
+*/
-()
+())
 {
 Tt_pattern p = tt_pattern_create ();
 Lisp_Object pattern = make_tooltalk_pattern (p);
 tt_pattern_callback_add (p, tooltalk_pattern_callback);
 return pattern;
 }
-DEFUN ("destroy-tooltalk-pattern",
+DEFUN ("destroy-tooltalk-pattern", Fdestroy_tooltalk_pattern, 1, 1, 0, /*
-Fdestroy_tooltalk_pattern,
-Sdestroy_tooltalk_pattern,
-1, 1, 0 /*
 Apply tt_pattern_destroy() to the pattern.
 This effectively unregisters the pattern.
-*/ )
+*/
-(pattern)
+(pattern))
-Lisp_Object pattern;
 {
 Tt_pattern p = unbox_tooltalk_pattern (pattern);
 if (VALID_TOOLTALK_PATTERNP (p))
 {
 return Qnil;
 }
-DEFUN ("add-tooltalk-pattern-attribute",
+DEFUN ("add-tooltalk-pattern-attribute", Fadd_tooltalk_pattern_attribute, 3, 3, 0, /*
-Fadd_tooltalk_pattern_attribute,
-Sadd_tooltalk_pattern_attribute,
-3, 3, 0 /*
 Add one value to the indicated pattern attribute.
 All Tooltalk pattern attributes are supported except 'user.  The names
 of attributes are the same as the Tooltalk accessors used to set them
 less the \"tooltalk_pattern_\" prefix and the \"_add\" ...
-*/ )
+*/
-(value, pattern, attribute)
+(value, pattern, attribute))
-Lisp_Object value;
-Lisp_Object pattern;
-Lisp_Object attribute;
 {
 Tt_pattern p = unbox_tooltalk_pattern (pattern);
 CHECK_SYMBOL (attribute);
 return Qnil;
 }
-DEFUN ("add-tooltalk-pattern-arg",
+DEFUN ("add-tooltalk-pattern-arg", Fadd_tooltalk_pattern_arg, 3, 4, 0, /*
-Fadd_tooltalk_pattern_arg,
-Sadd_tooltalk_pattern_arg,
-3, 4, 0 /*
 Add one fully specified argument to a tooltalk pattern.
 Mode must be one of TT_IN, TT_INOUT, or TT_OUT, type must be a string.
 Value can be an integer, string or nil.  If value is an integer then
 an integer argument (tt_pattern_iarg_add) added otherwise a string argument
 is added.  At present there's no way to add a binary data argument.
-*/ )
+*/
-(pattern, mode, vtype, value)
+(pattern, mode, vtype, value))
-Lisp_Object pattern, mode, vtype, value;
 {
 Tt_pattern p = unbox_tooltalk_pattern (pattern);
 Tt_mode n;
 CHECK_STRING (vtype);
 return Qnil;
 }
-DEFUN ("register-tooltalk-pattern",
+DEFUN ("register-tooltalk-pattern", Fregister_tooltalk_pattern, 1, 1, 0, /*
-Fregister_tooltalk_pattern,
-Sregister_tooltalk_pattern,
-1, 1, 0 /*
 Emacs will begin receiving messages that match this pattern.
-*/ )
+*/
-(pattern)
+(pattern))
-Lisp_Object pattern;
 {
 Tt_pattern p = unbox_tooltalk_pattern (pattern);
 if (VALID_TOOLTALK_PATTERNP (p) && tt_pattern_register (p) == TT_OK)
 {
 else
 return Qnil;
 }
-DEFUN ("unregister-tooltalk-pattern",
+DEFUN ("unregister-tooltalk-pattern", Funregister_tooltalk_pattern, 1, 1, 0, /*
-Funregister_tooltalk_pattern,
-Sunregister_tooltalk_pattern,
-1, 1, 0 /*
 Emacs will stop receiving messages that match this pattern.
-*/ )
+*/
-(pattern)
+(pattern))
-Lisp_Object pattern;
 {
 Tt_pattern p = unbox_tooltalk_pattern (pattern);
 if (VALID_TOOLTALK_PATTERNP (p))
 {
 return Qnil;
 }
-DEFUN ("tooltalk-pattern-prop-get",
+DEFUN ("tooltalk-pattern-prop-get", Ftooltalk_pattern_prop_get, 2, 2, 0, /*
-Ftooltalk_pattern_prop_get,
-Stooltalk_pattern_prop_get,
-2, 2, 0 /*
 Return the value of PROPERTY in tooltalk pattern PATTERN.
 This is the last value set with `tooltalk-pattern-prop-set'.
-*/ )
+*/
-(pattern, property)
+(pattern, property))
-Lisp_Object pattern, property;
 {
 CHECK_TOOLTALK_PATTERN (pattern);
 return Fget (XTOOLTALK_PATTERN (pattern)->plist_sym, property, Qnil);
 }
-DEFUN ("tooltalk-pattern-prop-set",
+DEFUN ("tooltalk-pattern-prop-set", Ftooltalk_pattern_prop_set, 3, 3, 0, /*
-Ftooltalk_pattern_prop_set,
-Stooltalk_pattern_prop_set,
-3, 3, 0 /*
 Set the value of PROPERTY to VALUE in tooltalk pattern PATTERN.
 It can be retrieved with `tooltalk-pattern-prop-get'.
-*/ )
+*/
-(pattern, property, value)
+(pattern, property, value))
-Lisp_Object pattern, property, value;
 {
 CHECK_TOOLTALK_PATTERN (pattern);
 return Fput (XTOOLTALK_PATTERN (pattern)->plist_sym, property, value);
 }
-DEFUN ("tooltalk-pattern-plist-get",
+DEFUN ("tooltalk-pattern-plist-get", Ftooltalk_pattern_plist_get, 1, 1, 0, /*
-Ftooltalk_pattern_plist_get,
-Stooltalk_pattern_plist_get,
-1, 1, 0 /*
 Return the a list of all the properties currently set in PATTERN.
-*/ )
+*/
-(pattern)
+(pattern))
-Lisp_Object pattern;
 {
 CHECK_TOOLTALK_PATTERN (pattern);
 return Fcopy_sequence
 (Fsymbol_plist (XTOOLTALK_PATTERN (pattern)->plist_sym));
 }
-DEFUN ("tooltalk-default-procid",
+DEFUN ("tooltalk-default-procid", Ftooltalk_default_procid, 0, 0, 0, /*
-Ftooltalk_default_procid,
-Stooltalk_default_procid,
-0, 0, 0 /*
 Return current default process identifier for your process.
-*/ )
+*/
-()
+())
 {
 char *procid = tt_default_procid ();
 if (!procid)
 return Qnil;
 return build_string (procid);
 }
-DEFUN ("tooltalk-default-session",
+DEFUN ("tooltalk-default-session", Ftooltalk_default_session, 0, 0, 0, /*
-Ftooltalk_default_session,
-Stooltalk_default_session,
-0, 0, 0 /*
 Return current default session identifier for the current default procid.
-*/ )
+*/
-()
+())
 {
 char *session = tt_default_session ();
 if (!session)
 return Qnil;
 return build_string (session);
 				   Vtooltalk_fd, Vtooltalk_fd);
 if (!NILP (lp))
 {
 /* Don't ask the user for confirmation when exiting Emacs */
 Fprocess_kill_without_query (lp, Qnil);
-XSETSUBR (fil, &Sreceive_tooltalk_message);
+XSETSUBR (fil, &SFreceive_tooltalk_message);
 set_process_filter (lp, fil, 1);
 }
 else
 {
 tt_close ();
 tt_message_destroy (exit_msg);
 }
 #endif
 }
-DEFUN ("tooltalk-open-connection",
+DEFUN ("tooltalk-open-connection", Ftooltalk_open_connection, 0, 0, 0, /*
-Ftooltalk_open_connection, Stooltalk_open_connection,
-0, 0, 0 /*
 Opens a connection to the ToolTalk server.
 Returns t if successful, nil otherwise.
-*/ )
+*/
-	()
+())
 {
 if (!NILP (Vtooltalk_fd))
 error ("Already connected to ToolTalk.");
 if (noninteractive)
 error ("Can't connect to ToolTalk in batch mode.");
 void
 syms_of_tooltalk (void)
 {
 defsymbol (&Qtooltalk_messagep, "tooltalk-message-p");
-defsubr (&Stooltalk_message_p);
+DEFSUBR (Ftooltalk_message_p);
 defsymbol (&Qtooltalk_patternp, "tooltalk-pattern-p");
-defsubr (&Stooltalk_pattern_p);
+DEFSUBR (Ftooltalk_pattern_p);
 defsymbol (&Qtooltalk_message_handler_hook, "tooltalk-message-handler-hook");
 defsymbol (&Qtooltalk_pattern_handler_hook, "tooltalk-pattern-handler-hook");
 defsymbol (&Qtooltalk_unprocessed_message_hook,
 	     "tooltalk-unprocessed-message-hook");
-defsubr (&Sreceive_tooltalk_message);
+DEFSUBR (Freceive_tooltalk_message);
-defsubr (&Screate_tooltalk_message);
+DEFSUBR (Fcreate_tooltalk_message);
-defsubr (&Sdestroy_tooltalk_message);
+DEFSUBR (Fdestroy_tooltalk_message);
-defsubr (&Sadd_tooltalk_message_arg);
+DEFSUBR (Fadd_tooltalk_message_arg);
-defsubr (&Sget_tooltalk_message_attribute);
+DEFSUBR (Fget_tooltalk_message_attribute);
-defsubr (&Sset_tooltalk_message_attribute);
+DEFSUBR (Fset_tooltalk_message_attribute);
-defsubr (&Ssend_tooltalk_message);
+DEFSUBR (Fsend_tooltalk_message);
-defsubr (&Sreturn_tooltalk_message);
+DEFSUBR (Freturn_tooltalk_message);
-defsubr (&Screate_tooltalk_pattern);
+DEFSUBR (Fcreate_tooltalk_pattern);
-defsubr (&Sdestroy_tooltalk_pattern);
+DEFSUBR (Fdestroy_tooltalk_pattern);
-defsubr (&Sadd_tooltalk_pattern_attribute);
+DEFSUBR (Fadd_tooltalk_pattern_attribute);
-defsubr (&Sadd_tooltalk_pattern_arg);
+DEFSUBR (Fadd_tooltalk_pattern_arg);
-defsubr (&Sregister_tooltalk_pattern);
+DEFSUBR (Fregister_tooltalk_pattern);
-defsubr (&Sunregister_tooltalk_pattern);
+DEFSUBR (Funregister_tooltalk_pattern);
-defsubr (&Stooltalk_pattern_plist_get);
+DEFSUBR (Ftooltalk_pattern_plist_get);
-defsubr (&Stooltalk_pattern_prop_set);
+DEFSUBR (Ftooltalk_pattern_prop_set);
-defsubr (&Stooltalk_pattern_prop_get);
+DEFSUBR (Ftooltalk_pattern_prop_get);
-defsubr (&Stooltalk_default_procid);
+DEFSUBR (Ftooltalk_default_procid);
-defsubr (&Stooltalk_default_session);
+DEFSUBR (Ftooltalk_default_session);
-defsubr (&Stooltalk_open_connection);
+DEFSUBR (Ftooltalk_open_connection);
 defsymbol (&Qreceive_tooltalk_message, "receive-tooltalk-message");
 defsymbol (&Qtt_address, "address");
 defsymbol (&Qtt_args_count, "args_count");
 defsymbol (&Qtt_arg_bval, "arg_bval");

Mercurial > hg > xemacs-beta

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