home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast.iso / eel / storemod.zip / STORE.E
Text File  |  1990-09-19  |  6KB  |  279 lines
  1. /************************************************************************
  2. * "Epsilon", "EEL" and "Lugaru" are trademarks of Lugaru Software, Ltd. *
  3. *                                    *
  4. *  Copyright (C) 1985, 1990 Lugaru Software Ltd.  All rights reserved.    *
  5. *                                    *
  6. * Limited permission is hereby granted to reproduce and modify this    *
  7. * copyrighted material provided that the resulting code is used only in    *
  8. * conjunction with Lugaru products and that this notice is retained in    *
  9. * any such reproduction or modification.                *
  10. ************************************************************************/
  11.  
  12. /*
  13. * The modifications marked KSH below allow the following forms to be 
  14. * placed in files suitable for M-x load-file.  Enjoy, Shane Hartman.
  15. * 
  16. * (set-variable "beep-duration" 19)
  17. * (load-bytes "shane")
  18. *
  19. */
  20.  
  21. #include "eel.h"
  22.  
  23. jmp_buf jbuf;
  24.  
  25. do_load_file(fname)    /* load command file */
  26. char *fname;
  27. {
  28. int err;
  29. char *old = bufname, *temp_load;
  30.  
  31. temp_load = temp_buf();
  32. bufname = temp_load;
  33. filename = fname;
  34. if (err = do_file_read(fname, strip_returns.default)) {
  35.     file_error(err, fname, "read error");
  36.     maybe_ding(bell_on_read_error);
  37. } else if (parse_cmds()) {
  38.     bufname = old;
  39.     to_buffer(temp_load);        /* show bad commands in window */
  40.     quick_abort();
  41. }
  42. bufname = old;
  43. delete_buffer(temp_load);
  44. }
  45.  
  46. load_buffer_command()
  47. {
  48. char bname[80], *old = bufname;
  49. int err;
  50.  
  51. get_buf(bname, "Load definitions from buffer", bufname);
  52. if (exist(bname))
  53.     bufname = bname;
  54. else
  55.     error("No such buffer");
  56. err = parse_cmds();
  57. bufname = old;
  58. if (err) to_buffer(bname);        /* show offending command */
  59. }
  60.  
  61. parse_cmds()    /* load cmds in current buf, return 1 if error occured */
  62. {
  63. int c;
  64. char funcname[80];
  65.  
  66. point = 0;
  67. if (setjmp(&jbuf))            /* errors come here */
  68.     return 1;
  69. for (;;) {
  70.     re_search(1, "[ \n\t]*");        /* skip whitespace */
  71.     if (point == size())
  72.         return 0;
  73.     if (curchar() == ';') {            /* found comment */
  74.         nl_forward();
  75.         continue;
  76.     }
  77.     must_char('(');
  78.     re_search(1, "[ \t\n]*");
  79.     parse_string(1, "[^ \t\n]*", funcname);
  80.     if (!strcmp(funcname,"define-macro"))
  81.         cf_macro();
  82.     else if (!strcmp(funcname, "bind-to-key"))
  83.         cf_bind();
  84.     else if (!strcmp(funcname, "create-prefix-command"))
  85.         cf_prefix();
  86.     else if (!(strcmp(funcname, "load-bytes")))    /* KSH */
  87.         cf_load();                /* KSH */
  88.     else if (!(strcmp(funcname, "set-variable")))    /* KSH */
  89.         cf_set();                /* KSH */
  90.     else
  91.         init_error("bad function");
  92.     re_search(1, "[ \t\n]*");
  93.     must_char(')');
  94. }
  95. }
  96.  
  97. short *keyseq;        /* sequence of key codes, in format used by macros */
  98.  
  99. cf_macro()        /* handle define-macro */
  100. {
  101. char name[80];
  102.  
  103. get_str(name);
  104. get_keyseq();
  105. name_macro(name, keyseq);
  106. }
  107.  
  108. cf_bind()        /* handle bind-to-key */
  109. {
  110. int index;
  111. char name[80];
  112.  
  113. get_str(name);
  114. index = find_index(name);
  115. if (index)
  116.     put_on_key(index);
  117. else
  118.     init_error("no such command");
  119. }
  120.  
  121. cf_prefix()        /* handle create-prefix-command */
  122. {
  123.     put_on_key(make_anon_keytable());
  124. }
  125.  
  126. put_on_key(index)        /* parse key seq and bind it to index */
  127. {
  128. short *curtab;
  129. int c, i = 1;
  130.  
  131. get_keyseq();
  132. curtab = root_keys;
  133. for (;;) {
  134.     c = keyseq[i];
  135.     if (++i >= keyseq[0]) break;
  136.     if (name_type(curtab[c]) != NT_TABLE)
  137.         init_error("expected \"");
  138.     curtab = index_table(curtab[c]);
  139. }
  140. curtab[c] = index;
  141. }
  142.  
  143. get_keyseq()            /* parse key names, put keys in keyseq */
  144. {
  145. re_search(1, "[ \t\n]*");
  146. keyseq = get_keycode();
  147. if (!keyseq)
  148.     init_error("bad character");
  149. }
  150.  
  151. /* KSH */
  152. get_int(into)
  153. char *into;
  154. {
  155.     re_search(1, "[ \t\n]*");
  156.     if (!isdigit (character (point)))
  157.         error ("Not a number");
  158.     parse_string(1, "[012345679]*", into);
  159.     re_search(1, "[ \t\n]*");
  160. }
  161.  
  162. get_str(s)        /* get a quoted string, and put it in s */
  163. char *s;
  164. {
  165. re_search(1, "[ \t\n]*");
  166. must_char('"');
  167. parse_string(1, "[^\"]*", s);
  168. must_char('"');
  169. }
  170.  
  171. must_char(c)    /* move past current character, making sure that it's c */
  172. {
  173. char msg[80];
  174.  
  175. if (curchar() != c) {
  176.     sprintf(msg, "expected %c", c);
  177.     init_error(msg);
  178. } else
  179.     point++;
  180. }
  181.  
  182. have_char(c)    /* if this character is c, move past and return 1, else 0 */
  183. {
  184. int res = (curchar() == c);
  185.  
  186. if (res) point++;
  187. return res;
  188. }
  189.  
  190. init_error(s)        /* display error and abort loading */
  191. char *s;
  192. {
  193. say("%s", s);
  194. longjmp(&jbuf, 1);
  195. }
  196.  
  197. insert_macro_command()        /* insert command-file definition of macro */
  198. {
  199.     char name[80];
  200.     int i;
  201.  
  202.     get_macname(name, "Insert macro", "last-kbd-macro");
  203.     i = find_index(name);
  204.     if (i && name_type(i) == NT_MACRO) {
  205.         bprintf("(define-macro \"%s\" ", name);
  206.         stuff_macro(get_macro(i));
  207.         stuff(")\n");
  208.     } else
  209.         error("Not a macro");
  210. }
  211.  
  212. stuff_macro(m)        /* insert cmd-file format macro text in buffer */
  213. short *m;
  214. {
  215.     char tmp[20];
  216.     int i;
  217.  
  218.     stuff("\"");
  219.     for (i = 1; i < m[0]; i++)
  220.         switch (m[i]) {
  221.             case '\n':    insert('\n'); break;
  222.             case 'A':    /* "F-1" in text */
  223.             case 'C':    /* resembles special key */
  224.             case 'S':
  225.             case 'F':
  226.             case 'N':    if (i + 1 < m[0] && m[i + 1] == '-') {
  227.                         insert('\\');    /* quote it */
  228.                         insert(m[i]);
  229.                         break;
  230.                     }        /* fall through */
  231.             default:    tmp[0] = 0;
  232.                     show_char(tmp, m[i]);
  233.                     stuff(tmp);
  234.                     break;
  235.             case ALT('<'):
  236.             case ALT('"'):
  237.             case ALT('\\'):    stuff("A-");    /* fall through */
  238.             case '<':        /* quote these */
  239.             case '"':
  240.             case '\\':    insert('\\');
  241.                     insert(m[i] & 0x7f);
  242.                     break;
  243.         }
  244.     stuff("\"");
  245. }
  246.  
  247. /* KSH */
  248. cf_set()    /* handle set-variable */
  249. {
  250.     int index;
  251.     int type;
  252.     char name[80];
  253.     char arg[256];
  254.  
  255.     get_str(name);
  256.     re_search(1, "[ \n\t]*");               /* skip whitespace */
  257.     if (character(point) == '"')
  258.         get_str(arg);
  259.     else
  260.         get_int(arg);
  261.     index = find_index(name);
  262.     type = name_type(index);
  263.     if (type != NT_VAR && type != NT_BUFVAR && type != NT_WINVAR)
  264.         error("%s: not a variable", name);
  265.     set_var_val(index, arg, 1);
  266.     set_var_val(index, arg, 0);  
  267. }
  268.  
  269. /* KSH */
  270. cf_load()   /* handle load-bytes */
  271. {
  272.     char fname[80];
  273.  
  274.     get_str(fname);
  275.     strcpy(get_extension(fname), byte_extension);
  276.     say("Loading %s", fname);
  277.     load_commands(fname);
  278. }
  279.