xemacs-beta: src/fileio.c comparison

comparison src/fileio.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
 Lisp_Object Qset_buffer_modtime;
 /* If FILENAME is handled specially on account of its syntax,
 return its handler function.  Otherwise, return nil.  */
-DEFUN ("find-file-name-handler",
+DEFUN ("find-file-name-handler", Ffind_file_name_handler, 1, 2, 0, /*
-Ffind_file_name_handler, Sfind_file_name_handler, 1, 2, 0 /*
 Return FILENAME's handler function for OPERATION, if it has one.
 Otherwise, return nil.
 A file name is handled if one of the regular expressions in
 `file-name-handler-alist' matches it.
 If OPERATION equals `inhibit-file-name-operation', then we ignore
 any handlers that are members of `inhibit-file-name-handlers',
 but we still do run any other handlers.  This lets handlers
 use the standard functions without calling themselves recursively.
-*/ )
+*/
-(filename, operation)
+(filename, operation))
-Lisp_Object filename, operation;
 {
 /* This function must not munge the match data.  */
 Lisp_Object chain, inhibited_handlers;
 CHECK_STRING (filename);
 CHECK_STRING (result);
 return (result);
 }
-DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory,
+DEFUN ("file-name-directory", Ffile_name_directory, 1, 1, 0, /*
-1, 1, 0 /*
 Return the directory component in file name NAME.
 Return nil if NAME does not include a directory.
 Otherwise return a directory spec.
 Given a Unix syntax file name, returns a string ending in slash;
 on VMS, perhaps instead a string ending in `:', `]' or `>'.
-*/ )
+*/
-(file)
+(file))
-Lisp_Object file;
 {
 /* This function can GC */
 Bufbyte *beg;
 Bufbyte *p;
 Lisp_Object handler;
 }
 #endif /* DOS_NT */
 return make_string (beg, p - beg);
 }
-DEFUN ("file-name-nondirectory", Ffile_name_nondirectory,
+DEFUN ("file-name-nondirectory", Ffile_name_nondirectory, 1, 1, 0, /*
-Sfile_name_nondirectory,
-1, 1, 0 /*
 Return file name NAME sans its directory.
 For example, in a Unix-syntax file name,
 this is everything after the last slash,
 or the entire name if it contains no slash.
-*/ )
+*/
-(file)
+(file))
-Lisp_Object file;
 {
 /* This function can GC */
 Bufbyte *beg, *p, *end;
 Lisp_Object handler;
 	 ) p--;
 return make_string (p, end - p);
 }
-DEFUN ("unhandled-file-name-directory",
+DEFUN ("unhandled-file-name-directory", Funhandled_file_name_directory, 1, 1, 0, /*
-Funhandled_file_name_directory, Sunhandled_file_name_directory, 1, 1, 0 /*
 Return a directly usable directory name somehow associated with FILENAME.
 A `directly usable' directory name is one that may be used without the
 intervention of any file handler.
 If FILENAME is a directly usable file itself, return
 (file-name-directory FILENAME).
 The `call-process' and `start-process' functions use this function to
 get a current directory to run processes in.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object handler;
 /* If the file name has special constructs in it,
 }
 #endif /* not VMS */
 return out;
 }
-DEFUN ("file-name-as-directory", Ffile_name_as_directory,
+DEFUN ("file-name-as-directory", Ffile_name_as_directory, 1, 1, 0, /*
-Sfile_name_as_directory, 1, 1, 0 /*
 Return a string representing file FILENAME interpreted as a directory.
 This operation exists because a directory is also a file, but its name as
 a directory is different from its name as a file.
 The result can be used as the value of `default-directory'
 or passed as second argument to `expand-file-name'.
 For a Unix-syntax file name, just appends a slash.
 On VMS, converts \"[X]FOO.DIR\" to \"[X.FOO]\", etc.
-*/ )
+*/
-(file)
+(file))
-Lisp_Object file;
 {
 /* This function can GC */
 char *buf;
 Lisp_Object handler;
 dst[slen - 1] = 0;
 #endif
 return 1;
 }
-DEFUN ("directory-file-name", Fdirectory_file_name, Sdirectory_file_name,
+DEFUN ("directory-file-name", Fdirectory_file_name, 1, 1, 0, /*
-1, 1, 0 /*
 Return the file name of the directory named DIR.
 This is the name of the file that holds the data for the directory DIR.
 This operation exists because a directory is also a file, but its name as
 a directory is different from its name as a file.
 In Unix-syntax, this function just removes the final slash.
 On VMS, given a VMS-syntax directory name such as \"[X.Y]\",
 it returns a file name such as \"[X]Y.DIR.1\".
-*/ )
+*/
-(directory)
+(directory))
-Lisp_Object directory;
 {
 /* This function can GC */
 char *buf;
 Lisp_Object handler;
 #endif
 directory_file_name ((char *) XSTRING_DATA (directory), buf);
 return build_string (buf);
 }
-DEFUN ("make-temp-name", Fmake_temp_name, Smake_temp_name, 1, 1, 0 /*
+DEFUN ("make-temp-name", Fmake_temp_name, 1, 1, 0, /*
 Generate temporary file name (string) starting with PREFIX (a string).
 The Emacs process number forms part of the result,
 so there is no danger of generating a name being used by another process.
-*/ )
+*/
-(prefix)
+(prefix))
-Lisp_Object prefix;
 {
 CONST char suffix[] = "XXXXXX";
 Bufbyte *data;
 Bytecount len;
 Lisp_Object val;
 mktemp ((char *) data);
 return val;
 }
-DEFUN ("expand-file-name", Fexpand_file_name, Sexpand_file_name, 1, 2, 0 /*
+DEFUN ("expand-file-name", Fexpand_file_name, 1, 2, 0, /*
 Convert FILENAME to absolute, and canonicalize it.
 Second arg DEFAULT is directory to start with if FILENAME is relative
 (does not start with slash); if DEFAULT is nil or missing,
 the current buffer's value of default-directory is used.
 Path components that are `.' are removed, and
 note that these simplifications are done without checking the resulting
 paths in the file system.
 An initial `~/' expands to your home directory.
 An initial `~USER/' expands to USER's home directory.
 See also the function `substitute-in-file-name'.
-*/ )
+*/
-(name, defalt)
+(name, defalt))
-Lisp_Object name, defalt;
 {
 /* This function can GC */
 Bufbyte *nm;
 Bufbyte *newdir, *p, *o;
 /* not a full declaration because realpath() is typed differently
 on different systems */
 extern char *realpath ();
-DEFUN ("file-truename", Ffile_truename, Sfile_truename, 1, 2, 0 /*
+DEFUN ("file-truename", Ffile_truename, 1, 2, 0, /*
 Return the canonical name of the given FILE.
 Second arg DEFAULT is directory to start with if FILE is relative
 (does not start with slash); if DEFAULT is nil or missing,
 the current buffer's value of default-directory is used.
 No component of the resulting pathname will be a symbolic link, as
 in the realpath() function.
-*/ )
+*/
-(filename, defalt)
+(filename, defalt))
-Lisp_Object filename, defalt;
 {
 /* This function can GC */
 struct gcpro gcpro1;
 Lisp_Object expanded_name;
 Lisp_Object handler;
 return Qnil;	/* suppress compiler warning */
 #endif /* not VMS */
 }
-DEFUN ("substitute-in-file-name", Fsubstitute_in_file_name,
+DEFUN ("substitute-in-file-name", Fsubstitute_in_file_name, 1, 1, 0, /*
-Ssubstitute_in_file_name, 1, 1, 0 /*
 Substitute environment variables referred to in FILENAME.
 `$FOO' where FOO is an environment variable name means to substitute
 the value of that variable.  The variable name should be terminated
 with a character not a letter, digit or underscore; otherwise, enclose
 the entire variable name in braces.
 If `/~' appears, all of FILENAME through that `/' is discarded.
 On VMS, `$' substitution is not done; this function does little and only
 duplicates what `expand-file-name' does.
-*/ )
+*/
-(string)
+(string))
-Lisp_Object string;
 {
 Bufbyte *nm;
 Bufbyte *s, *p, *o, *x, *endp;
 Bufbyte *target = 0;
 	statptr->st_mode = 0;
 }
 return;
 }
-DEFUN ("copy-file", Fcopy_file, Scopy_file, 2, 4,
+DEFUN ("copy-file", Fcopy_file, 2, 4,
-"fCopy file: \nFCopy %s to file: \np\nP" /*
+"fCopy file: \nFCopy %s to file: \np\nP", /*
 Copy FILE to NEWNAME.  Both args must be strings.
 Signals a `file-already-exists' error if file NEWNAME already exists,
 unless a third argument OK-IF-ALREADY-EXISTS is supplied and non-nil.
 A number as third arg means request confirmation if NEWNAME already exists.
 This is what happens in interactive use with M-x.
 Fourth arg KEEP-TIME non-nil means give the new file the same
 last-modified time as the old one.  (This works on only some systems.)
 A prefix arg makes KEEP-TIME non-nil.
-*/ )
+*/
-(filename, newname, ok_if_already_exists, keep_time)
+(filename, newname, ok_if_already_exists, keep_time))
-Lisp_Object filename, newname, ok_if_already_exists, keep_time;
 {
 /* This function can GC */
 int ifd, ofd, n;
 char buf[16 * 1024];
 struct stat st, out_st;
 UNGCPRO;
 return Qnil;
 }
-DEFUN ("make-directory-internal", Fmake_directory_internal,
+DEFUN ("make-directory-internal", Fmake_directory_internal, 1, 1, 0, /*
-Smake_directory_internal, 1, 1, 0 /*
 Create a directory.  One argument, a file name string.
-*/ )
+*/
-(dirname)
+(dirname))
-Lisp_Object dirname;
 {
 /* This function can GC */
 char dir [MAXPATHLEN];
 Lisp_Object handler;
 report_file_error ("Creating directory", list1 (dirname));
 return Qnil;
 }
-DEFUN ("delete-directory", Fdelete_directory, Sdelete_directory, 1, 1,
+DEFUN ("delete-directory", Fdelete_directory, 1, 1, "FDelete directory: ", /*
-"FDelete directory: " /*
 Delete a directory.  One argument, a file name or directory name string.
-*/ )
+*/
-(dirname)
+(dirname))
-Lisp_Object dirname;
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1;
 report_file_error ("Removing directory", list1 (dirname));
 return Qnil;
 }
-DEFUN ("delete-file", Fdelete_file, Sdelete_file, 1, 1, "fDelete file: " /*
+DEFUN ("delete-file", Fdelete_file, 1, 1, "fDelete file: ", /*
 Delete specified file.  One argument, a file name string.
 If file has multiple names, it continues to exist with the other names.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1;
 {
 return NILP (condition_case_1 (Qt, Fdelete_file, filename,
 				 internal_delete_file_1, Qnil));
 }
-DEFUN ("rename-file", Frename_file, Srename_file, 2, 3,
+DEFUN ("rename-file", Frename_file, 2, 3,
-"fRename file: \nFRename %s to file: \np" /*
+"fRename file: \nFRename %s to file: \np", /*
 Rename FILE as NEWNAME.  Both args strings.
 If file has names other than FILE, it continues to have those names.
 Signals a `file-already-exists' error if a file NEWNAME already exists
 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
 A number as third arg means request confirmation if NEWNAME already exists.
 This is what happens in interactive use with M-x.
-*/ )
+*/
-(filename, newname, ok_if_already_exists)
+(filename, newname, ok_if_already_exists))
-Lisp_Object filename, newname, ok_if_already_exists;
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1, gcpro2;
 }
 UNGCPRO;
 return Qnil;
 }
-DEFUN ("add-name-to-file", Fadd_name_to_file, Sadd_name_to_file, 2, 3,
+DEFUN ("add-name-to-file", Fadd_name_to_file, 2, 3,
-"fAdd name to file: \nFName to add to %s: \np" /*
+"fAdd name to file: \nFName to add to %s: \np", /*
 Give FILE additional name NEWNAME.  Both args strings.
 Signals a `file-already-exists' error if a file NEWNAME already exists
 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
 A number as third arg means request confirmation if NEWNAME already exists.
 This is what happens in interactive use with M-x.
-*/ )
+*/
-(filename, newname, ok_if_already_exists)
+(filename, newname, ok_if_already_exists))
-Lisp_Object filename, newname, ok_if_already_exists;
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1, gcpro2;
 UNGCPRO;
 return Qnil;
 }
 #ifdef S_IFLNK
-DEFUN ("make-symbolic-link", Fmake_symbolic_link, Smake_symbolic_link, 2, 3,
+DEFUN ("make-symbolic-link", Fmake_symbolic_link, 2, 3,
-"FMake symbolic link to file: \nFMake symbolic link to file %s: \np" /*
+"FMake symbolic link to file: \nFMake symbolic link to file %s: \np", /*
 Make a symbolic link to FILENAME, named LINKNAME.  Both args strings.
 Signals a `file-already-exists' error if a file LINKNAME already exists
 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
 A number as third arg means request confirmation if LINKNAME already exists.
 This happens for interactive use with M-x.
-*/ )
+*/
-(filename, linkname, ok_if_already_exists)
+(filename, linkname, ok_if_already_exists))
-Lisp_Object filename, linkname, ok_if_already_exists;
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1, gcpro2;
 }
 #endif /* S_IFLNK */
 #ifdef VMS
-DEFUN ("define-logical-name", Fdefine_logical_name, Sdefine_logical_name,
+DEFUN ("define-logical-name", Fdefine_logical_name, 2, 2,
-2, 2, "sDefine logical name: \nsDefine logical name %s as: " /*
+"sDefine logical name: \nsDefine logical name %s as: ", /*
 Define the job-wide logical name NAME to have the value STRING.
 If STRING is nil or a null string, the logical name NAME is deleted.
-*/ )
+*/
-(varname, string)
+(varname, string))
-Lisp_Object varname;
-Lisp_Object string;
 {
 CHECK_STRING (varname);
 if (NILP (string))
 delete_logical_name ((char *) XSTRING_DATA (varname));
 else
 }
 #endif /* VMS */
 #ifdef HPUX_NET
-DEFUN ("sysnetunam", Fsysnetunam, Ssysnetunam, 2, 2, 0 /*
+DEFUN ("sysnetunam", Fsysnetunam, 2, 2, 0, /*
 Open a network connection to PATH using LOGIN as the login string.
-*/ )
+*/
-(path, login)
+(path, login))
-Lisp_Object path, login;
 {
 int netresult;
 CHECK_STRING (path);
 CHECK_STRING (login);
 else
 return Qt;
 }
 #endif /* HPUX_NET */
-DEFUN ("file-name-absolute-p", Ffile_name_absolute_p, Sfile_name_absolute_p,
+DEFUN ("file-name-absolute-p", Ffile_name_absolute_p, 1, 1, 0, /*
-1, 1, 0 /*
 Return t if file FILENAME specifies an absolute path name.
 On Unix, this is a name starting with a `/' or a `~'.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 Bufbyte *ptr;
 CHECK_STRING (filename);
 ptr = XSTRING_DATA (filename);
 return (access (filename, 2) >= 0);
 #endif
 #endif /* not MSDOS */
 }
-DEFUN ("file-exists-p", Ffile_exists_p, Sfile_exists_p, 1, 1, 0 /*
+DEFUN ("file-exists-p", Ffile_exists_p, 1, 1, 0, /*
 Return t if file FILENAME exists.  (This does not mean you can read it.)
 See also `file-readable-p' and `file-attributes'.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object abspath;
 Lisp_Object handler;
 struct stat statbuf;
 return (Qt);
 else
 return (Qnil);
 }
-DEFUN ("file-executable-p", Ffile_executable_p, Sfile_executable_p, 1, 1, 0 /*
+DEFUN ("file-executable-p", Ffile_executable_p, 1, 1, 0, /*
 Return t if FILENAME can be executed by you.
 For a directory, this means you can access files in that directory.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object abspath;
 Lisp_Object handler;
 struct gcpro gcpro1;
 return (check_executable ((char *) XSTRING_DATA (abspath))
 	  ? Qt : Qnil);
 }
-DEFUN ("file-readable-p", Ffile_readable_p, Sfile_readable_p, 1, 1, 0 /*
+DEFUN ("file-readable-p", Ffile_readable_p, 1, 1, 0, /*
 Return t if file FILENAME exists and you can read it.
 See also `file-exists-p' and `file-attributes'.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object abspath;
 Lisp_Object handler;
 int desc;
 return Qt;
 }
 /* Having this before file-symlink-p mysteriously caused it to be forgotten
 on the RT/PC.  */
-DEFUN ("file-writable-p", Ffile_writable_p, Sfile_writable_p, 1, 1, 0 /*
+DEFUN ("file-writable-p", Ffile_writable_p, 1, 1, 0, /*
 Return t if file FILENAME can be written or created by you.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object abspath, dir;
 Lisp_Object handler;
 struct stat statbuf;
 return (check_writable (!NILP (dir) ? (char *) XSTRING_DATA (dir)
 			  : "")
 	  ? Qt : Qnil);
 }
-DEFUN ("file-symlink-p", Ffile_symlink_p, Sfile_symlink_p, 1, 1, 0 /*
+DEFUN ("file-symlink-p", Ffile_symlink_p, 1, 1, 0, /*
 Return non-nil if file FILENAME is the name of a symbolic link.
 The value is the name of the file to which it is linked.
 Otherwise returns nil.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 #ifdef S_IFLNK
 char *buf;
 int bufsize;
 #else /* not S_IFLNK */
 return Qnil;
 #endif /* not S_IFLNK */
 }
-DEFUN ("file-directory-p", Ffile_directory_p, Sfile_directory_p, 1, 1, 0 /*
+DEFUN ("file-directory-p", Ffile_directory_p, 1, 1, 0, /*
 Return t if file FILENAME is the name of a directory as a file.
 A directory name spec may be given instead; then the value is t
 if the directory so specified exists and really is a directory.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object abspath;
 struct stat st;
 Lisp_Object handler;
 if (stat ((char *) XSTRING_DATA (abspath), &st) < 0)
 return Qnil;
 return (st.st_mode & S_IFMT) == S_IFDIR ? Qt : Qnil;
 }
-DEFUN ("file-accessible-directory-p",
+DEFUN ("file-accessible-directory-p", Ffile_accessible_directory_p, 1, 1, 0, /*
-Ffile_accessible_directory_p, Sfile_accessible_directory_p, 1, 1, 0 /*
 Return t if file FILENAME is the name of a directory as a file,
 and files in that directory can be opened by you.  In order to use a
 directory as a buffer's current directory, this predicate must return true.
 A directory name spec may be given instead; then the value is t
 if the directory so specified exists and really is a readable and
 searchable directory.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1;
 handler = Ffile_executable_p (filename);
 UNGCPRO;
 return (handler);
 }
-DEFUN ("file-regular-p", Ffile_regular_p, Sfile_regular_p, 1, 1, 0 /*
+DEFUN ("file-regular-p", Ffile_regular_p, 1, 1, 0, /*
 "Return t if file FILENAME is the name of a regular file.
 This is the sort of file that holds an ordinary stream of data bytes.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 REGISTER Lisp_Object abspath;
 struct stat st;
 Lisp_Object handler;
 if (stat ((char *) XSTRING_DATA (abspath), &st) < 0)
 return Qnil;
 return (st.st_mode & S_IFMT) == S_IFREG ? Qt : Qnil;
 }
-DEFUN ("file-modes", Ffile_modes, Sfile_modes, 1, 1, 0 /*
+DEFUN ("file-modes", Ffile_modes, 1, 1, 0, /*
 Return mode bits of FILE, as an integer.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 Lisp_Object abspath;
 struct stat st;
 Lisp_Object handler;
 #endif /* DOS_NT */
 return make_int (st.st_mode & 07777);
 }
-DEFUN ("set-file-modes", Fset_file_modes, Sset_file_modes, 2, 2, 0 /*
+DEFUN ("set-file-modes", Fset_file_modes, 2, 2, 0, /*
 Set mode bits of FILE to MODE (an integer).
 Only the 12 low bits of MODE are used.
-*/ )
+*/
-(filename, mode)
+(filename, mode))
-Lisp_Object filename, mode;
 {
 /* This function can GC */
 Lisp_Object abspath;
 Lisp_Object handler;
 struct gcpro gcpro1, gcpro2;
 report_file_error ("Doing chmod", Fcons (abspath, Qnil));
 return Qnil;
 }
-DEFUN ("set-default-file-modes", Fset_default_file_modes,
+DEFUN ("set-default-file-modes", Fset_default_file_modes, 1, 1, 0, /*
-Sset_default_file_modes, 1, 1, 0 /*
 Set the file permission bits for newly created files.
 MASK should be an integer; if a permission's bit in MASK is 1,
 subsequently created files will not have that permission enabled.
 Only the low 9 bits are used.
 This setting is inherited by subprocesses.
-*/ )
+*/
-(mode)
+(mode))
-Lisp_Object mode;
 {
 CHECK_INT (mode);
 umask ((~ XINT (mode)) & 0777);
 return Qnil;
 }
-DEFUN ("default-file-modes", Fdefault_file_modes, Sdefault_file_modes, 0, 0, 0 /*
+DEFUN ("default-file-modes", Fdefault_file_modes, 0, 0, 0, /*
 Return the default file protection for created files.
 The umask value determines which permissions are enabled in newly
 created files.  If a permission's bit in the umask is 1, subsequently
 created files will not have that permission enabled.
-*/ )
+*/
-()
+())
 {
 int mode;
 mode = umask (0);
 umask (mode);
 return make_int ((~ mode) & 0777);
 }
 #ifndef VMS
-DEFUN ("unix-sync", Funix_sync, Sunix_sync, 0, 0, "" /*
+DEFUN ("unix-sync", Funix_sync, 0, 0, "", /*
 Tell Unix to finish all pending disk updates.
-*/ )
+*/
-()
+())
 {
 sync ();
 return Qnil;
 }
 #endif /* !VMS */
-DEFUN ("file-newer-than-file-p", Ffile_newer_than_file_p,
+DEFUN ("file-newer-than-file-p", Ffile_newer_than_file_p, 2, 2, 0, /*
-Sfile_newer_than_file_p, 2, 2, 0 /*
 Return t if file FILE1 is newer than file FILE2.
 If FILE1 does not exist, the answer is nil;
 otherwise, if FILE2 does not exist, the answer is t.
-*/ )
+*/
-(file1, file2)
+(file1, file2))
-Lisp_Object file1, file2;
 {
 /* This function can GC */
 Lisp_Object abspath1, abspath2;
 struct stat st;
 int mtime1;
 /* Stack sizes > 2**16 is a good way to elicit compiler bugs */
 /* #define READ_BUF_SIZE (2 << 16) */
 #define READ_BUF_SIZE (1 << 15)
-DEFUN ("insert-file-contents-internal", Finsert_file_contents_internal,
+DEFUN ("insert-file-contents-internal",
-Sinsert_file_contents_internal, 1, 5, 0 /*
+Finsert_file_contents_internal, 1, 5, 0, /*
 Insert contents of file FILENAME after point.
 Returns list of absolute file name and length of data inserted.
 If second argument VISIT is non-nil, the buffer's visited filename
 and last save file modtime are set, and it is marked unmodified.
 If visiting and the file does not exist, visiting is completed
 If optional fifth argument REPLACE is non-nil,
 it means replace the current buffer contents (in the accessible portion)
 with the file contents.  This is better than simply deleting and inserting
 the whole thing because (1) it preserves some marker positions
 and (2) it puts less data in the undo list.
-*/ )
+*/
-(filename, visit, beg, end, replace)
+(filename, visit, beg, end, replace))
-Lisp_Object filename, visit, beg, end, replace;
 {
 /* This function can GC */
 struct stat st;
 int fd;
 int saverrno = 0;
 that preserves markers pointing to the unchanged parts.  */
 #if !defined (DOS_NT) && !defined (MULE)
 /* The replace-mode code currently only works when the assumption
 'one byte == one char' holds true.  This fails under MSDOS and
 Windows NT (because newlines are represented as CR-LF in text
-files). and under Mule because files may contain multibyte characters. */
+files) and under Mule because files may contain multibyte characters. */
 # define FSFMACS_SPEEDY_INSERT
 #endif
 #ifndef FSFMACS_SPEEDY_INSERT
 if (!NILP (replace))
 {
 Fset_buffer (buf);
 Fkill_buffer (tembuf);
 return Qnil;
 }
-DEFUN ("write-region-internal", Fwrite_region_internal,
+DEFUN ("write-region-internal", Fwrite_region_internal, 3, 6,
-Swrite_region_internal, 3, 6,
+"r\nFWrite region to file: ", /*
-"r\nFWrite region to file: " /*
 Write current region into specified file.
 When called from a program, takes three arguments:
 START, END and FILENAME.  START and END are buffer positions.
 Optional fourth argument APPEND if non-nil means
 append to existing file contents (if any).
 VISIT is also the file name to lock and unlock for clash detection.
 If VISIT is neither t nor nil nor a string,
 that means do not print the \"Wrote file\" message.
 Kludgy feature: if START is a string, then that string is written
 to the file, instead of any buffer contents, and END is ignored.
-*/ )
+*/
-(start, end, filename, append, visit, lockname)
+(start, end, filename, append, visit, lockname))
-Lisp_Object start, end, filename, append, visit, lockname;
 {
 /* This function can GC */
 int desc;
 int failure;
 int save_errno = 0;
 }
 /* #### This is such a load of shit!!!!  There is no way we should define
 something so stupid as a subr, just sort the fucking list more
 intelligently. */
-DEFUN ("car-less-than-car", Fcar_less_than_car, Scar_less_than_car, 2, 2, 0 /*
+DEFUN ("car-less-than-car", Fcar_less_than_car, 2, 2, 0, /*
 Return t if (car A) is numerically less than (car B).
-*/ )
+*/
-(a, b)
+(a, b))
-Lisp_Object a, b;
 {
 return Flss (Fcar (a), Fcar (b));
 }
 /* Heh heh heh, let's define this too, just to aggravate the person who
 wrote the above comment. */
-DEFUN ("cdr-less-than-cdr", Fcdr_less_than_cdr, Scdr_less_than_cdr, 2, 2, 0 /*
+DEFUN ("cdr-less-than-cdr", Fcdr_less_than_cdr, 2, 2, 0, /*
 Return t if (cdr A) is numerically less than (cdr B).
-*/ )
+*/
-(a, b)
+(a, b))
-Lisp_Object a, b;
 {
 return Flss (Fcdr (a), Fcdr (b));
 }
 /* Build the complete list of annotations appropriate for writing out
 #include <des_crypt.h>
 #define CRYPT_BLOCK_SIZE 8	/* bytes */
 #define CRYPT_KEY_SIZE 8	/* bytes */
-DEFUN ("encrypt-string", Fencrypt_string, Sencrypt_string, 2, 2, 0 /*
+DEFUN ("encrypt-string", Fencrypt_string, 2, 2, 0, /*
 Encrypt STRING using KEY.
-*/ )
+*/
-(string, key)
+(string, key))
-Lisp_Object string, key;
 {
 char *encrypted_string, *raw_key;
 int rounded_size, extra, key_size;
 /* !!#### May produce bogus data under Mule. */
 (void) ecb_crypt (raw_key, encrypted_string, rounded_size,
 		    DES_ENCRYPT | DES_SW);
 return make_string (encrypted_string, rounded_size);
 }
-DEFUN ("decrypt-string", Fdecrypt_string, Sdecrypt_string, 2, 2, 0 /*
+DEFUN ("decrypt-string", Fdecrypt_string, 2, 2, 0, /*
 Decrypt STRING using KEY.
-*/ )
+*/
-(string, key)
+(string, key))
-Lisp_Object string, key;
 {
 char *decrypted_string, *raw_key;
 int string_size, key_size;
 CHECK_STRING (string);
 return make_string (decrypted_string, string_size - 1);
 }
 #endif
-DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime,
+DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime, 1, 1, 0, /*
-Sverify_visited_file_modtime, 1, 1, 0 /*
 Return t if last mod time of BUF's visited file matches what BUF records.
 This means that the file has not been changed since it was visited or saved.
-*/ )
+*/
-(buf)
+(buf))
-Lisp_Object buf;
 {
 /* This function can GC */
 struct buffer *b;
 struct stat st;
 Lisp_Object handler;
 	      || st.st_mtime == b->modtime - 1)))
 return Qt;
 return Qnil;
 }
-DEFUN ("clear-visited-file-modtime", Fclear_visited_file_modtime,
+DEFUN ("clear-visited-file-modtime", Fclear_visited_file_modtime, 0, 0, 0, /*
-Sclear_visited_file_modtime, 0, 0, 0 /*
 Clear out records of last mod time of visited file.
 Next attempt to save will certainly not complain of a discrepancy.
-*/ )
+*/
-()
+())
 {
 current_buffer->modtime = 0;
 return Qnil;
 }
-DEFUN ("visited-file-modtime", Fvisited_file_modtime,
+DEFUN ("visited-file-modtime", Fvisited_file_modtime, 0, 0, 0, /*
-Svisited_file_modtime, 0, 0, 0 /*
 Return the current buffer's recorded visited file modification time.
 The value is a list of the form (HIGH . LOW), like the time values
 that `file-attributes' returns.
-*/ )
+*/
-()
+())
 {
 return time_to_lisp ((time_t) current_buffer->modtime);
 }
-DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime,
+DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime, 0, 1, 0, /*
-Sset_visited_file_modtime, 0, 1, 0 /*
 Update buffer's recorded modification time from the visited file's time.
 Useful if the buffer was not read from the file normally
 or if the file itself has been changed for some known benign reason.
 An argument specifies the modification time value to use
 (instead of that of the visited file), in the form of a list
 (HIGH . LOW) or (HIGH LOW).
-*/ )
+*/
-(time_list)
+(time_list))
-Lisp_Object time_list;
 {
 /* This function can GC */
 if (!NILP (time_list))
 {
 time_t the_time;
 }
 return Qnil;
 }
-DEFUN ("set-buffer-modtime", Fset_buffer_modtime,
+DEFUN ("set-buffer-modtime", Fset_buffer_modtime, 1, 2, 0, /*
-Sset_buffer_modtime, 1, 2, 0 /*
 Update BUFFER's recorded modification time from the associated
 file's modtime, if there is an associated file. If not, use the
 current time. In either case, if the optional arg TIME is supplied,
 it will be used if it is either an integer or a cons of two integers.
-*/ )
+*/
-(buf, in_time)
+(buf, in_time))
-Lisp_Object buf, in_time;
 {
 /* This function can GC */
 unsigned long time_to_use = 0;
 int set_time_to_use = 0;
 struct stat st;
 The only time that Fdo_auto_save() is called while GC is in progress
 is if we're going down, as a result of an abort() or a kill signal.
 It's fairly important that we generate autosave files in that case!
 */
-DEFUN ("do-auto-save", Fdo_auto_save, Sdo_auto_save, 0, 2, "" /*
+DEFUN ("do-auto-save", Fdo_auto_save, 0, 2, "", /*
 Auto-save all buffers that need it.
 This is all buffers that have auto-saving enabled
 and are changed since last auto-saved.
 Auto-saving writes the buffer into a file
 so that your editing is not lost if the system crashes.
 This file is not the file you visited; that changes only when you save.
 Normally we run the normal hook `auto-save-hook' before saving.
 Non-nil first argument means do not print any message if successful.
 Non-nil second argument means save only current buffer.
-*/ )
+*/
-(no_message, current_only)
+(no_message, current_only))
-Lisp_Object no_message, current_only;
 {
 /* This function can GC */
 struct buffer *old = current_buffer, *b;
 Lisp_Object tail, buf;
 int auto_saved = 0;
 Vquit_flag = oquit;
 RETURN_UNGCPRO (unbind_to (speccount, Qnil));
 }
-DEFUN ("set-buffer-auto-saved", Fset_buffer_auto_saved,
+DEFUN ("set-buffer-auto-saved", Fset_buffer_auto_saved, 0, 0, 0, /*
-Sset_buffer_auto_saved, 0, 0, 0 /*
 Mark current buffer as auto-saved with its current text.
 No auto-save file will be written until the buffer changes again.
-*/ )
+*/
-()
+())
 {
 current_buffer->auto_save_modified = BUF_MODIFF (current_buffer);
 current_buffer->save_length = make_int (BUF_SIZE (current_buffer));
 current_buffer->auto_save_failure_time = -1;
 return Qnil;
 }
-DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure,
+DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure, 0, 0, 0, /*
-Sclear_buffer_auto_save_failure, 0, 0, 0 /*
 Clear any record of a recent auto-save failure in the current buffer.
-*/ )
+*/
-()
+())
 {
 current_buffer->auto_save_failure_time = -1;
 return Qnil;
 }
-DEFUN ("recent-auto-save-p", Frecent_auto_save_p, Srecent_auto_save_p,
+DEFUN ("recent-auto-save-p", Frecent_auto_save_p, 0, 0, 0, /*
-0, 0, 0 /*
 Return t if buffer has been auto-saved since last read in or saved.
-*/ )
+*/
-()
+())
 {
 return (BUF_SAVE_MODIFF (current_buffer) <
 	  current_buffer->auto_save_modified) ? Qt : Qnil;
 }
 defsymbol (&Qcompute_buffer_file_truename, "compute-buffer-file-truename");
 deferror (&Qfile_error, "file-error", "File error", Qio_error);
 deferror (&Qfile_already_exists, "file-already-exists",
 	    "File already exists", Qfile_error);
-defsubr (&Sfind_file_name_handler);
+DEFSUBR (Ffind_file_name_handler);
-defsubr (&Sfile_name_directory);
+DEFSUBR (Ffile_name_directory);
-defsubr (&Sfile_name_nondirectory);
+DEFSUBR (Ffile_name_nondirectory);
-defsubr (&Sunhandled_file_name_directory);
+DEFSUBR (Funhandled_file_name_directory);
-defsubr (&Sfile_name_as_directory);
+DEFSUBR (Ffile_name_as_directory);
-defsubr (&Sdirectory_file_name);
+DEFSUBR (Fdirectory_file_name);
-defsubr (&Smake_temp_name);
+DEFSUBR (Fmake_temp_name);
-defsubr (&Sexpand_file_name);
+DEFSUBR (Fexpand_file_name);
-defsubr (&Sfile_truename);
+DEFSUBR (Ffile_truename);
-defsubr (&Ssubstitute_in_file_name);
+DEFSUBR (Fsubstitute_in_file_name);
-defsubr (&Scopy_file);
+DEFSUBR (Fcopy_file);
-defsubr (&Smake_directory_internal);
+DEFSUBR (Fmake_directory_internal);
-defsubr (&Sdelete_directory);
+DEFSUBR (Fdelete_directory);
-defsubr (&Sdelete_file);
+DEFSUBR (Fdelete_file);
-defsubr (&Srename_file);
+DEFSUBR (Frename_file);
-defsubr (&Sadd_name_to_file);
+DEFSUBR (Fadd_name_to_file);
 #ifdef S_IFLNK
-defsubr (&Smake_symbolic_link);
+DEFSUBR (Fmake_symbolic_link);
 #endif /* S_IFLNK */
 #ifdef VMS
-defsubr (&Sdefine_logical_name);
+DEFSUBR (Fdefine_logical_name);
 #endif /* VMS */
 #ifdef HPUX_NET
-defsubr (&Ssysnetunam);
+DEFSUBR (Fsysnetunam);
 #endif /* HPUX_NET */
-defsubr (&Sfile_name_absolute_p);
+DEFSUBR (Ffile_name_absolute_p);
-defsubr (&Sfile_exists_p);
+DEFSUBR (Ffile_exists_p);
-defsubr (&Sfile_executable_p);
+DEFSUBR (Ffile_executable_p);
-defsubr (&Sfile_readable_p);
+DEFSUBR (Ffile_readable_p);
-defsubr (&Sfile_writable_p);
+DEFSUBR (Ffile_writable_p);
-defsubr (&Sfile_symlink_p);
+DEFSUBR (Ffile_symlink_p);
-defsubr (&Sfile_directory_p);
+DEFSUBR (Ffile_directory_p);
-defsubr (&Sfile_accessible_directory_p);
+DEFSUBR (Ffile_accessible_directory_p);
-defsubr (&Sfile_regular_p);
+DEFSUBR (Ffile_regular_p);
-defsubr (&Sfile_modes);
+DEFSUBR (Ffile_modes);
-defsubr (&Sset_file_modes);
+DEFSUBR (Fset_file_modes);
-defsubr (&Sset_default_file_modes);
+DEFSUBR (Fset_default_file_modes);
-defsubr (&Sdefault_file_modes);
+DEFSUBR (Fdefault_file_modes);
-defsubr (&Sunix_sync);
+DEFSUBR (Funix_sync);
-defsubr (&Sfile_newer_than_file_p);
+DEFSUBR (Ffile_newer_than_file_p);
-defsubr (&Sinsert_file_contents_internal);
+DEFSUBR (Finsert_file_contents_internal);
-defsubr (&Swrite_region_internal);
+DEFSUBR (Fwrite_region_internal);
-defsubr (&Scar_less_than_car); /* Vomitous! */
+DEFSUBR (Fcar_less_than_car); /* Vomitous! */
-defsubr (&Scdr_less_than_cdr); /* Yeah oh yeah bucko .... */
+DEFSUBR (Fcdr_less_than_cdr); /* Yeah oh yeah bucko .... */
 #if 0
-defsubr (&Sencrypt_string);
+DEFSUBR (Fencrypt_string);
-defsubr (&Sdecrypt_string);
+DEFSUBR (Fdecrypt_string);
 #endif
-defsubr (&Sverify_visited_file_modtime);
+DEFSUBR (Fverify_visited_file_modtime);
-defsubr (&Sclear_visited_file_modtime);
+DEFSUBR (Fclear_visited_file_modtime);
-defsubr (&Svisited_file_modtime);
+DEFSUBR (Fvisited_file_modtime);
-defsubr (&Sset_visited_file_modtime);
+DEFSUBR (Fset_visited_file_modtime);
-defsubr (&Sset_buffer_modtime);
+DEFSUBR (Fset_buffer_modtime);
-defsubr (&Sdo_auto_save);
+DEFSUBR (Fdo_auto_save);
-defsubr (&Sset_buffer_auto_saved);
+DEFSUBR (Fset_buffer_auto_saved);
-defsubr (&Sclear_buffer_auto_save_failure);
+DEFSUBR (Fclear_buffer_auto_save_failure);
-defsubr (&Srecent_auto_save_p);
+DEFSUBR (Frecent_auto_save_p);
 }
 void
 vars_of_fileio (void)
 {

Mercurial > hg > xemacs-beta

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