/* 
    What follows is my files.e after making changes so read-only files
    stay that way.  It does not garuntee that you won't change the buffer
    but it will beep for most charicters and will not save the file.

    There may be better ways to accomplish this but this one works.

    At the bottom of this file is the output from a diff if you need to
    merge these changes into different source.

*/


/************************************************************************
* "Epsilon", "EEL" and "Lugaru" are trademarks of Lugaru Software, Ltd. *
*									*
*  Copyright (C) 1985, 1989 Lugaru Software Ltd.  All rights reserved.	*
*									*
* Limited permission is hereby granted to reproduce and modify this	*
* copyrighted material provided that the resulting code is used only in	*
* conjunction with Lugaru products and that this notice is retained in	*
* any such reproduction or modification.				*
************************************************************************/

#include "eel.h"

/* Ask for a file name and save buffer to that file if one is given. */
command write_file() on cx_tab[CTRL('W')]
{
	char tmp[FNAMELEN];

	iter = 0;
	get_file_dir(tmp, "Write file: ", filename);
	if (*tmp) {
		filename = tmp;
		return save_file();
	}
	return 0;
}

command copy_to_file() on reg_tab[FCTRL(7)]
{
	char tmp[FNAMELEN], orig[FNAMELEN];
	int mod = modified;

	iter = 0;
	strcpy(orig, filename);
	get_file(tmp, "Copy to file", filename);
	filename = tmp;
	save_file();
	filename = orig;
	modified = mod;
}

command visit_file() on cx_tab[CTRL('V')]
{
	char tmp[FNAMELEN];
	char resp[80];

	iter = 0;
	get_file(tmp, "Visit file", filename);
	if (!*tmp)
		return;
	if (!has_arg && modified) {		/* buffer need to be saved? */
		get_string(resp, "Save buffer? [y]");
		if (toupper(*resp) != 'N')
			save_file();
		}
	read_file(tmp, strip_returns);
}

/* read the specifed file into the current buffer */
read_file(tmp, strip)
	char *tmp;
{
	struct file_info finfo;
	int err;

	filename = tmp;
	err = file_read(filename, strip);
	if (err == 2) {
		zap(bufname);
		modified = 0;
		say("%s: New file.",tmp);
	} else if (err)
		file_error(err, tmp, "read error");
	  else if (!err) {
		if (CHECK_FILE == check_file(tmp,  &finfo)) {
			if (finfo.fattr & 1) {
				make_readonly();
			}
		}
	}
	return err;
}

char ro_mode_name[] = "ReadOnly";
keytable ro_tab;			/* key table for ro mode */

command readonly_character()   /*  */
{
	ding();
}

command make_readonly()   /*  */
{
	short x;
	major_mode = ro_mode_name;
	make_mode();
	mode_keys = ro_tab;		/* use these keys */
	for (x = ' '; x < '~'; x++)
		mode_keys[x] = (short)readonly_character;
}

command insert_file() on cx_tab['i']
{
	char file[FNAMELEN], *orig = bufname, *buf;
	int err, want_strip = strip_returns;

	iter = 0;
	get_file(file, "Insert file", region_file);
	mark = point;
	bufname = buf = temp_buf();
	err = file_read(file, want_strip);
	if (!err)
		xfer(orig, 0, size());
	bufname = orig;
	build_first = 1;
	delete_buffer(buf);
	if (err)
		file_error(err, file, "read error");
	else
		strcpy(region_file, file);
}

command write_region() on cx_tab['w']
{
	char file[FNAMELEN], *orig = bufname, *buf;
	int err, want_strip = strip_returns;	/* use orig buffer's val */

	get_file(file, "Write region to file", region_file);
	buf = temp_buf();
	xfer(buf, point, mark);
	bufname = buf;
	err = file_write(file, want_strip);
	bufname = orig;
	delete_buffer(buf);
	if (err)
		file_error(err, file, "write error");
	else {
		strcpy(region_file, file);
		say("%s written.", file);
	}
}

/* user routine to save a file.  used by various other user routines.  Returns
   non-zero and prints message in echo area if some sort of error happened. */
command save_file() on cx_tab[CTRL('S')]
{
	char backupname[80];

	iter = 0;
	if (major_mode == ro_mode_name)
		return 1;
	if (!*filename)
		return write_file();
	strcpy(backupname, filename);
	strcpy(get_extension(backupname), ".bak");
	if (want_backups && strcmp(filename, backupname)) {
		delete_file(backupname);	/* don't check errors */
		rename_file(filename, backupname);
	}
	return do_save_file();
}

do_save_file()
{
	int err;

	if (err = file_write(filename, strip_returns))
		file_error(err, filename, "write error");
	else
		say("%s written.", filename);
	return err;
}

command change_modified() on reg_tab[ALT('~')]
{
	modified = has_arg? (iter != 0) : !modified;
	iter = 0;
}

list_line(inbuffer)	/* insert a line into the buffer list */
char *inbuffer;
{
	char file[FNAMELEN], msg[160];

	relative(filename, file);
	sprintf(msg, " %7d %c  %-16s %s\n",
		size(), modified ? '*' : ' ', bufname, file);
	bufname = inbuffer;
	stuff(msg);
}

make_buffer_list(all, inbuffer)	/* put buffer list in specified buffer */
char *inbuffer;
{
	char *old = bufname, *s;

	create(inbuffer);
	zap(inbuffer);
	s = buffer_list(1);
	do {
		bufname = s;
		if (*filename != '\0')
			list_line(inbuffer);
	} while (s = buffer_list(0));
	if (all) {
		s = buffer_list(1);
		do {
			bufname = s;
			if (*filename == '\0')
				list_line(inbuffer);
		} while (s = buffer_list(0));
		iter=0;
	}
	bufname = inbuffer;
	point = 0;
	stuff("    Size    Buffer           File\n");
	point = 0;
	bufname = old;
}

command list_buffers() on cx_tab[CTRL('B')]
{
	make_buffer_list(has_arg, "help");
	view_buffer("help");
}

unsaved_buffers()	/* return 1 if any unsaved buffers exist */
{
	char *orig = bufname, *s = buffer_list(1);
	int ret = 0;

	do {
		bufname = s;
		if (modified && *filename && size()) {
			ret = 1;
			break;
		}
	} while (s = buffer_list(0));
	bufname = orig;
	return ret;
}

maybe_save_all()	/* possibly save all buffers, depending on variable */
{
	switch (save_when_making) {
		case 0:		return;		/* never do it */
		case 1:		break;		/* always do it */
		default:	if (!unsaved_buffers())
					return;
				bufed();
				sayput("Save unsaved buffers first [N]? ");
				maybe_refresh();
				getkey();
				to_buffer(previous_buffer);
				if (toupper(key) == 'Y')
					break;
				check_abort();
				return;
	}
	save_all_buffers();
}

command save_all_buffers()
{
	char *old = bufname, *s;

	s = buffer_list(1);
	do {
		bufname = s;
		if (*filename != '\0' && modified)
			if(save_file()){
				bufname = old;
				quick_abort();
			}
	} while (s = buffer_list(0));
	bufname = old;
}

make_bname(fname, bname) /* build buffer name from file name for find-file */
char *fname, *bname;
{
	int uniq = 1, ok;
	char *from, *to, *oldbuf;

	strcpy(bname, get_tail(fname, 0));
	bname[14] = 0;		/* make no long buffer names */
	if (!(to = rindex(bname, '.')) || to == bname)
		to = bname + strlen(bname);
	while (exist(bname)) {
		oldbuf = bufname;
		bufname = bname;
		ok = (size() == 0);
		bufname = oldbuf;
		if (ok) return;
		sprintf(to, "<%d>", uniq++);
	}
}

command find_file() on cx_tab[CTRL('F')]
{
	char fname[FNAMELEN];

	iter = 0;
	get_file_dir(fname, "Find file: ", filename);
	find_it(fname, !has_arg);
}


find_it(fname, strip)	/* find named file (must be in absolute form) */
char *fname;
{
	char bname[FNAMELEN+10], *s, mode[80];

	if (fname[0] == '\0' || strcmp(filename, fname) == 0)
		return;
	s = buffer_list(1);
	do {
		bufname = s;
		if (strcmp(filename, fname) == 0) {
			to_buffer(s);
			return;
		}
	} while (s = buffer_list(0));
	make_bname(fname, bname);
	to_buffer(bname);
	if (!strip) {
		strip_returns = 0;
		make_mode();
	}
	read_file(fname, strip_returns);
	s = get_extension(fname);
	sprintf(mode, "suffix-%s", *s ? (s + 1) : "none");
	if (major_mode != ro_mode_name)
		if (!try_calling(mode))
			try_calling("suffix-default");
}

command count_lines() on cx_tab['l']
{
	int count = 0, here = 0, start = point;

	sayput("Counting...");
	point = 0;
	while (nl_forward() && !user_abort) {
		count++;
		if (!here && start < point) {
			here = count;
			sayput("Counting... point on line %d...", here);
		}
	}
	point = start;
	check_abort();
	if (!here)
		here = count + 1;
	say("%d lines, point on line %d.  %d bytes on disk.",
		count + 1, here, size() + (strip_returns ? count : 0));
	iter = 0;
}

command show_point() on cx_tab['=']
{
	char msg[80], c;

	sprintf(msg, "Column=%d, point=%d, size=%d", current_column(),
			point, size());
	if (point < size())
		if (c = curchar())
			sprintf(msg + strlen(msg),
				", char %d is '%c'=%d decimal=%x hex",
				point, c, c, c);
		else
			sprintf(msg + strlen(msg), ", char %d is '\0'",
				point);
	say("%s", msg);
	iter = 0;
}

command write_state() on reg_tab[FCTRL(3)]
{
	char fname[80], *s;

	if (!*state_file) {
		sprintf(fname, "epsilon%s", state_extension);
		s = lookpath(fname);
		strcpy(state_file, s ? s : fname);
	}
	get_file(fname, "Write current state on file", state_file);
	if (!*fname)
		return;

	do_save_state(fname);
	strcpy(state_file, fname);
	iter = 0;
}

do_save_state(fname)		/* save state in file, aborting on error */
char *fname;
{
	char file[80], rel[80];
	int err;

	strcpy(file, fname);
	get_doc();		/* save doc file position too */
	sayput("Writing...");

	strcpy(get_extension(file), state_extension);
	relative(file, rel);
	if (err = save_state(file)) {
		file_error(err, file, "write error");
		quick_abort();
	} else
		say("State saved on %s.", rel);
}

command set_line_translate()
{
	strip_returns = (has_arg? (iter != 0) : !strip_returns);
	say(strip_returns ? "Add/remove return characters"
			: "No changes when reading or writing");
	make_mode();
	iter = 1;
}

command cd() on reg_tab[FKEY(7)]	/* change current directory */
{
	char resp[FNAMELEN], dir[FNAMELEN];

	getcd(dir);
	get_file(resp, "Change to directory", dir);
	if (*resp && chdir(resp))
		file_error(errno, resp, "unknown error");
	else {
		getcd(dir);
		say("Current directory: %s", dir);
	}
}

#if 0
   source\files.e (19 Jan 1989 15:20:40)
           files.e (23 Mar 1990 17:20:16)
===================
      58      58  |
      59      59  |/* read the specifed file into the current buffer */
      60      60  |read_file(tmp, strip)
      61      61  |    char *tmp;
      62      62  |{
+             63  |    struct file_info finfo;
      63      64  |    int err;
      64      65  |
      65      66  |    filename = tmp;
      66      67  |    err = file_read(filename, strip);
      67      68  |    if (err == 2) {
      68      69  |        zap(bufname);
      69      70  |        modified = 0;
      70      71  |        say("%s: New file.",tmp);
      71      72  |    } else if (err)
      72      73  |        file_error(err, tmp, "read error");
+             74  |      else if (!err) {
+             75  |        if (CHECK_FILE == check_file(tmp,  &finfo)) {
+             76  |            if (finfo.fattr & 1) {
+             77  |                make_readonly();
+             78  |            }
+             79  |        }
+             80  |    }
      73      81  |    return err;
+             82  |}
+             83  |
+             84  |char ro_mode_name[] = "ReadOnly";
+             85  |keytable ro_tab;            /* key table for ro mode */
+             86  |
+             87  |command readonly_character()   /*  */
+             88  |{
+             89  |    ding();
+             90  |}
+             91  |
+             92  |command make_readonly()   /*  */
+             93  |{
+             94  |    short x;
+             95  |    major_mode = ro_mode_name;
+             96  |    make_mode();
+             97  |    mode_keys = ro_tab;     /* use these keys */
+             98  |    for (x = ' '; x < '~'; x++)
+             99  |        mode_keys[x] = (short)readonly_character;
      74     100  |}
      75     101  |
      76     102  |command insert_file() on cx_tab['i']
      77     103  |{
      78     104  |    char file[FNAMELEN], *orig = bufname, *buf;
===================
     119     145  |command save_file() on cx_tab[CTRL('S')]
     120     146  |{
     121     147  |    char backupname[80];
     122     148  |
     123     149  |    iter = 0;
+            150  |    if (major_mode == ro_mode_name)
+            151  |        return 1;
     124     152  |    if (!*filename)
     125     153  |        return write_file();
     126     154  |    strcpy(backupname, filename);
     127     155  |    strcpy(get_extension(backupname), ".bak");
     128     156  |    if (want_backups && strcmp(filename, backupname)) {
===================
     299     327  |        make_mode();
     300     328  |    }
     301     329  |    read_file(fname, strip_returns);
     302     330  |    s = get_extension(fname);
     303     331  |    sprintf(mode, "suffix-%s", *s ? (s + 1) : "none");
+            332  |    if (major_mode != ro_mode_name)
+            333  |        if (!try_calling(mode))
+            334  |            try_calling("suffix-default");
-    304          |    if (!try_calling(mode))
-    305          |        try_calling("suffix-default");
     306     335  |}
     307     336  |
     308     337  |command count_lines() on cx_tab['l']
     309     338  |{
     310     339  |    int count = 0, here = 0, start = point;
===================
#endif