home *** CD-ROM | disk | FTP | other *** search
/ Mega CD-ROM 1 / megacd_rom_1.zip / megacd_rom_1 / FREEMACS / EMACS16A.ZIP / MINTREF.ELI < prev    next >
Text File  |  1990-02-22  |  47KB  |  1,029 lines
  1. This file documents MINT primitives.  -*-Text-*-
  2. 
  3. File: mintref    Node: Top    Up: (DIR)    Next: Expert
  4.         The Reference Guide to Emacs Functions
  5.  
  6.  
  7. MINT:
  8.  
  9.     The input to the MINT processor consists of strings of characters.
  10. Certain combinations of strings, namely #(...) and ##(...), invoke functions.
  11. The body of the function is separated by commas into arguments (no commas
  12. means one argument) that are evaluated from left to right.  The first argument
  13. is assumed to be the name of a function, and the value is computed by
  14. supplying the arguments to the function.  If the function was the single sharp
  15. #(...) form, the value is rescanned; otherwise the value is passed over
  16. without rescanning.  The form (...), where the interior string contains
  17. balanced parentheses, protects the interior string from evaluation.  The
  18. processor simply strips the outer parentheses and passes by the interior.
  19. If '**' is the multiply function and '++' the addition function, then the input
  20. string
  21.  
  22.         ((3+4))*9 = #(**,#(++,3,4),9)'
  23.  
  24. will evaluate to
  25.  
  26.         (3+4)*9 = 63
  27.  
  28. Note that 3+4 is to be surrounded by parentheses.  To prevent them from 
  29. being interpreted as protection parentheses, they must themselves be 
  30. surrounded by a pair of protection parentheses.
  31.  
  32.     Interior to the processor are three structures: the active
  33. string, the neutral string, and the scan pointer.  A convenient
  34. visualization is to think of the neutral string on the left, the scan
  35. pointer in the middle, and the active string on the right.  The scan
  36. pointer always points at the left of the active string, looking at the
  37. first character.  Normally characters move from the active to neutral
  38. string, where they are accumulated until there are enough to form all the
  39. arguments of some function.  Then the function is evaluated and the
  40. result put back in the active or neutral string according to the function
  41. type.
  42.  
  43.      The MINT functions are listed here in their active forms, but
  44. each can be called in neutral mode as well.  The value of a function is
  45. always a string; any function, particularly those whose most important
  46. activity is a side effect, might return the null string.  In addition to
  47. the structures already mentioned, the processor can store strings in an
  48. area called string storage.  Each string has three parts: a string name,
  49. which may be any string whatsoever; a string body, which may also be any
  50. string; and a string pointer, which initially points just in front of the
  51. first character of the string body.  The string pointer always points
  52. just before the body, just after it, or between two characters; that is,
  53. it always points into a gap between characters.  Form bodies may include
  54. ordinal parameter markers intermixed with their characters.  Each such
  55. marker has some positive integer associated with it, and these integers
  56. need not be distinct.
  57. 
  58. File: mintref    Node: Scan    Up: Top    Next: Expert
  59.  
  60. The scanning algorithm:
  61.  
  62.     The algorithm consists of 10 numbered steps.  When the processor is
  63. executed, it begins by going to step 1.  Throughout the algorithm there are
  64. mentions of marking the neutral string in various ways.  Think of these
  65. markers as flags attached to the affected characters (of course, the markers
  66. are accompanied by pointers, pointing backwards though the neutral string).
  67.  
  68.     1. Clear the processor by emptying the neutral string, deleting the
  69.     contents of the active string, if any, filling the active string with
  70.     the string #(d,#(g)), and setting the scan pointer to the first
  71.     character of the active string.  Perform a redisplay of the current
  72.     text buffer if there are no characters in the input buffer.
  73.  
  74.     2. Examine the character under the scan pointer.  If there is none -
  75.     that is, if the active string is the null string - return to step 1.
  76.     Note that the neutral string may still contain characters.
  77.  
  78.     3. If the character under the scan pointer is a horizontal tab,
  79.     carriage return, or line feed, delete it, advance the scan pointer,
  80.     and return to step 2.
  81.  
  82.     4. If the character under the scan pointer is a left parenthesis,
  83.     delete it and scan forward until the matching right parenthesis is
  84.     found. After all of the intervening characters have been moved without
  85.     change to the neutral string, the right parenthesis deleted, and the
  86.     scan pointer moved to the character following the right parenthesis,
  87.     return to step 2.  If the matching right parenthesis cannot be found,
  88.     go back to step 1 without giving an error.
  89.  
  90.     5. If the character under the scan pointer is a comma, delete it, mark
  91.     the rightmost character of the neutral string as the end of one
  92.     argument, advance the scan pointer, and return to step 2.
  93.  
  94.     6. If the character under the scan pointer is a sharp sign and the
  95.     next character is a left parenthesis, an active function
  96.     is beginning.  Delete the sharp sign and the left parenthesis, advance
  97.     the scan pointer beyond them, mark the rightmost character of the 
  98.     neutral string as the beginning of both an argument and an active
  99.     function, and return to step 2.
  100.  
  101.     7. If the character under the scan pointer is a sharp sign and the
  102.     next two characters are another sharp sign and a left
  103.     parenthesis, a neutral function is beginning.  Delete the triple ##(,
  104.     advance the scan pointer beyond them, mark the rightmost character of
  105.     the neutral string as the beginning of both an argument and a neutral
  106.     function, and return to step 2.
  107.  
  108.     8. If the character under the scan pointer is a sharp sign that did
  109.     not meet the conditions of step 6 or 7, move it to the right end of
  110.     the neutral string, advance the scan pointer, and return to step 2.
  111.  
  112.     9. If the character under the scan pointer is a right parenthesis, a
  113.     function is ending.  Delete the right parenthesis, advance the scan
  114.     pointer, and mark the rightmost character of the neutral string as the
  115.     end of an argument and the end of a function.  Now the neutral string
  116.     from the rightmost begin function marker to the just inserted end
  117.     function marker constitutes a MINT function invocation.  (If there is
  118.     no begin function marker in the neutral string, return to step 1
  119.     without giving an error.)  The first argument is assumed to be the
  120.     name of a MINT function.  If the argument is two characters long, and
  121.     is the name of a built-in function, that function is evaluated with
  122.     the given arguments: extra arguments are ignored and missing ones are
  123.     automatically supplied as the null string.  If the function is not
  124.     built-in, a default built-in function is executed.  The result
  125.     of the function is catenated to the right of the neutral string if the
  126.     function was marked as neutral and to the left of the active string if
  127.     marked active; in the latter case, the scan pointer is reset to the
  128.     leftmost character of the new active string.  Check the head of the
  129.     keyboard buffer.  If the key is the break key for your system (Z-100
  130.     uses Shift-Help, IBM-PC uses Ctrl-Break) then input that key and go
  131.     to step one, otherwise return to step 2.
  132.  
  133.     10. If the character under the scan pointer did not meet any of the
  134.     conditions of steps 3 through 9, attach it to the right of the neutral
  135.     string, delete it from the active string, advance the scan pointer,
  136.     and return to step 2.
  137. 
  138. File: mintref    Node: Expert    Up: Top
  139. * Menu:
  140.  
  141. * ds::        #(ds,N,B) "Define String"
  142. * mp::        #(mp,N,P1,P2,...) "Make Parameter"
  143. * N::        #(N,A1,A2,...) "Default"
  144. * gs::        #(gs,N,A1,A2,...) "Get String"
  145. * go::        #(go,N,Z) "Get One (character)"
  146. * gn::        #(gn,N,D,Z) "Get N (characters)"
  147. * fm::        #(fm,N,X,Z) "First Match"
  148. * rs::        #(rs,N) "Restore String"
  149. * es::        #(es,N1,N2,...) "Erase String"
  150. * si::        #(si,N,C) "String Index"
  151. * ++::        #(++,A,B) "Add"
  152. * --::        #(--,A,B) "Subtract"
  153. * **::        #(**,A,B) "Multiply"
  154. * //::        #(//,A,B) "Divide"
  155. * %%::        #(%%,A,B) "Modulo"
  156. * ||::        #(||,A,B) "Or"
  157. * &&::        #(&&,A,B) "And"
  158. * ^^::        #(^^,A,B) "Xor"
  159. * g?::        #(g?,A,B,T,F) "Greater"
  160. * ==::        #(==,A,B,T,F) "Equality"
  161. * ll::        #(ll,A) "Load Library"
  162. * sl::        #(sl,A,F1,F2,...) "Save Library"
  163. * ls::        #(ls,S,P) "List Strings"
  164. * rd::        #(rd,F) "Redisplay"
  165. * ba::        #(ba,N) "Buffer Allocate"
  166. * bi::        #(bi,N,M,E) "Buffer Insert"
  167. * is::        #(is,S,E) "Insert String"
  168. * tr::        #(tr,M,S) "Translate to Mark"
  169. * an::        #(an,L,F,R) "Announce"
  170. * lv::        #(lv,F) "Load Variable"
  171. * sv::        #(sv,F,V) "Store Variable"
  172. * pp::        #(pp)   "Pick Position"
  173. * st::        #(st,S) "Syntax Table"
  174. * pm::        #(pm,S,E) "Push/Pop Mark"
  175. * sm::        #(sm,M,V) "Set Mark"
  176. * sp::        #(sp,M) "Set Point"
  177. * dm::        #(dm,M) "Delete to Mark"
  178. * rm::        #(rm,M,V) "Read Mark"
  179. * rc::        #(rc,M) "Read Count"
  180. * mb::        #(mb,M,Y,N) "Mark Before"
  181. * lp::        #(lp,S,N,R,F)   "Look Pattern"
  182. * lk::        #(lk,S,E,F,L,N) "Look"
  183. * l?::        #(l?,S,E,F,L,Y,N) "Look&Test"
  184. * rf::        #(rf,N) "Read File"
  185. * wf::        #(wf,N,M) "Write File"
  186. * ff::        #(ff,N,S) "Find Files"
  187. * rn::        #(rn,O,N) "Rename file"
  188. * de::        #(de,N) "Delete File"
  189. * ev::        #(ev)   "Environment"
  190. * it::        #(it,T) "Input Timed"
  191. * bc::        #(bc,V,F,T) "Base Conversion"
  192. * nc::        #(nc,A) "Number of Characters"
  193. * ct::        #(ct,F) "C Time"
  194. * n?::        #(n?,F,Y,N)     "Name exists?"
  195. * a?::        #(a?,A,B,Y,N)   "Alphabetic?"
  196. * sa::        #(sa,A,B,C,...) "Sort Ascending"
  197. * xy::        #(xy,X,Y) "X Y"
  198. * ow::        #(ow,S) "Over Write"
  199. * hl::        #(hl,N) "Halt"
  200. * db::        #(db)   "Debug"
  201. * ex::        #(ex,F,A,I,O,E) "Execute Program"
  202. * sc::        #(sc,W,F) "Spell Check"
  203. 
  204. File: mintref    Node: ds    Up: Expert    Next: mp
  205. #(ds,N,B) "Define String"
  206.     This null-valued function creates a string with name N and body B
  207. with its string pointer just before the first character of B.  If there is
  208. a string with name N already, its previous body and string pointer are lost.
  209. 
  210. File: mintref    Node: mp    Up: Expert    Next: default
  211. #(mp,N,P1,P2,...) "Make Parameter"
  212.     This null-valued function creates parameter markers in the
  213. string N.  The non-null arguments P1,P2..., are processed in turn from left
  214. to right (null arguments are ignored).  Argument Pi is processed in the
  215. following way.  The body of string N is scanned from left to right for the
  216. first substring exactly equal to Pi.  The matching substring must not
  217. contain any already-existing parameter markers.  If it does not, the
  218. substring is taken out of the string body and an ordinal parameter marker
  219. numbered i replaces it.  The matching process begins again at the
  220. character following the marker.  The string pointer is replaced at the left
  221. end of the string when the searching is finished.  A string may be
  222. searched more than once.
  223.     Parameter markers are represented by characters in the range
  224. 128..255.  Parameter marker 128 is ignored, 129 corresponds to P1, 130
  225. corresponds to P2, etc.
  226. 
  227. File: mintref    Node: default    Up: Expert    Next: gs
  228. #(N,A1,A2,...) "Default"
  229.     The value of this function is the body of the string N with its
  230. parameter markers filled in.   All those parameter markers numbered 1 are
  231. filled with argument N, those numbered 2 with A1, those numbered 3 with
  232. A2, and so on.  Remember that excess arguments are ignored and missing
  233. ones are supplied with the null string.
  234. 
  235. File: mintref    Node: gs    Up: Expert    Next: go
  236. #(gs,N,A1,A2,...) "Get String"
  237.     The value of this function is the body of the string N with its
  238. parameter markers filled in.  All those parameter markers numbered 1 are
  239. filled with argument A1, those numbered 2 with A2, and so on.  Remember
  240. that excess arguments are ignored and missing ones are supplied with the
  241. null string.
  242. 
  243. File: mintref    Node: go    Up: Expert    Next: gn
  244. #(go,N,Z) "Get One (character)"
  245.     The value of this function is the character immediately following
  246. the string pointer in the string N.  The string pointer is advanced just
  247. beyond the selected character.  If the string pointer is already at the
  248. right end of the string, the function value is argument Z returned in
  249. active mode regardless of the mode of the function call.
  250. 
  251. File: mintref    Node: gn    Up: Expert    Next: fm
  252. #(gn,N,D,Z) "Get N (characters)"
  253.     The value of this function is a substring of string N.  Starting
  254. at the string pointer and reading right the value is D characters of the
  255. string body.  (The interpretation of a string as a number will be
  256. discussed later.)  The string pointer is moved to point between the
  257. selected substring and the first unread character.  If D is zero, the
  258. value is null and the pointer does not move.  If the string pointer
  259. should move off the end of the string, the function value is argument Z
  260. returned in active mode regardless of the mode of the function call.
  261. *Note math:math
  262. 
  263. File: mintref    Node: fm    Up: Expert    Next: rs
  264. #(fm,N,X,Z) "First Match"
  265.     The string N is searched rightward from the string pointer for a
  266. substring containing no parameter markers and exactly matching argument X.
  267. If such a match is found, the value of the function is the substring of
  268. the string from the original location to the character immediately
  269. preceding the match and the string pointer is moved just before the
  270. character immediately following the matched substring.  If no match is
  271. found, the argument Z is returned in active mode regardless of the mode
  272. of the function call, and the string pointer is stationary.
  273. 
  274. File: mintref    Node: rs    Up: Expert    Next: es
  275. #(rs,N)    "Restore String"
  276.     This null-valued function restores the string pointer of string N to
  277. its initial position just before the first character of the string.
  278. 
  279. File: mintref    Node: es    Up: Expert    Next: si
  280. #(es,N1,N2,...) "Erase String"
  281.     This null-valued function erases the strings named N1, N2, ...,
  282. from string storage.
  283. 
  284. File: mintref    Node: si    Up: Expert    Next: ++
  285. #(si,N,C) "String Index"
  286.     Given a character C and string N, return the Cth character
  287. of N.  If C is empty or N doesn't exist or C is larger than the
  288. length of N, then return null.
  289. 
  290. File: mintref    Node: math    Up: Expert    Next: ++
  291.     MINT performs arithmetic on strings of decimal characters.  The
  292. arithmetic value of a string is given by the longest suffix of the
  293. string that can be described exactly as all decimal digits preceded by
  294. at most one plus or minus sign.  Thus the value of 3 is three; of a-4
  295. is negative four; of ++++200 is two hundred; and of the null string and
  296. of abc zero.  The null string acts as zero in arithmetic operations.
  297. The result of an arithmetic operation is a decimal string with no
  298. leading zeros or plus signs for positive results and with zero
  299. represented as 0.
  300. 
  301. File: mintref    Node: ++    Up: Expert    Next: --
  302. #(++,A,B) "Add"
  303.     The value of this function is the sum of the arithmetic values of
  304. arguments A and B with the nonnumeric prefix of A prefixed to the result.
  305. The prefix of B is lost.  *Note math:math
  306. 
  307. File: mintref    Node: --    Up: Expert    Next: **
  308. #(--,A,B) "Subtract"
  309.     The value of this function is the result of subtracting the
  310. arithmetic value of argument B from that of argument A.  The nonnumeric
  311. prefix of A is prefixed to the resultant decimal string, and the prefix
  312. of B is lost.  *Note math:math
  313. 
  314. File: mintref    Node: **    Up: Expert    Next: //
  315. #(**,A,B) "Multiply"
  316.     The value of this function is the result of multiplying the
  317. arithmetic value of argument B to that of argument A.  The nonnumeric
  318. prefix of A is prefixed to the resultant decimal string, and the prefix
  319. of B is lost.  *Note math:math
  320. 
  321. File: mintref    Node: //    Up: Expert    Next: %%
  322. #(//,A,B) "Divide"
  323.     The value of this function is the numeric value of argument A
  324. divided by the numeric value of argument B, and the result is prefixed
  325. with the nonnumeric prefix of A.  The prefix of B is lost.  The division
  326. operation is done in integer mode, and only the integral portion of the
  327. quotient is retained.  *Note math:math
  328. 
  329. File: mintref    Node: %%    Up: Expert    Next: g?
  330. #(%%,A,B) "Modulo"
  331.     The value of this function is the numeric value of argument A
  332. modulo the numeric value of argument B, and the result is prefixed with
  333. the nonnumeric prefix of A.  The prefix of B is lost.  The modulo
  334. operation is done in integer mode, and only the integral portion of the
  335. modulus is retained.  *Note math:math
  336. 
  337. File: mintref    Node: ||    Up: Expert    Next: &&
  338. #(||,A,B) "Or"
  339.     The value of this function is the numeric value of argument A
  340. or the numeric value of argument B, and the result is prefixed with
  341. the nonnumeric prefix of A.  The prefix of B is lost.  *Note math:math
  342. 
  343. File: mintref    Node: &&    Up: Expert    Next: ^^
  344. #(&&,A,B) "And"
  345.     The value of this function is the numeric value of argument A
  346. anded with  the numeric value of argument B, and the result is prefixed
  347. with the nonnumeric prefix of A.  The prefix of B is lost.  *Note math:math
  348. 
  349. File: mintref    Node: ^^    Up: Expert    Next: g?
  350. #(^^,A,B) "Xor"
  351.     The value of this function is the numeric value of argument A
  352. xor'ed with the numeric value of argument B, and the result is prefixed
  353. with the nonnumeric prefix of A.  The prefix of B is lost.  *Note math:math
  354. 
  355. File: mintref    Node: g?    Up: Expert    Next: ==
  356. #(g?,A,B,T,F) "Greater"
  357.     The value of is function is the argument T if the arithmetic
  358. value of argument A is greater than the arithmetic value of argument B,
  359. and is argument F otherwise.  *Note math:math
  360. 
  361. File: mintref    Node: ==    Up: Expert    Next: ll
  362. #(==,A,B,T,F) "Equality"
  363.     The value of this function is the argument T if the argument A is
  364. exactly equal, as a string, to the argument B, and is the argument F
  365. otherwise.  Notice that T and F may be any strings whatever.
  366. 
  367. File: mintref    Node: ll    Up: Expert    Next: sl
  368. #(ll,A) "Load Library"
  369.     This null-valued function retrieves all of the strings stored
  370. in the file specified by argument A.  The strings are brought back to
  371. string storage, and if some of the strings are already in string
  372. storage, their values are overwritten.
  373. 
  374. File: mintref    Node: sl    Up: Expert    Next: ls
  375. #(sl,A,F1,F2,...) "Save Library"
  376.     This null-valued function stores the strings named by arguments F1,
  377. F2, ... in the disk file specified by argument A.
  378. 
  379. File: mintref    Node: ls    Up: Expert    Next: rd
  380. #(ls,S,P) "List Strings"
  381.     The value of this function is a list of all the strings whose names
  382. have a prefix of P.  Of course, all strings have a null prefix, so if P is
  383. missing, then all strings are listed.  The string names are separated by the
  384. string S.
  385. 
  386. File: mintref    Node: text    Up: Expert    Next: 
  387.     In addition to the active string, neutral string, and
  388. named string storage, Emacs has a text buffer.  This buffer is capable of
  389. holding any string of characters.  Characters in the range zero through 127
  390. may be viewed directly, while characters in the range 128 through 255 are viewed
  391. as the inverse video representation of the character that is 128 lower in
  392. value. The two character combination Carriage Return followed by Line Feed is
  393. considered a newline character, distinct from all other characters.  Emacs
  394. considers the two characters to be indivisible.  Any operation performed on
  395. one is performed on the other.  Usually a newline character may be considered as
  396. one character, except that #(rm,>) will return a newline as two characters.
  397.     The text buffer is most often accessed at a particular position
  398. called the point.  The point is the place at which all insertions and
  399. deletions take place.  The cursor on the screen is placed at the point.
  400.     A mark is another position in the file, used to delimit block
  401. operations, and can be used to set the point.
  402.     A mark is specified by a ASCII character.  Emacs defines certain
  403. marks, called system marks, to have a special value.  The meanings of all the
  404. valid marks are given in a table below.  Any mark, system or user, may be used
  405. when a mark is called for.
  406.     All the user marks are initially set to the beginning of the
  407. file.  Once a mark is set, the mark "sticks" to the character at the
  408. right of the mark, or eof if that's the case.  Therefore, the user marks
  409. migrate to the end of the file.
  410.     The global user marks are always available for use.  The number
  411. of global marks is controlled by the value of a negative argument to the
  412. primitive 'pm'.  For example, '#(pm,-3)' creates three global marks - @, A,
  413. and B.  Creating global marks destroys all local marks.
  414.     The local user marks are arranged as a stack.  The primitive 'pm'
  415. is used to push and pop marks.  If you wish to use two local marks, then
  416. you would execute '#(pm,2)'.  This creates two new marks, 0 and 1, which both
  417. have the value of the current point.  When you are finished using the marks,
  418. you would execute '#(pm)'.  You may use at most ten local user marks at
  419. once.
  420.  
  421.     Mark Character    Meaning
  422.     ___________    _______
  423.     @ through Z    Global user marks
  424.     0 through 9    Local user marks.
  425.     <        The character to the left of the point.
  426.     >        The character to the right of the point.
  427.     {        The first blank character to the left of the point.
  428.     }        The first blank character to the right of the point.
  429.     -        The first non-blank character to the left of the point.
  430.     +        The first non-blank character to the right of the point.
  431.     [        The beginning of the file.
  432.     ]        The end of the file.
  433.     ^        The beginning of this line.
  434.     $        The end of this line.
  435.     .        The point.
  436. 
  437. File: mintref    Node: rd    Up: Expert    Next: ba
  438. #(rd,F) "Redisplay"
  439.     This null-valued function causes the screen to match the text in
  440. the text buffer.  The lines on the screen which do not match the lines in
  441. the text are redrawn.  If the argument F is not null, the screen is
  442. completely redrawn.  If the input buffer is not empty, that is, if a key
  443. is waiting to be executed, redisplay is not performed.  This prevents the
  444. input buffer from overflowing.
  445. 
  446. File: mintref    Node: ba    Up: Expert    Next: bi
  447. #(ba,N) "Buffer Allocate"
  448.     This function will create and select a new buffer if N is zero.
  449. The result is the new buffer's number or zero if there is not enough
  450. memory for a new buffer.  If N is positive, then the buffer numbered N
  451. is selected.  The result is zero if there is no buffer numbered N.  If
  452. N is negative, the result is the number of the currently selected
  453. buffer, which remains selected.
  454. 
  455. File: mintref    Node: bi    Up: Expert    Next: is
  456. #(bi,N,M,E) "Buffer Insert"
  457.     This function will insert into the current buffer all the text in
  458. buffer N between buffer N's point and buffer N's mark 'M'.  If the buffer
  459. cannot hold the entire string, the string is not inserted; instead, the
  460. argument E is returned active.
  461. 
  462. File: mintref    Node: is    Up: Expert    Next: tr
  463. #(is,S,E) "Insert String"
  464.     This null-valued function inserts the argument S before the
  465. point.  If the buffer cannot hold the entire string, the string is not
  466. inserted; instead, the argument E is returned active.
  467. 
  468. File: mintref    Node: tr    Up: Expert    Next: an
  469. #(tr,M,S) "Translate to Mark"
  470.     This null-valued function will translate characters in the region given
  471. by M according to the table given in S.  If a character's value is larger than
  472. the size of S, then it goes untranslated.  Newlines always go untranslated.
  473. 
  474. File: mintref    Node: an    Up: Expert    Next: lv
  475. #(an,L,F,R) "Announce"
  476.     This null-valued function displays the string given in
  477. argument L on the screen followed by the string given in argument
  478. R.  If argument F is null, then the bottom line is used and the
  479. cursor is left following argument L.  If argument F is not null,
  480. then the last line of the current window is used and the cursor is
  481. not positioned after the string.
  482.  
  483. Guidelines for announcing things with #(an):
  484.     If the string ends in ..., you are expected to wait for the operation
  485.       to complete.
  486.     If the string ends in ?, you are expected to type a single character.
  487.       If a choice is not given, then you must type 'y' or 'n'.
  488.     If the string ends in !, an error has occurred.
  489.     If the string ends in :, you are expected to type a string terminated
  490.       by return.
  491.     If the string doesn't end in one of the above, it's an advisory message,
  492.       and is ignorable.
  493. 
  494. File: mintref    Node: variables    Up: Expert    Next: marks
  495.  
  496. * Menu:
  497.  
  498. * as:as-var (Auto Save)        Auto save counter (0..65535)
  499. * bc:bc-var (Background Color)    Background color (0..7), initially 0
  500. * bl:bl-var (Bottom Line)    bottom line of current window (1..23)
  501. * bo:bo-var (Background Origin)    Background color (0..7), originally
  502. * bs:bs-var (Bot Scroll)    percentage of bot screen that scrolls (0..100)
  503. * cc:cc-var (Control Color)    Control Char color (0..15), initially 7
  504. * cl:cl-var (Current Line)    number of current line (1..32767)
  505. * cn:cn-var (Computer Name)    currently, either 'IBM-PC' or 'Z-100'.
  506. * cs:cs-var (Column on Screen)    column on screen (1..32767)
  507. * cw:cw-var (Current Window)    window currently in use (1..2)
  508. * fc:fc-var (Foreground Color)    Foreground color (0..15), initially 7
  509. * fo:fo-var (Foreground Origin)    Foreground color (0..15), originally
  510. * im:im-var (Inverse Mark)    Mark that is showing inverse video.
  511. * is:is-var (Inhibit Snow)    inhibit snow on CGA (0..1)
  512. * lc:lc-var (Left Column)    Left Column on screen (1..)
  513. * mb:mb-var (Modified Buffer)    flag, zero if buffer not modified (0..2)
  514. * nl:nl-var (Number of Lines)    number of lines (1..32767) 
  515. * ow:ow-var (Other Window)    buffer being displayed in "other" window (0..)
  516. * pb:pb-var (Percentage Before)    Percentage of text buffer before point. (0..100)
  517. * rs:rs-var (Row on Screen)    row on screen (-32768..32767)
  518. * tc:tc-var (Tab Columns)    number of columns per tab (2,4,8,16)
  519. * tl:tl-var (Top Line)        top line of current window (1..23)
  520. * ts:ts-var (Top Scroll)    percentage of top screen that scrolls (0..100)
  521. * vn:vn-var (Version Number)    current version number.
  522. * wc:wc-var (Whitespace Color)    Whitespace Char color (0..15), initially 7
  523. * wp:wp-var (Window Percent)    percent of screen allocated to the top window
  524. * ws:ws-var (Whitespace Showing)redisplay shows whitespace (0..1)
  525. 
  526. File: mintref    Node: lv    Up: Expert    Next: sv
  527. #(lv,F)    "Load Variable"
  528.     This function returns a value which is dependent upon the value of
  529. the argument F.  *Note variables:variables.
  530. 
  531. File: mintref    Node: sv    Up: Expert    Next: pp
  532. #(sv,F,V) "Store Variable"
  533.     This function sets a value which is dependent upon the value of
  534. the argument F.  A table of the various values set versus argument F
  535. follows:  *Note variables:variables.
  536.  
  537.      F            Value set
  538.      --------------------    --------------
  539.      as (Auto Save)        Auto save counter (0..65535)
  540.      bc (Background Color)    Background color (0..7) initially 0
  541.      bl (Bottom Line)    bottom line of current window (1..23)
  542.      bs (Bot Scroll)    percentage of bot screen that scrolls (0..100)
  543.      cl (Current Line)    number of current line (1..32767)
  544.      cs (Column on Screen)    the point is moved to column on screen (1..32767)
  545.      cw (Current Window)    window currently in use (1..2)
  546.      fc (Foreground Color)    Foreground color (0..15) initially 7
  547.      im (Inverse Mark)    Mark to inverse video to.
  548.      is (Inhibit Snow)    inhibit snow on CGA (0..1)
  549.      lc (Left Column)    Left Column on screen (1..)
  550.      mb (Modified Buffer)    flag, zero if buffer not modified (0..2)
  551.      ow (Other Window)    buffer being displayed in "other" window (0..)
  552.      rs (Row on Screen)    moves the cursor to the    Vth row on screen (1..)
  553.      tc (Tab Columns)    number of columns per tab (2,4,8,16)
  554.      tl (Top Line)        top line of current window (1..23)
  555.      ts (Top Scroll)    percentage of top screen that scrolls (0..100)
  556.      wp (Window Percent)    percent of screen allocated to the top window
  557.      ws (Whitespace Showing)redisplay shows whitespace (0..1)
  558.      none of the above    number of current line (1..32767)
  559. 
  560. File: mintref    Node: im-var    Up: Expert    Next: sv
  561. im (Inverse Mark)
  562.     If 'im' is set to anything other than '.', then redisplay will cause
  563. the text between the supplied mark and point to be displayed in inverse
  564. video.  This is kind of buggy in that switching to a different buffer will
  565. cause text in THAT buffer to be inverse between the supplied mark and point
  566. in THAT buffer.  Also goes funky with two windows.
  567.  
  568. 
  569. File: mintref    Node: bc-var    Up: Expert    Next: sv
  570. bc (Background Color)    Background color (0..7), initially 0
  571.     Text will be displayed with this background color.
  572. 
  573. File: mintref    Node: fc-var    Up: Expert    Next: sv
  574. fc (Foreground Color)    Foreground color (0..15), initially 7
  575.     Text will be displayed with this foreground color.
  576. 
  577. File: mintref    Node: cc-var    Up: Expert    Next: sv
  578. cc (Control Color)    Control color (0..15), initially 7
  579.     Control characters will be displayed with this foreground color.
  580. 
  581. File: mintref    Node: wc-var    Up: Expert    Next: sv
  582. wc (Whitespace Color)    Whitespace color (0..15), initially 7
  583.     Visible whitespace will be displayed with this foreground color.
  584. 
  585. File: mintref    Node: bo-var    Up: Expert    Next: sv
  586. bo (Background Origin)    Background color (0..7), background color on entry.
  587.     These are derived from the attribute of the character at the
  588. cursor position.  Sampled when you first enter Freemacs and after
  589. #(ex).  In other words, when you suspend then re-enter Freemacs,
  590. these colors are sampled again.  Cannot be set.
  591. 
  592. File: mintref    Node: fo-var    Up: Expert    Next: sv
  593. fo (Foreground Origin)    Foreground color (0..15), foreground color on entry.
  594.     These are derived from the attribute of the character at the
  595. cursor position.  Sampled when you first enter Freemacs and after
  596. #(ex).  In other words, when you suspend then re-enter Freemacs,
  597. these colors are sampled again.  Cannot be set.
  598. 
  599. File: mintref    Node: vn-var    Up: Expert    Next: sv
  600. vn (Version Number)    current version number.
  601.     If loaded, 'vn' will return the current version number.  Cannot be set.
  602. 
  603. File: mintref    Node: cn-var    Up: Expert    Next: sv
  604. cn (Computer Name)    current    machine, either 'IBM-PC' or 'Z-100'.
  605.     If loaded, 'cn' will return the name of the computer that Freemacs
  606. is running on.  Cannot be set.
  607. 
  608. File: mintref    Node: pb-var    Up: Expert    Next: sv
  609. pb (Percentage Before)    Percentage of text buffer before point. (0..100)
  610.     If loaded, 'pb' will return the percentage of the text buffer that is
  611. before the point.  Cannot be set.
  612. 
  613. File: mintref    Node: wp-var    Up: Expert    Next: sv
  614. wp (Window Percent)    percent of screen allocated to the top window
  615.     ???
  616. 
  617. File: mintref    Node: ow-var    Up: Expert    Next: sv
  618. ow (Other Window)    buffer being displayed in "other" window (0..)
  619.     When set to a number other than zero, then that buffer will be
  620. displayed in the other window.  If you load this variable, then it is the
  621. number of the buffer being displayed in the other window, or 0 if there is
  622. only one window.
  623. 
  624. File: mintref    Node: cw-var    Up: Expert    Next: sv
  625. cw (Current Window)    window currently in use (1..2)
  626.     When set, 'cw' will determine which window the next redisplay will use.
  627. When loaded, 'cw' will return the number of the window being used for
  628. redisplay.  If #(lv,ow) is zero, then #(lv,cw) will always be 1.
  629. 
  630. File: mintref    Node: nl-var    Up: Expert    Next: sv
  631. nl (Number of Lines)    number of lines (1..32767)
  632.     Total number of text lines in the buffer.  Cannot be set, only loaded.
  633. 
  634. File: mintref    Node: rs-var    Up: Expert    Next: sv
  635. rs (Row on Screen)    row on screen (-32768..32767)
  636.     When set, 'rs' will determine the row on the screen that the
  637. point is on.  When loaded, will return the row on the screen that the
  638. point is on.  If #(lv,tl) <= #(lv,rs) <= #(lv,bl) then the point is on the
  639. screen.  Otherwise, the point is below or above the screen respectively.
  640. After a redisplay, the point will always be on the screen.
  641. 
  642. File: mintref    Node: cs-var    Up: Expert    Next: sv
  643. cs (Column on Screen)    column on screen (1..65535)
  644.     If loaded, will return the column on the screen of point,
  645. regardless of when the last redisplay was done.  If set, the point will
  646. positioned to that column, interpreting tab characters.  If the line is
  647. not that long, the point will be at the end of the line.
  648. 
  649. File: mintref    Node: tc-var    Up: Expert    Next: sv
  650. tc (Tab Columns)    number of columns per tab (2,4,8,16)
  651.     Each tab character advances the cursor to the next tab stop.  Each tab stop
  652. is #(lv,tc) characters apart.
  653. 
  654. File: mintref    Node: tl-var    Up: Expert    Next: sv
  655. tl (Top Line)        top line of current window (1..)
  656.     If loaded, will return the position of the current window on the screen.
  657. Can only set the bottom line of the top window, or the top line of the bottom
  658. window.  Any other attempt to set will be ignored.  #(sv,tl,#(lv,tl)) and
  659. #(sv,bl,#(lv,bl)) are no-ops.
  660. 
  661. File: mintref    Node: bl-var    Up: Expert    Next: sv
  662. bl (Bottom Line)    bottom line of current window (1..)
  663.     If loaded, will return the position of the current window on the screen.
  664. Can only set the bottom line of the top window, or the top line of the bottom
  665. window.  Any other attempt to set will be ignored.  #(sv,tl,#(lv,tl)) and
  666. #(sv,bl,#(lv,bl)) are no-ops.
  667. 
  668. File: mintref    Node: lc-var    Up: Expert    Next: sv
  669. lc (Left Column)    Left Column on screen (1..)
  670.     If set, 'lc' will set the column shown in the left hand edge of
  671. the screen.  This will have no effect if it would result in the point not being
  672. shown on the screen.  In other words, redisplay will change 'lc' if needed.
  673. 
  674. File: mintref    Node: rc-var    Up: Expert    Next: sv
  675. rc (Rightmost Column)    Rightmost Column on screen (1..)
  676.     Total number of columns on the screen.  Cannot be set, only loaded.
  677. 
  678. File: mintref    Node: mb-var    Up: Expert    Next: sv
  679. mb (Modified Buffer)    flag, zero if buffer not modified (0..1)
  680.     Can be loaded or set.  Whenever the buffer is changed by #(dm), #(rf),
  681. #(is), #(tr), or #(bi), the flag is set to 1.  If the flag is set
  682. to 2, then the buffer is read-only and cannot be modified.
  683. 
  684. File: mintref    Node: ts-var    Up: Expert    Next: sv
  685. ts (Top Scroll)    percentage of top screen that scrolls (0..100)
  686.     If possible, this percentage of the screen will be shown above or below
  687. the point.
  688. 
  689. File: mintref    Node: bs-var    Up: Expert    Next: sv
  690. bs (Bot Scroll)    percentage of bot screen that scrolls (0..100)
  691.     If possible, this percentage of the screen will be shown above or below
  692. the point.
  693. 
  694. File: mintref    Node: ws-var    Up: Expert    Next: sv
  695. ws (Whitespace Showing)    redisplay shows whitespace (0..1)
  696.     If 'ws' is set, then the Freemacs redisplay algorithm will show
  697. trailing whitespace using bullet (space) or diamond (tab) characters.
  698. 
  699. File: mintref    Node: is-var    Up: Expert    Next: sv
  700. is (Inhibit Snow)    inhibit snow on CGA (0..1)
  701.     Some CGA cards, most notably IBMs, will produce video interference if
  702. this flag is set to a zero.
  703. 
  704. File: mintref    Node: as-var    Up: Expert    Next: sv
  705. as (Auto Save)        Auto save counter (0..65535)
  706.     If set to a non-zero value, Freemacs will execute #(Fauto-save) after
  707. that many characters have been typed.  If set to a zero value, then Freemacs
  708. will never execute #(Fauto-save) automatically.
  709. 
  710. File: mintref    Node: cl-var    Up: Expert    Next: sv
  711. cl (Current Line)    number of current line (1..32767)
  712.     If set, the point is positioned to that line in the text buffer.  If
  713. loaded, the line number that point is on will be returned.
  714. 
  715. File: mintref    Node: pp    Up: Expert    Next: st
  716. #(pp)    "Pick Position"
  717.     This function returns a value corresponding to the position specified
  718. by the pick device.  The value consists of two numbers separated by a comma.
  719. The first number is the column being picked, and the second number is the row
  720. being picked.
  721. 
  722. File: mintref    Node: st    Up: Expert    Next: pm
  723. #(st,S)    "Syntax Table"
  724.     This null-valued function sets the string to be used as the syntax
  725. table.  The syntax table is used to determine the syntax of a particular
  726. character.  The first character in the string gives the syntax for the null
  727. character.  The 32nd character in the string gives the syntax for the space
  728. character, etc.  If the string is less than 256 characters in length, those
  729. characters that fall off the right end have random syntax.  If argument S
  730. is null, the string previously selected as the syntax table is deleted, or
  731. no string is selected as the syntax table, the syntax reverts to the
  732. default syntax: 0-9, A-Z, and a-z are the only non-blank characters.
  733. The newline character is neither blank nor non-blank.
  734.     The characters are interpreted as bit fields.  The
  735. following bits have the given meaning:
  736.  
  737.     bit    meaning
  738.     ---    -------
  739.     0    =0 if blank, =1 if non-blank.
  740.     7-1    not used.
  741. 
  742. File: mintref    Node: pm    Up: Expert    Next: sm
  743. #(pm,S,E) "Push/Pop Mark"
  744.     This null-valued function allocates marks.  If the numeric
  745. argument S is positive and not zero, that number of local marks are
  746. allocated and initialized to '.'.  If the numeric argument S is negative,
  747. that number of permanent marks are allocated and all local marks are
  748. destroyed.  If the numeric argument S is zero, the current local marks are
  749. deallocated, and the previous local marks become available again.  If
  750. stack overflow or underflow occurs, the argument E is returned active.
  751. 
  752. File: mintref    Node: sm    Up: Expert    Next: sp
  753. #(sm,M,V) "Set Mark"
  754.     This function sets the mark given by argument M to the mark given
  755. by argument V.  If V is null, the point is used.  Note that a newly created
  756. mark is initialized to '.'.
  757. 
  758. File: mintref    Node: sp    Up: Expert    Next: dm
  759. #(sp,M)    "Set Point"
  760.     This null-valued function causes the point to be set to the mark
  761. given by argument M.  Argument M may be a single mark or a sequence of
  762. marks.  #(sp,MN) is equivalent to #(sp,M)#(sp,N).
  763. 
  764. File: mintref    Node: dm    Up: Expert    Next: rm
  765. #(dm,M)    "Delete to Mark"
  766.     This null-valued function causes all text between the point and
  767. the mark given by argument M to be deleted.  Deleting large amount of text
  768. can take a long time, but #(dm,]) is optimized when the point is at the beginning of file.
  769. 
  770. File: mintref    Node: rm    Up: Expert    Next: rc
  771. #(rm,M,V) "Read Mark"
  772.     This function returns the characters between the point and the
  773. mark given by argument M.  If there is not enough string space, the
  774. argument V is returned active.
  775. 
  776. File: mintref    Node: rc    Up: Expert    Next: mb
  777. #(rc,M) "Read Count"
  778.     This function returns the number of characters between the point and the
  779. mark given by argument M.  *Note math:math
  780. 
  781. File: mintref    Node: mb    Up: Expert    Next: lp
  782. #(mb,M,Y,N) "Mark Before"
  783.     This function returns Y if the mark M is before the point, and N
  784. if the mark is after the point.
  785. 
  786. File: mintref    Node: lp    Up: Expert    Next: lk
  787. #(lp,S,N,R,F)    "Look Pattern"
  788.     This function sets the pattern to be searched for with #(lk) to S.  If
  789. R is non-null, then the pattern is may contain regular expressions.  If the
  790. regular expression is in error, then N is returned active.  If F is non-null,
  791. then case is folded, i.e. fOo matches FOO, fOO, FOo, and foo.
  792.  
  793. Regular expression characters:
  794.     \    causes the following character to have no special meaning.
  795.     ^    matches the beginning of a line.
  796.     $    matches the end of a line.
  797.     .    matches any single character.
  798.     [,;]    matches , or ; (for instance).
  799.     [a-z]    matches a-z (for instance).
  800.     [~a-z]    matches anything but a-z (for instance).
  801.     *    causes the previous character to be matched zero or more times.
  802. 
  803. File: mintref    Node: lk    Up: Expert    Next: l?
  804. #(lk,S,E,F,L,N) "Look"
  805. *** This function will removed after the next release, and only exists ***
  806. *** for compatibility's sake ***
  807.     This function searches between marks S and E for the pattern
  808. specified by #(lp).  If the pattern is found, the mark F is set to the
  809. point before the found string, and mark L is set to the point after the
  810. found string.  If S is not found, neither mark is changed, and argument N
  811. is returned active.
  812. 
  813. File: mintref    Node: l?    Up: Expert    Next: rf
  814. #(l?,S,E,F,L,Y,N) "Look&Test"
  815.     This function searches between marks S and E for the pattern
  816. specified by #(lp).  If the pattern is found, the mark F is set to the
  817. point before the found string, and mark L is set to the point after the
  818. found string, and argument Y is returned.  If S is not found, neither mark
  819. is changed, and argument N is returned.  If F is null then it is not set.
  820. If L is null then it is not set.
  821. 
  822. File: mintref    Node: rf    Up: Expert    Next: wf
  823. #(rf,N)    "Read File"
  824.     This function reads the file named in argument N into the text
  825. buffer to the left of the point.  If no error occurs, the null string is
  826. returned.  If an error occurs, an error message is returned.  The
  827. possible messages are:
  828.     File not found
  829.     File too large
  830.     End of file
  831. 
  832. File: mintref    Node: wf    Up: Expert    Next: ff
  833. #(wf,N,M) "Write File"
  834.     This function writes text to the file named in argument N.  The
  835. text to be written is located between the point and the mark given in
  836. argument M.  If no error occurs, the null string is returned.  If an
  837. error occurs, an error message is returned.  The possible messages are:
  838.     Directory Full
  839.     Disk Full
  840. 
  841. File: mintref    Node: ff    Up: Expert    Next: rn
  842. #(ff,N,S) "Find Files"
  843.     This function returns the names of all the files that match
  844. argument N.  Wildcards are allowed.  Each file name is separated by argument S.
  845. 
  846. File: mintref    Node: rn    Up: Expert    Next: de
  847. #(rn,O,N) "Rename file"
  848.     This function renames the file given in argument O to the name given in
  849. argument N.  Wildcards are not allowed.  If an error occurs, an error message
  850. is returned.  The possible messages are:
  851.     Rename error
  852. 
  853. File: mintref    Node: de    Up: Expert    Next: ev
  854. #(de,N)    "Delete File"
  855.     This function deletes the file named in argument N.  Wildcards are not
  856. allowed.  If an error occurs, an error message is returned.  The possible
  857. messages are:
  858.     File not found
  859. 
  860. File: mintref    Node: ev    Up: Expert    Next: it
  861. #(ev)    "Environment"
  862.     This function reads the MS-DOS environment.  All the environment
  863. strings are defined as strings with a prefix of "env.".  In addition, the
  864. arguments passed to emacs on the run line are defined as "env.RUNLINE".  The
  865. switch character used by MS-DOS is defined as "env.SWITCHAR".  Under DOS 3.x,
  866. the full pathname of emacs.exe is "env.FULLPATH".
  867. 
  868. File: mintref    Node: it    Up: Expert    Next: bc
  869. #(it,T)    "Input Timed"
  870.     This function waits for T hundreths of a second for a key to be
  871. pressed on the keyboard.  If T is zero, the character (if one has been
  872. pressed) is not input.  If no key is pressed, "Timeout" is returned.
  873. If a key is pressed before the timeout interval, then one of the
  874. following values is returned:
  875.  
  876.  
  877.     C-@    Control-@
  878.     C-A    Control-A
  879.     ...    The rest of the control characters are fashioned similarly.
  880.     C-_    Control-_
  881.          Space (a single space)
  882.     !    Bang
  883.     ...    The rest of the printables just return themselves
  884.     Delete
  885.  
  886. Emacs is written to be as machine independent as possible.  Therefore,
  887. your Emacs implementation may not implement all of the following keys.
  888. If the key has a shifted version, then the key name is preceded by 'S-'
  889. unless it is a standard ASCII character.  For example, C-_ is not
  890. returned as C-S--.  If your implementation has a Meta key (sometimes
  891. called Alt), then the key name from the list below (as well as those
  892. above) is preceded with 'M-'.  Note that other Emacs' define control and
  893. meta keys to be C-M-x whereas Freemacs defines control and meta keys to
  894. be M-C-x.
  895.  
  896.     BackSpace    Not the same as C-H
  897.     Tab        Not the same as C-I
  898.     Return        Not the same as C-M
  899.     Escape        Not the same as C-[
  900.     Enter        Not the same as C-M
  901.     Help
  902.  
  903.     F0,F1,F2,F3,F4,F5,F6,F7,F8,F9,F10,F11,F12    Etc.
  904.  
  905.     Ins
  906.     Del
  907.     I Chr
  908.     D Chr
  909.     Ins Line
  910.     Del Line
  911.  
  912.     Up Arrow
  913.     Down Arrow
  914.     Right Arrow
  915.     Left Arrow
  916.  
  917.     Home
  918.     End
  919.     Pg Up
  920.     Pg Dn
  921.     Break
  922.     Sys Req
  923.  
  924.     KP+,KP-,KP.    Keypad keys
  925.     KP0,KP1,KP2,KP3,KP4,KP5,KP6,KP7,KP8,KP9
  926.  
  927.     Left Down    Mouse buttons
  928.     Left Up
  929.     Right Down
  930.     Right Up
  931.     Middle Down
  932.     Middle Up
  933. 
  934. File: mintref    Node: bc    Up: Expert    Next: nc
  935. #(bc,V,F,T) "Base Conversion"
  936.     This function converts the Value given in argument V From the
  937. base given in argument F To the base given in argument T.  Several
  938. different characters are used in the From  and To arguments, and are
  939. given in the table below.  From defaults to ASCII, and To defaults to
  940. decimal.  *Note math:math
  941.       Character    Meaning
  942.        a or A    ASCII character.
  943.        d or D    decimal number.
  944.        h or H    hexadecimal number.
  945.        o or O    octal number.
  946.        b or B    binary number.
  947. 
  948. File: mintref    Node: nc    Up: Expert    Next: ct
  949. #(nc,A) "Number of Characters"
  950.     This function returns the number of characters in the argument A.
  951. *Note math:math
  952. 
  953. File: mintref    Node: ct    Up: Expert    Next: n?
  954. #(ct,F)    "C Time"
  955.     If F is empty, this function returns the current time and date
  956. in the form "Mon Nov 10 00:23:47 1988" regardless of the country
  957. setting.  If F is the name of a file, this function returns the time and
  958. date associated with the last write to the file.
  959. 
  960. File: mintref    Node: n?    Up: Expert    Next: a?
  961. #(n?,F,Y,N)    "Name exists?"
  962.     This function tests for the existance of the string F and returns Y if
  963. found and N if not found.
  964. 
  965. File: mintref    Node: a?    Up: Expert    Next: sa
  966. #(a?,A,B,Y,N)    "Alphabetic?"
  967.     This function returns Y if A is alphabetically less than B
  968. and N otherwise.
  969. 
  970. File: mintref    Node: sa    Up: Expert    Next: xy
  971. #(sa,A,B,C,...)    "Sort Ascending"
  972.     The arguments A, B, C, etc. are returned in alphabetic ascending
  973. order seperated by commas.
  974. 
  975. File: mintref    Node: xy    Up: Expert    Next: ow
  976. #(xy,X,Y) "X Y"
  977.     This function sets the screen location at which the next overwrite
  978. will occur.  *Note math:math
  979. 
  980. File: mintref    Node: ow    Up: Expert    Next: hl
  981. #(ow,S)    "Over Write"
  982.     This function overwrites the screen with the string S.  The next
  983. redisplay will rewrite the buffer's lines.  Multiple over writes are
  984. equivalent to a single over write.  That is, #(ow,A)#(ow,B) is equivalent to
  985. #(ow,AB).
  986. 
  987. File: mintref    Node: hl    Up: Expert    Next: db
  988. #(hl,N)    "Halt"
  989.     Exits Emacs to MS-DOS with a return code of N (decimal).  Emacs
  990. will halt with a return code of one if 'emacs.ed' cannot be found.
  991. *Note math:math
  992. 
  993. File: mintref    Node: db    Up: Expert    Next: ex
  994. #(db)    "Debug"
  995.     Executes an interrupt 3 which should enter a debugger.  Do not use
  996. this if you haven't run DEBUG first!
  997. 
  998. File: mintref    Node: ex    Up: Expert    Next: sc
  999. #(ex,F,A,I,O,E) "Execute Program"
  1000.     Executes the program F, which must be a fully qualified
  1001. pathname with an extension.  The arguments to the program are in A.
  1002. If I is non-null, then stdin is redirected to I.  If O is non-null,
  1003. then stdout is redirected to O.  If E is non-null, then stderr is
  1004. redirected to E.
  1005.     The way to execute the dos command 'dir' is:
  1006. #(ex,#(env.COMSPEC),#(env.SWITCHAR)C dir)
  1007. 
  1008. File: mintref    Node: sc    Up: Expert
  1009. #(sc,W,F) "Spell Check"
  1010.     Invoke the resident spelling checker on the word W, and function code F.
  1011. The value returned is a decimal error code or a word count.  *Note math:math
  1012.  
  1013. Function codes:
  1014.     0 will spell check the word given in W.
  1015.     1 will add a word given in W to the dictionary.
  1016.     2 will return the number of words, or an error code as given below.
  1017.     3 will write the speller to the file given in W.
  1018.     4 will empty the dictionary.
  1019.     5 will return the maximum number of words in the dictionary.
  1020.  
  1021. Errors:
  1022.      0 No error (function code 2: zero words in dictionary).
  1023.     -1 Speller not installed.
  1024.     -2 illegal function call was made
  1025.     -3 word was mis-spelled
  1026.     -4 word too long to add to dict / spell check
  1027.     -5 dictionary is full!
  1028.     -6 disk full, speller not saved
  1029.