xemacs-beta: src/tooltalk.c comparison

comparison src/tooltalk.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	15872534500d
children	3d6bfa290dbd

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 }
 static Lisp_Object
 make_tooltalk_message (Tt_message m)
 {
-struct Lisp_Tooltalk_Message *msg
+struct Lisp_Tooltalk_Message *message_
 = alloc_lcrecord (sizeof (struct Lisp_Tooltalk_Message),
 		      lrecord_tooltalk_message);
 Lisp_Object val;
-msg->m = m;
+message_->m = m;
-msg->callback = Qnil;
+message_->callback = Qnil;
-msg->plist_sym = Fmake_symbol (Tooltalk_Message_plist_str);
+message_->plist_sym = Fmake_symbol (Tooltalk_Message_plist_str);
-XSETTOOLTALK_MESSAGE (val, msg);
+XSETTOOLTALK_MESSAGE (val, message_);
 return val;
 }
 Tt_message
-unbox_tooltalk_message (Lisp_Object msg)
+unbox_tooltalk_message (Lisp_Object message_)
 {
-CHECK_TOOLTALK_MESSAGE (msg);
+CHECK_TOOLTALK_MESSAGE (message_);
-return XTOOLTALK_MESSAGE (msg)->m;
+return XTOOLTALK_MESSAGE (message_)->m;
 }
 DEFUN ("tooltalk-message-p", Ftooltalk_message_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a tooltalk message.
 */
 (object))
 {
-return (TOOLTALK_MESSAGEP (object) ? Qt : Qnil);
+return TOOLTALK_MESSAGEP (object) ? Qt : Qnil;
 }
 DEFUN ("tooltalk-pattern-p", Ftooltalk_pattern_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a tooltalk pattern.
 */
 (object))
 {
-return (TOOLTALK_PATTERNP (object) ? Qt : Qnil);
+return TOOLTALK_PATTERNP (object) ? Qt : Qnil;
 }
 */
 (ignore1, ignore2))
 {
 /* This function can GC */
 Tt_message mess = tt_message_receive ();
-Lisp_Object msg = make_tooltalk_message (mess);
+Lisp_Object message_ = make_tooltalk_message (mess);
 struct gcpro gcpro1;
-GCPRO1 (msg);
+GCPRO1 (message_);
 if (mess != NULL && !NILP (Vtooltalk_unprocessed_message_hook))
-va_run_hook_with_args (Qtooltalk_unprocessed_message_hook, 1,
+va_run_hook_with_args (Qtooltalk_unprocessed_message_hook, 1, message_);
-			   msg);
 UNGCPRO;
 /* see comment in event-stream.c about this return value. */
 return make_int (0);
 }
 static Tt_callback_action
 tooltalk_message_callback (Tt_message m, Tt_pattern p)
 {
 /* This function can GC */
 Lisp_Object cb;
-Lisp_Object msg;
+Lisp_Object message_;
 Lisp_Object pattern;
 struct gcpro gcpro1, gcpro2;
 #ifdef TT_DEBUG
 int i, j;
 }
 fprintf (tooltalk_log_file, "\n\n");
 fflush (tooltalk_log_file);
 #endif
-VOID_TO_LISP (msg, tt_message_user (m, TOOLTALK_MESSAGE_KEY));
+VOID_TO_LISP (message_, tt_message_user (m, TOOLTALK_MESSAGE_KEY));
 pattern = make_tooltalk_pattern (p);
-cb = XTOOLTALK_MESSAGE (msg)->callback;
+cb = XTOOLTALK_MESSAGE (message_)->callback;
-GCPRO2 (msg, pattern);
+GCPRO2 (message_, pattern);
 if (!NILP (Vtooltalk_message_handler_hook))
-va_run_hook_with_args (Qtooltalk_message_handler_hook, 2, msg,
+va_run_hook_with_args (Qtooltalk_message_handler_hook, 2,
-			   pattern);
+			   message_, pattern);
 if ((SYMBOLP (cb) && EQ (Qt, Ffboundp (cb))) ||
 (CONSP (cb) && EQ (Qlambda, Fcar (cb)) &&
 !NILP (Flistp (Fcar (Fcdr (cb))))))
-call2 (cb, msg, pattern);
+call2 (cb, message_, pattern);
 UNGCPRO;
 tt_message_destroy (m);
-Fremhash (msg, Vtooltalk_message_gcpro);
+Fremhash (message_, Vtooltalk_message_gcpro);
 return TT_CALLBACK_PROCESSED;
 }
 static Tt_callback_action
 tooltalk_pattern_callback (Tt_message m, Tt_pattern p)
 {
 /* This function can GC */
 Lisp_Object cb;
-Lisp_Object msg;
+Lisp_Object message_;
 Lisp_Object pattern;
 struct gcpro gcpro1, gcpro2;
 #ifdef TT_DEBUG
 int i, j;
 }
 fprintf (tooltalk_log_file, "\n\n");
 fflush (tooltalk_log_file);
 #endif
-msg = make_tooltalk_message (m);
+message_ = make_tooltalk_message (m);
 VOID_TO_LISP (pattern, tt_pattern_user (p, TOOLTALK_PATTERN_KEY));
 cb = XTOOLTALK_PATTERN (pattern)->callback;
-GCPRO2 (msg, pattern);
+GCPRO2 (message_, pattern);
 if (!NILP (Vtooltalk_pattern_handler_hook))
-va_run_hook_with_args (Qtooltalk_pattern_handler_hook, 2, msg,
+va_run_hook_with_args (Qtooltalk_pattern_handler_hook, 2,
-			   pattern);
+			   message_, pattern);
 if (SYMBOLP (cb) && EQ (Qt, Ffboundp (cb)))
-call2 (cb, msg, pattern);
+call2 (cb, message_, pattern);
 UNGCPRO;
 tt_message_destroy (m);
 return TT_CALLBACK_PROCESSED;
 }
 check_status (tt_message_arg_bval (m, n, &value, &len));
 return make_string (value, len);
 }
-DEFUN ("get-tooltalk-message-attribute", Fget_tooltalk_message_attribute, 2, 3, 0, /*
+DEFUN ("get-tooltalk-message-attribute",
+Fget_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
 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))
+(message_, attribute, argn))
 {
-Tt_message m = unbox_tooltalk_message (msg);
+Tt_message m = unbox_tooltalk_message (message_);
 int n = 0;
 CHECK_SYMBOL (attribute);
 if (EQ (attribute, (Qtt_arg_bval))  ||
 EQ (attribute, (Qtt_arg_ival))  ||
 else if (EQ (attribute, Qtt_uid))
 return make_int (tt_message_uid (m));
 else if (EQ (attribute, Qtt_callback))
-return XTOOLTALK_MESSAGE (msg)->callback;
+return XTOOLTALK_MESSAGE (message_)->callback;
 else if (EQ (attribute, Qtt_prop))
-return Fget (XTOOLTALK_MESSAGE (msg)->plist_sym, argn, Qnil);
+return Fget (XTOOLTALK_MESSAGE (message_)->plist_sym, argn, Qnil);
 else if (EQ (attribute, Qtt_plist))
-return Fcopy_sequence (Fsymbol_plist (XTOOLTALK_MESSAGE (msg)->
+return Fcopy_sequence (Fsymbol_plist
-					  plist_sym));
+			   (XTOOLTALK_MESSAGE (message_)->plist_sym));
 else
 signal_simple_error ("invalid value for `get-tooltalk-message-attribute'",
 			 attribute);
 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, message_, attribute, argn))
 {
-Tt_message m = unbox_tooltalk_message (msg);
+Tt_message m = unbox_tooltalk_message (message_);
 int n = 0;
 CHECK_SYMBOL (attribute);
 if (EQ (attribute, (Qtt_arg_bval))  ||
 EQ (attribute, (Qtt_arg_ival))  ||
 tt_message_status_string_set (m, value_ext);
 }
 else if (EQ (attribute, Qtt_callback))
 {
 CHECK_SYMBOL (value);
-XTOOLTALK_MESSAGE (msg)->callback = value;
+XTOOLTALK_MESSAGE (message_)->callback = value;
 }
 else if (EQ (attribute, Qtt_prop))
 {
-return Fput (XTOOLTALK_MESSAGE (msg)->plist_sym, argn, value);
+return Fput (XTOOLTALK_MESSAGE (message_)->plist_sym, argn, value);
 }
 else
 signal_simple_error ("invalid value for `set-tooltalk-message-attribute'",
 			 attribute);
 return Qnil;
 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))
+(message_, mode))
 {
-Tt_message m = unbox_tooltalk_message (msg);
+Tt_message m = unbox_tooltalk_message (message_);
 if (NILP (mode))
 mode = Qtt_reply;
 else
 CHECK_SYMBOL (mode);
 calling `make-tooltalk-message'.
 */
 (no_callback))
 {
 Tt_message m = tt_message_create ();
-Lisp_Object msg = make_tooltalk_message (m);
+Lisp_Object message_ = make_tooltalk_message (m);
 if (NILP (no_callback))
 {
 tt_message_callback_add (m, tooltalk_message_callback);
 }
 tt_message_session_set (m, tt_default_session ());
-tt_message_user_set (m, TOOLTALK_MESSAGE_KEY, LISP_TO_VOID (msg));
+tt_message_user_set (m, TOOLTALK_MESSAGE_KEY, LISP_TO_VOID (message_));
-return msg;
+return message_;
 }
 DEFUN ("destroy-tooltalk-message", Fdestroy_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))
+(message_))
 {
-Tt_message m = unbox_tooltalk_message (msg);
+Tt_message m = unbox_tooltalk_message (message_);
 if (VALID_TOOLTALK_MESSAGEP (m))
 /* #### Should we call Fremhash() here?  It seems that
 a common paradigm is
 Arguments can initialized by providing a value or with
 `set-tooltalk-message-attribute'.  The latter is necessary if you
 want to initialize the argument with a string that can contain
 embedded nulls (use 'arg_bval).
 */
-(msg, mode, vtype, value))
+(message_, mode, vtype, value))
 {
-Tt_message m = unbox_tooltalk_message (msg);
+Tt_message m = unbox_tooltalk_message (message_);
 Tt_mode n;
 CHECK_STRING (vtype);
 CHECK_TOOLTALK_CONSTANT (mode);
 DEFUN ("send-tooltalk-message", Fsend_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))
+(message_))
 {
-Tt_message m = unbox_tooltalk_message (msg);
+Tt_message m = unbox_tooltalk_message (message_);
 if (VALID_TOOLTALK_MESSAGEP (m))
 {
 tt_message_send (m);
-Fputhash (msg, Qnil, Vtooltalk_message_gcpro);
+Fputhash (message_, Qnil, Vtooltalk_message_gcpro);
 }
 return Qnil;
 }
 Return the a list of all the properties currently set in PATTERN.
 */
 (pattern))
 {
 CHECK_TOOLTALK_PATTERN (pattern);
-return Fcopy_sequence
+return
-(Fsymbol_plist (XTOOLTALK_PATTERN (pattern)->plist_sym));
+Fcopy_sequence (Fsymbol_plist (XTOOLTALK_PATTERN (pattern)->plist_sym));
 }
 DEFUN ("tooltalk-default-procid", Ftooltalk_default_procid, 0, 0, 0, /*
 Return current default process identifier for your process.
 */
 if (!NILP (Vtooltalk_fd))
 error ("Already connected to ToolTalk.");
 if (noninteractive)
 error ("Can't connect to ToolTalk in batch mode.");
 init_tooltalk ();
-return (NILP (Vtooltalk_fd) ? Qnil : Qt);
+return NILP (Vtooltalk_fd) ? Qnil : Qt;
 }
 void
 syms_of_tooltalk (void)

Mercurial > hg > xemacs-beta

comparison src/tooltalk.c @ 173:8eaf7971accc r20-3b13