#include "commands.h"
-#ifndef FILE_SYSTEM_CASE
-#define FILE_SYSTEM_CASE(filename) (filename)
-#endif
-
/* Nonzero during writing of auto-save files. */
static int auto_saving;
synchronize_system_messages_locale ();
str = strerror (errorno);
- errstring = code_convert_string_norecord (make_unibyte_string (str,
- strlen (str)),
+ errstring = code_convert_string_norecord (build_unibyte_string (str),
Vlocale_coding_system, 0);
while (1)
return STRINGP (handled_name) ? handled_name : Qnil;
}
- filename = FILE_SYSTEM_CASE (filename);
#ifdef DOS_NT
beg = alloca (SBYTES (filename) + 1);
memcpy (beg, SSDATA (filename), SBYTES (filename) + 1);
if (p == beg + 4 && IS_DIRECTORY_SEP (*beg) && beg[1] == ':')
{
- strncpy (res, beg, 2);
+ memcpy (res, beg, 2);
beg += 2;
r += 2;
}
UNGCPRO;
}
}
- name = FILE_SYSTEM_CASE (name);
multibyte = STRING_MULTIBYTE (name);
if (multibyte != STRING_MULTIBYTE (default_directory))
{
/* Copy out the variable name. */
target = alloca (s - o + 1);
- strncpy (target, o, s - o);
+ memcpy (target, o, s - o);
target[s - o] = 0;
#ifdef DOS_NT
strupr (target); /* $home == $HOME etc. */
env variables twice should be acceptable. Note that
decoding may cause a garbage collect. */
Lisp_Object orig, decoded;
- orig = make_unibyte_string (o, strlen (o));
+ orig = build_unibyte_string (o);
decoded = DECODE_FILE (orig);
total += SBYTES (decoded);
substituted = 1;
/* Copy out the variable name. */
target = alloca (s - o + 1);
- strncpy (target, o, s - o);
+ memcpy (target, o, s - o);
target[s - o] = 0;
#ifdef DOS_NT
strupr (target); /* $home == $HOME etc. */
orig = make_unibyte_string (o, orig_length);
decoded = DECODE_FILE (orig);
decoded_length = SBYTES (decoded);
- strncpy (x, SSDATA (decoded), decoded_length);
+ memcpy (x, SDATA (decoded), decoded_length);
x += decoded_length;
/* If environment variable needed decoding, return value
needs to be multibyte. */
if (decoded_length != orig_length
- || strncmp (SSDATA (decoded), o, orig_length))
+ || memcmp (SDATA (decoded), o, orig_length))
multibyte = 1;
}
}
DWORD attributes;
char * filename;
- EMACS_GET_TIME (now);
filename = SDATA (encoded_newname);
/* Ensure file is writable while its modified time is set. */
attributes = GetFileAttributes (filename);
SetFileAttributes (filename, attributes & ~FILE_ATTRIBUTE_READONLY);
+ now = current_emacs_time ();
if (set_file_times (-1, filename, now, now))
{
/* Restore original attributes. */
set_buffer_internal (XBUFFER (buffer));
adjust_markers_for_delete (BEG, BEG_BYTE, Z, Z_BYTE);
adjust_overlays_for_delete (BEG, Z - BEG);
- BUF_INTERVALS (current_buffer) = 0;
+ buffer_set_intervals (current_buffer, NULL);
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
/* Now we are safe to change the buffer's multibyteness directly. */
- BVAR (current_buffer, enable_multibyte_characters) = multibyte;
- BVAR (current_buffer, undo_list) = undo_list;
+ BSET (current_buffer, enable_multibyte_characters, multibyte);
+ BSET (current_buffer, undo_list, undo_list);
return Qnil;
}
static EMACS_TIME
time_error_value (int errnum)
{
- EMACS_TIME t;
int ns = (errnum == ENOENT || errnum == EACCES || errnum == ENOTDIR
? NONEXISTENT_MODTIME_NSECS
: UNKNOWN_MODTIME_NSECS);
- EMACS_SET_SECS_NSECS (t, 0, ns);
- return t;
+ return make_emacs_time (0, ns);
}
DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,
buf = XBUFFER (workbuf);
delete_all_overlays (buf);
- BVAR (buf, directory) = BVAR (current_buffer, directory);
- BVAR (buf, read_only) = Qnil;
- BVAR (buf, filename) = Qnil;
- BVAR (buf, undo_list) = Qt;
- eassert (buf->overlays_before == NULL);
- eassert (buf->overlays_after == NULL);
+ BSET (buf, directory, BVAR (current_buffer, directory));
+ BSET (buf, read_only, Qnil);
+ BSET (buf, filename, Qnil);
+ BSET (buf, undo_list, Qt);
+ eassert (buffer_get_overlays (buf, OV_BEFORE) == NULL);
+ eassert (buffer_get_overlays (buf, OV_AFTER) == NULL);
set_buffer_internal (buf);
Ferase_buffer ();
- BVAR (buf, enable_multibyte_characters) = Qnil;
+ BSET (buf, enable_multibyte_characters, Qnil);
insert_1_both ((char *) read_buf, nread, nread, 0, 0, 0);
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
unwind_data = Fcons (BVAR (current_buffer, enable_multibyte_characters),
Fcons (BVAR (current_buffer, undo_list),
Fcurrent_buffer ()));
- BVAR (current_buffer, enable_multibyte_characters) = Qnil;
- BVAR (current_buffer, undo_list) = Qt;
+ BSET (current_buffer, enable_multibyte_characters, Qnil);
+ BSET (current_buffer, undo_list, Qt);
record_unwind_protect (decide_coding_unwind, unwind_data);
if (inserted > 0 && ! NILP (Vset_auto_coding_function))
&& NILP (replace))
/* Visiting a file with these coding system makes the buffer
unibyte. */
- BVAR (current_buffer, enable_multibyte_characters) = Qnil;
+ BSET (current_buffer, enable_multibyte_characters, Qnil);
}
coding.dst_multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
if (!NILP (visit))
{
if (!EQ (BVAR (current_buffer, undo_list), Qt) && !nochange)
- BVAR (current_buffer, undo_list) = Qnil;
+ BSET (current_buffer, undo_list, Qnil);
if (NILP (handler))
{
current_buffer->modtime = mtime;
current_buffer->modtime_size = st.st_size;
- BVAR (current_buffer, filename) = orig_filename;
+ BSET (current_buffer, filename, orig_filename);
}
SAVE_MODIFF = MODIFF;
/* Save old undo list and don't record undo for decoding. */
old_undo = BVAR (current_buffer, undo_list);
- BVAR (current_buffer, undo_list) = Qt;
+ BSET (current_buffer, undo_list, Qt);
if (NILP (replace))
{
if (NILP (visit))
{
- BVAR (current_buffer, undo_list) = old_undo;
+ BSET (current_buffer, undo_list, old_undo);
if (CONSP (old_undo) && inserted != old_inserted)
{
/* Adjust the last undo record for the size change during
else
/* If undo_list was Qt before, keep it that way.
Otherwise start with an empty undo_list. */
- BVAR (current_buffer, undo_list) = EQ (old_undo, Qt) ? Qt : Qnil;
+ BSET (current_buffer, undo_list, EQ (old_undo, Qt) ? Qt : Qnil);
unbind_to (count1, Qnil);
}
{
SAVE_MODIFF = MODIFF;
XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
- BVAR (current_buffer, filename) = visit_file;
+ BSET (current_buffer, filename, visit_file);
}
UNGCPRO;
return val;
{
SAVE_MODIFF = MODIFF;
XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
- BVAR (current_buffer, filename) = visit_file;
+ BSET (current_buffer, filename, visit_file);
update_mode_lines++;
}
else if (quietly)
struct stat st;
Lisp_Object handler;
Lisp_Object filename;
- EMACS_TIME mtime, diff, one_second;
+ EMACS_TIME mtime, diff;
if (NILP (buf))
b = current_buffer;
if ((EMACS_TIME_EQ (mtime, b->modtime)
/* If both exist, accept them if they are off by one second. */
|| (EMACS_TIME_VALID_P (mtime) && EMACS_TIME_VALID_P (b->modtime)
- && ((EMACS_TIME_LT (mtime, b->modtime)
- ? EMACS_SUB_TIME (diff, b->modtime, mtime)
- : EMACS_SUB_TIME (diff, mtime, b->modtime)),
- EMACS_SET_SECS_NSECS (one_second, 1, 0),
- EMACS_TIME_LE (diff, one_second))))
+ && ((diff = (EMACS_TIME_LT (mtime, b->modtime)
+ ? sub_emacs_time (b->modtime, mtime)
+ : sub_emacs_time (mtime, b->modtime))),
+ EMACS_TIME_LE (diff, make_emacs_time (1, 0)))))
&& (st.st_size == b->modtime_size
|| b->modtime_size < 0))
return Qt;
Next attempt to save will certainly not complain of a discrepancy. */)
(void)
{
- EMACS_SET_SECS_NSECS (current_buffer->modtime, 0, UNKNOWN_MODTIME_NSECS);
+ current_buffer->modtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS);
current_buffer->modtime_size = -1;
return Qnil;
}
msg = Fformat (3, args);
GCPRO1 (msg);
nbytes = SBYTES (msg);
- SAFE_ALLOCA (msgbuf, char *, nbytes);
+ msgbuf = SAFE_ALLOCA (nbytes);
memcpy (msgbuf, SDATA (msg), nbytes);
for (i = 0; i < 3; ++i)
|| NILP (Ffind_file_name_handler (BVAR (b, auto_save_file_name),
Qwrite_region))))
{
- EMACS_TIME before_time, after_time;
-
- EMACS_GET_TIME (before_time);
+ EMACS_TIME before_time = current_emacs_time ();
+ EMACS_TIME after_time;
/* If we had a failure, don't try again for 20 minutes. */
if (b->auto_save_failure_time > 0
XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
set_buffer_internal (old);
- EMACS_GET_TIME (after_time);
+ after_time = current_emacs_time ();
/* If auto-save took more than 60 seconds,
assume it was an NFS failure that got a timeout. */
Fput (Qfile_error, Qerror_conditions,
Fpurecopy (list2 (Qfile_error, Qerror)));
Fput (Qfile_error, Qerror_message,
- make_pure_c_string ("File error"));
+ build_pure_c_string ("File error"));
Fput (Qfile_already_exists, Qerror_conditions,
Fpurecopy (list3 (Qfile_already_exists, Qfile_error, Qerror)));
Fput (Qfile_already_exists, Qerror_message,
- make_pure_c_string ("File already exists"));
+ build_pure_c_string ("File already exists"));
Fput (Qfile_date_error, Qerror_conditions,
Fpurecopy (list3 (Qfile_date_error, Qfile_error, Qerror)));
Fput (Qfile_date_error, Qerror_message,
- make_pure_c_string ("Cannot set file date"));
+ build_pure_c_string ("Cannot set file date"));
DEFVAR_LISP ("file-name-handler-alist", Vfile_name_handler_alist,
doc: /* Alist of elements (REGEXP . HANDLER) for file names handled specially.
HCoop / bpt / emacs.git / blobdiff