xemacs-beta: src/minibuf.c comparison

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

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	538048ae2ab8
children	262b8bb4a523

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 Vminibuf_preprompt = Qnil;
 }
 else
 {
 CHECK_STRING (preprompt);
 Vminibuf_preprompt = LISP_GETTEXT (preprompt);
 }
 return Qnil;
 }
 noseeum_cons
 			 (Vminibuf_prompt,
 			  noseeum_cons (make_int (minibuf_level), Qnil)));
 Vminibuf_prompt = LISP_GETTEXT (prompt);
 /* NOTE: Here (or somewhere around here), in FSFmacs 19.30,
 choose_minibuf_frame() is called.  This is the only
 place in FSFmacs that it's called any more -- there's
 also a call in xterm.c, but commented out, and 19.28
 had the calls in different places.
 similar, but not identical, to a set-window-buffer call made
 in `read-from-minibuffer' in minibuf.el.  I hope it's close
 enough, because minibuf_window isn't really exported to Lisp.
 The comment above choose_minibuf_frame() reads:
 Put minibuf on currently selected frame's minibuffer.
 We do this whenever the user starts a new minibuffer
 or when a minibuffer exits.  */
 minibuf_window = FRAME_MINIBUF_WINDOW (selected_frame ());
 run_hook (Qminibuffer_setup_hook);
 minibuf_level++;
 clear_echo_area (selected_frame (), Qnil, 0);
 val = call_command_loop (Qt);
-return (unbind_to (speccount, val));
+return unbind_to (speccount, val);
 }
 /* Completion hair */
 	{
 	  Lisp_Object re = XCAR (regexps);
 	  if (STRINGP (re)
 	      && (fast_string_match (re, nonreloc, reloc, offset,
 				     length, 0, ERROR_ME, 0) < 0))
-	    return (1);
+	    return 1;
 	}
 }
-return (0);
+return 0;
 }
 /* Callers should GCPRO, since this may call eval */
 static int
 ignore_completion_p (Lisp_Object completion_string,
 Lisp_Object pred, Lisp_Object completion)
 {
 if (regexp_ignore_completion_p (0, completion_string, 0, -1))
-return (1);
+return 1;
 /* Ignore this element if there is a predicate
 and the predicate doesn't like it. */
 if (!NILP (pred))
 {
 Lisp_Object tem;
 if (EQ (pred, Qcommandp))
 tem = Fcommandp (completion);
 else
 tem = call1 (pred, completion);
 if (NILP (tem))
-return (1);
+return 1;
 }
-return (0);
+return 0;
 }
 /* This function can GC */
 Lisp_Object bestmatch, tail;
 Charcount bestmatchsize = 0;
 int list;
 int indice = 0;
-int obsize = 0;
 int matchcount = 0;
+int obsize;
 Lisp_Object bucket;
 Charcount slength, blength;
 CHECK_STRING (string);
 /* If ALIST is not a list, set TAIL just for gc pro.  */
 tail = alist;
 if (!list)
 {
-obsize = vector_length (XVECTOR (alist));
+obsize = XVECTOR_LENGTH (alist);
-bucket = vector_data (XVECTOR (alist))[indice];
+bucket = XVECTOR_DATA (alist)[indice];
+}
+else /* warning suppression */
+{
+obsize = 0;
+bucket = Qnil;
 }
 while (1)
 {
 /* Get the next element of the alist or obarray. */
 	    }
 	  else if (++indice >= obsize)
 	    break;
 	  else
 	    {
-	      bucket = vector_data (XVECTOR (alist))[indice];
+	      bucket = XVECTOR_DATA (alist)[indice];
 	      continue;
 	    }
 	}
 /* Is this element a possible completion? */
 			   (matchsize == blength)
 			   && 0 > scmp_1 (XSTRING_DATA (eltstring),
 					  XSTRING_DATA (string),
 					  slength, 0)
 			   && 0 <= scmp_1 (XSTRING_DATA (bestmatch),
 					   XSTRING_DATA (string),
 					   slength, 0)))
 {
 			bestmatch = eltstring;
 blength = eltlength;
 }
 /* This function can GC */
 Lisp_Object tail;
 Lisp_Object allmatches;
 int list;
 int indice = 0;
-int obsize = 0;
+int obsize;
 Lisp_Object bucket;
 Charcount slength;
 CHECK_STRING (string);
 /* If ALIST is not a list, set TAIL just for gc pro.  */
 tail = alist;
 if (!list)
 {
-obsize = vector_length (XVECTOR (alist));
+obsize = XVECTOR_LENGTH (alist);
-bucket = vector_data (XVECTOR (alist))[indice];
+bucket = XVECTOR_DATA (alist)[indice];
+}
+else /* warning suppression */
+{
+obsize = 0;
+bucket = Qnil;
 }
 while (1)
 {
 /* Get the next element of the alist or obarray. */
 }
 	  else if (++indice >= obsize)
 	    break;
 	  else
 	    {
-	      bucket = vector_data (XVECTOR (alist))[indice];
+	      bucket = XVECTOR_DATA (alist)[indice];
 	      continue;
 	    }
 	}
 /* Is this element a possible completion? */
 if (STRINGP (eltstring)
 && (slength <= string_char_length (XSTRING (eltstring)))
 	  /* Reject alternatives that start with space
 	     unless the input starts with space.  */
 	  && ((string_char_length (XSTRING (string)) > 0 &&
 	       string_char (XSTRING (string), 0) == ' ')
 Return the prompt string of the currently-active minibuffer.
 If no minibuffer is active, return nil.
 */
 	 ())
 {
-return (Fcopy_sequence (Vminibuf_prompt));
+return Fcopy_sequence (Vminibuf_prompt);
 }
 xxDEFUN ("minibuffer-prompt-width", Fminibuffer_prompt_width, 0, 0, 0, /*
 Return the display width of the minibuffer prompt.
 */
 	 ())
 {
-return (make_int (minibuf_prompt_width));
+return make_int (minibuf_prompt_width);
 }
 #endif /* 0 */
 /************************************************************************/
 if (!NILP (Ffboundp (Qclear_message)))
 {
 Lisp_Object frame;
 XSETFRAME (frame, f);
 return call4 (Qclear_message, label, frame, from_print ? Qt : Qnil,
 		    no_restore ? Qt : Qnil);
 }
 else
 {
 write_string_to_stdio_stream (stderr, 0, (CONST Bufbyte *) "\n", 0, 1,
 /* some callers pass in a null string as a way of clearing the echo area.
 check for length == 0 now; if this case, neither nonreloc nor reloc
 may be valid.  */
 if (length == 0)
 return;
 fixup_internal_substring (nonreloc, reloc, offset, &length);
 /* also check it here, in case the string was really blank. */
 if (length == 0)
 return;
 if (!NILP (Ffboundp (Qappend_message)))
 	{
 	  if (STRINGP (reloc))
 	    nonreloc = XSTRING_DATA (reloc);
 	  obj = make_string (nonreloc + offset, length);
 	}
 XSETFRAME (frame, f);
 GCPRO1 (obj);
 call4 (Qappend_message, label, obj, frame,
 	     EQ (label, Qprint) ? Qt : Qnil);
 UNGCPRO;
 }
 else
 {
 {
 /* By definition, the echo area is active if the echo-area buffer
 is not empty.  No need to call Lisp code. (Anyway, this function
 is called from redisplay.) */
 struct buffer *echo_buffer = XBUFFER (Vecho_area_buffer);
-return (BUF_BEGV (echo_buffer) != BUF_ZV (echo_buffer));
+return BUF_BEGV (echo_buffer) != BUF_ZV (echo_buffer);
 }
 Lisp_Object
 echo_area_status (struct frame *f)
 {
 if (!NILP (Ffboundp (Qcurrent_message_label)))
 {
 Lisp_Object frame;
 XSETFRAME (frame, f);
-return (call1 (Qcurrent_message_label, frame));
+return call1 (Qcurrent_message_label, frame);
 }
 else
 return stdout_needs_newline ? Qmessage : Qnil;
 }
 Vminibuf_prompt = Qnil;
 /* Added by Jareth Hein (jhod@po.iijnet.or.jp) for input system support */
 staticpro (&Vminibuf_preprompt);
 Vminibuf_preprompt = Qnil;
 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook /*
 Normal hook run just after entry to minibuffer.
 */ );
 Vminibuffer_setup_hook = Qnil;

Mercurial > hg > xemacs-beta

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