xemacs-beta: src/energize.c comparison

comparison src/energize.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	8eaf7971accc
children

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 extern int current_debuggerpanel_exposed_p;
 extern int desired_debuggerpanel_exposed_p;
 extern int debuggerpanel_sheet;
 /**************************** Macros *****************************/
-#define xnew(type) ((type*)xmalloc (sizeof (type)))
 #define BUFFER_NOTIFY_BACKGROUND_BIT_SET_P(buffer) 1
 #define get_extent_data(id,binfo) (Energize_Extent_Data*)get_object(id, binfo)
 #define get_class(id,binfo) (GDataClass*)get_object(id, binfo)
 }
 static GDataClass *
 alloc_GDataclass (EId id, BufferInfo *binfo)
 {
-GDataClass *cl = xnew (GDataClass);
+GDataClass *cl = xnew_and_zero (GDataClass);
-memset (cl, 0, sizeof (GDataClass));
 cl->seal = GDATA_CLASS_SEAL;
 cl->id = id;
 put_class (cl->id, binfo, cl);
 return cl;
 }
 {
 char win_as_string [16];
 nw = XtWindowToWidget (get_x_display (Qnil), win);
 if (nw)
 	nw = XtParent (nw);
 if (nw)
 	sprintf (win_as_string, "w%x", nw);
 else
 	sprintf (win_as_string, "0x%x", win);
 binfo->frame =
 binfo->n_notes = 0;
 #ifdef I18N4
 binfo->wcmap.valid = 0;
 binfo->wcmap.modiff_stamp = -1;
 binfo->wcmap.map = NULL;
 #endif
 put_buffer_info (id, binfo->emacs_buffer, binfo, editor);
 Venergize_buffers_list = Fcons (buffer, Venergize_buffers_list);
 #if 0
 #ifdef I18N4
 if (binfo->wcmap.valid) {
 binfo->wcmap.valid= 0;
 xfree(binfo->wcmap.map);
 }
 #endif
 SET_OBJECT_FREE (binfo);
 }
 /* hash for BufferInfo structures */
 static BufferInfo*
 /* Called by mark_buffer.  It is possible for the last remaining pointer to
 an extent object to be in an Energize_Extent_Data structure that is pointed
 at by the binfo->id_to_object table.  Since Energize may still reference
 this object by its id (in fact, I think it may even "ressurect" a detached
 extent) we must prevent the extent from being garbage collected.  Aside
 from the obvious lossage (that the extent itself would be trashed) this
 would also cause us to free the Energize_Extent_Data which the server still
 believes we have.  The buffers all get marked because they're on the
 `Venergize_buffers_list'.
 hash tables, we again build in the assumption that GC never relocates.
 */
 /* FUCK!!  It's not standard-conforming to cast pointers to functions
 to or from void*.  Give me a fucking break! */
 struct markobj_kludge_fmh
 {
 void (*markobj) (Lisp_Object);
 };
 static void
 }
 #define WCMAP_ENLARGE(wcmap) WCMAP_SETSIZE(wcmap, 2*(wcmap.mapsize))
 #ifndef MB_LEN_MAX
 #define MB_LEN_MAX 10		/* arbitrarily large enough */
 #endif
 static char wcsize_buf[MB_LEN_MAX];
 #define WCSIZE(wc)	     (isascii(wc) ? 1 : wctomb(wcsize_buf,wc))
 #define SANITY_CHECK_NOT
 #ifdef SANITY_CHECK
 static int sanity=0;
 #endif
 static void
 sync_buffer_widechar_map (BufferInfo *binfo)
 {
 /* #### - check this: */
 wchar_t *buf, t;
 #ifdef SANITY_CHECK
 stderr_out ("rebuilding widechar map for %s\n", XSTRING_DATA (current_buffer->name));
 #endif
 /* #### this is not gonna compile.  move_gap() is now a private function
 	 inside of insdel.c and it should stay that way. */
 if (BUF_BEGV (current_buffer) < GPT && BUF_ZV (current_buffer) > GPT)
 	move_gap (current_buffer, BUF_BEGV (current_buffer));
 binfo->wcmap.modiff_stamp = BUF_MODIFF (current_buffer);
 buf = BUF_BEG_ADDR (current_buffer);
 maxpos= (BUF_Z (current_buffer) - 1);
 wctomb (NULL, 0);		/* reset shift state of wctomb() */
 binfo->wcmap.map[mapindex].pos= pos;
 binfo->wcmap.map[mapindex].eucsize=
 if (check_pos != char_pos) {
 stderr_out ("ezpos(%d) = %d, Bufpos(%d) = %d\n",
 	      char_pos, byte_pos, byte_pos, check_pos);
 }
 }
 #endif
 return byte_pos;
 }
 static Bufpos
 BufposForEnergizePos (EnergizePos ez_pos, BufferInfo *binfo)
 if (!sanity) {
 EnergizePos check_pos;
 sanity=1;
 check_pos= EnergizePosForBufpos(char_pos);
 sanity=0;
 if (check_pos != ez_pos) {
 stderr_out ("Bufpos(%d) = %d, EnergizePosForBufpos(%d) = %d\n",
 	      ez_pos, char_pos, char_pos, check_pos);
 }
 }
 #endif
 return char_pos;
 }
 #else /* !I18N4 */
 static Bufpos
 BufposForEnergizePos (EnergizePos energizePos, BufferInfo *binfo)
 {
 return ((energizePos >= (1 << VALBITS)) ? BUF_Z (current_buffer) :
 	  (energizePos + 1));
 }
 static EnergizePos
 EnergizePosForBufpos (Bufpos emacs_pos, BufferInfo *binfo)
 {
 if (energize_connection
 && !NILP (energize_connection->proc)
 && energize_connection->conn
 && CRequestDelayedP (energize_connection->conn))
 this function no longer exists.
 (Replaced by mark_what_as_being_ready, with different arguments.)
 Rewrite this.
 mark_process_as_being_ready (XPROCESS (energize_connection->proc));
 }
 {
 char *first_section_chars = (char *) BUF_BYTE_ADDRESS (buf, bufpos);
 int comp = strncmp (string, first_section_chars,
 			first_section_end - bufpos);
 if (comp) return comp;
 }
 if (first_section_end < BUF_ZV (buf))
 /* there is a second section */
 int no_text_deleted = 0;
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 /* For some reason calling the GC before parsing the buffer data
 makes a better usage of memory and emacs leaks less when
 creating/deleting LE browser buffers.
 However you don't want to call GC all the tiem so we only do it if the request
 will create more than a given number of extents. */
 if (cbu->nExtent > energize_extent_gc_threshold)
 garbage_collect_1 ();
 if (cbu->flags != 0xff)
 get_chars_from_file = cbu->flags &  CBFileYourself;
 else
 get_chars_from_file = binfo->flags &  CBFileYourself;
 #endif
 /* Even when we get the chars from a file there is an empty text string */
 if (get_chars_from_file)
 {
 text = CGetVstring (conn, &text_len);
 text = NULL;
 }
 else
 {
 text = CGetVstring (conn, &text_len);
 }
 /* updates the visited file modtime */
 if (modifying_p && (from != to || text_len)
 /* but only when we do not read the file ourselves */
 && !get_chars_from_file)
 Fset_buffer_modtime (binfo->emacs_buffer, Qnil);
 						     (binfo->output_mark)),
 					   binfo);
 else
 extent_offset = EnergizePosForBufpos (BUF_Z(XBUFFER(binfo->emacs_buffer)),
 					   binfo);
 #if 1
 if (text_len || !text)
 hack_window_point (display_window,
 		       make_int (previous_point),
 		       make_int (display_start),
 #endif
 {
 map_extents (BUF_BEG (current_buffer), BUF_Z (current_buffer),
 		   write_energize_extent_data_mapper, &bane,
 		   binfo->emacs_buffer, 0, ME_END_CLOSED);
 }
 /* update nextent in request's header */
 req = (CEditorRequest *)conn->header;
 req->buffersaved.buffer.nExtent = bane.n_extents;
 		   XSTRING_LENGTH (value));
 	}
 }
 else if (!NILP (selection))
 error ("unrecognized energize selection");
 if (!NILP (no_confirm))
 conn->header->data |= CECnoConfirm;
 CWriteLength (conn);
 CWriteRequestBuffer (conn);
 DEFUN ("energize-list-menu", Fenergize_list_menu, 3, 4, 0, /*
 Request the set of menu options from the Energize server that are
 appropriate to the buffer and the extent.  Extent can be (), in which case
 the options are requested for the whole buffer.	 Selection-p tells
 if the selection is available on the dislpay emacs is using.
 Returns the options as
 a list that can be passed to energize-activate-menu.  Items
 in the list can also be passed to energize-execute-menu-item.
 The list is (buffer extent or () <item1> ... <itemN>).
 where <itemI> is (name id1 id2 flags); idI is (high . low).
 DEFUN ("energize-execute-menu-item", Fenergize_execute_menu_item, 3, 5, 0, /*
 Item is a vector received by energize-list-menu.  Sends a request to
 execute the code associated to this menu inside the Energize server.
 Optional fourth argument is a string or a vector to be used as the selection
 for entry disabled because they need the selection.
 Optional fifth argument, if non NIL, tells Energize to not request
 confirmation before executing the command.
 */
 (buffer, extent_obj, item, selection, no_confirm))
 {
 struct Lisp_Vector *v;
 DEFUN ("energize-execute-command-internal",
 Fenergize_execute_command_internal, 3, 5, 0, /*
 Command is a string naming an energize command.	 Sends a request to
 execute this command inside the Energize server.
 Optional fourth argument is a string or a vector to be used as the selection.
 Optional fifth argument, if non NIL, tells Energize to not request
 confirmation before executing the command.
 See also 'energize-list-menu'.
 */
 (buffer, extent_obj, command, selection, no_confirm))
 else
 {
 /* Do not show the debugger panel in this function.  The
 * debugger panel should never be listed in the visible psheets. */
 extern int debuggerpanel_sheet;
 if (count == 1 && psheets [0] == debuggerpanel_sheet)
 	return;
 FRAME_X_DESIRED_PSHEETS (f) = psheets;
 FRAME_X_DESIRED_PSHEET_COUNT (f) = count;
 }
 }
 /* returns 1 if the buffer is only visible in window on frame f */
 static int
 buffer_only_visible_in_this_window_p (Lisp_Object buffer,
 				      struct frame* f,
 				      struct window* window)
 {
 return !find_buffer_in_different_window (XWINDOW (f->root_window), buffer,
 					   window);
 }
 if (! lw_get_some_values (id, data)) abort ();
 case_sensitive_p = (data->selected ? Qt : Qnil);
 data->name = "matchWord";
 if (! lw_get_some_values (id, data)) abort ();
 match_word_p = (data->selected ? Qt : Qnil);
 data->name = "directionForward";
 if (! lw_get_some_values (id, data)) abort ();
 direction = data->selected ? Qt : Qnil;
 if (!strcmp (name, "search"))
 	replace = Qnil;
 else if (!strcmp (name, "replace"))
 	;
 else if (!strcmp (name, "replace_all"))
 	  replace = list1 (replace);
 	  /*	hide_search_dialog (parent, id); */
 	}
 else
 	abort ();
 free_widget_value (data);
 signal_special_Xt_user_event (device,
 				    intern ("energize-search-internal"),
 				 (NILP (replace)
 				  ? list5 (case_sensitive_p, match_word_p,
 					   regexp_p, direction, search)
 The Lisp object representing the Energize connection, or nil
 */ );
 Venergize_process = Qnil;
 DEFVAR_LISP ("energize-create-buffer-hook", &Venergize_create_buffer_hook /*
 Hook called when buffer is created by energize; takes
 BUFFER as its only argument.
 */ );
 Venergize_create_buffer_hook = Qnil;
 DEFVAR_INT ("energize-extent-gc-threshold", &energize_extent_gc_threshold /*
 Number of  extents in a ModifyBuffer request above which to do a GC
 */ );
 energize_extent_gc_threshold = 20;
 pure_put (Qbuffer_locked_by_energize, Qerror_conditions,
 	    list2 (Qbuffer_locked_by_energize, Qerror));
 pure_put (Qbuffer_locked_by_energize, Qerror_message,
 	    build_string ("Buffer is currently locked by kernel"));
 }

Mercurial > hg > xemacs-beta

comparison src/energize.c @ 185:3d6bfa290dbd r20-3b19