home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Moscow ML 1.31 / source code / mosml / README.Mac < prev    next >
Encoding:
Text File  |  1995-10-20  |  22.5 KB  |  563 lines  |  [TEXT/Moml]
  1. 20Oct95 e
  2.  
  3. Moscow ML for the Apple Macintosh™
  4.  
  5. mosml is a port of Moscow ML 1.31 to the Apple Macintosh.
  6. It was done by e (Doug Currie) in late October 1995.
  7.  
  8. mosml is freeware. The entire source code for mosml is available.
  9. A number of authors have contributed to its development; see the file 
  10. copyrght/copyrght.cl for restrictions on charging money for distribution 
  11. of this software.
  12.  
  13. I have tested mosml on a PowerMac 8100 and a Mac IIfx. It surely needs 
  14. an FPU or an FPU emulator. I have not stress tested memory requirements. 
  15. I usually run with 8M allocated to mosml, but it will probably run with 
  16. much less.
  17.  
  18. Comments/questions about the port should be directed to <e@flavors.com>.
  19.  
  20. Comments/questions about Moscow ML should probably be directed elsewhere, 
  21. as I am not an expert in ML or its implementation! Please read this file, 
  22. and any other README or documentation that accompanies this release 
  23. before sending questions to me or any of the other authors, mailing lists, 
  24. or newsgroups. See the SML FAQ, and  newsgroup comp.lang.ml which I watch 
  25. via the SML-LIST mailing list.
  26.  
  27. Getting Started
  28. ---------------
  29.  
  30. Extract the files onto your hard disk. The self extracting archive should 
  31. create a mosml folder. Inside this folder are the applications, the 
  32. image, and library files.
  33.  
  34. There are two applications: mosml13ppc and mosml13m68. They are both the 
  35. same except that mosml13ppc only runs on PowerMacs, and runs faster on 
  36. PowerMacs than mosml13m68. Keep the version for your Mac and trash 
  37. the other version. From now on I'll call the version you kept "mosml."
  38.  
  39. The binary image file "mosml.image" is loaded automatically when mosml is 
  40. launched. mosml then loads some library files. It's important to avoid 
  41. moving the image or library files; they should be left where installed 
  42. (relative to mosml and the mosml folder).
  43.  
  44. Now you are running mosml interactively. Typing expressions, followed by 
  45. the Enter key (or Option-Return), causes the expression to be sent to 
  46. mosml for evaluation. Try typing:
  47.   help "lib";
  48. followed by Enter.
  49.  
  50. The Command menu contains mosml specific commands. Use these menu items 
  51. to use, load, compile, etc. The meaning of these commands is documented 
  52. in the Moscow ML documentation. The File, Edit, Search, and Windows menus 
  53. are for using the built in editor. Also in the Edit menu is a Styles item 
  54. for setting preferences (which are recorded in a "Mosml Preferences" file 
  55. in your Preferences Folder).
  56.  
  57. Later you can use the link function to build your own images. If you name 
  58. your image "mosml.image" then it will be loaded automatically at launch 
  59. instead of the original mosml image. You can also select an image to load 
  60. at launch time using the command line, see below.
  61.  
  62. Also below is a section called eConsole User Notes which describes how to 
  63. use the console and editor features.
  64.  
  65. Cow Icons
  66. ---------
  67.  
  68. My nine year old daughter, Megan, drew the icons. She is better at it than 
  69. me. I chose a cow for the icon for three reasons:
  70. 1) "cow" are the letters missing from mosml
  71. 2) Caml Light uses a camel, so I though an animal face would be appropriate
  72. 3) I think cows are nice.
  73.  
  74. Cows in New Hampshire look _something_ like the icon. They are white with 
  75. blotchy black spots. If there are any Moscow ML users out there who are also 
  76. artists, please feel free to contribute more polished icons!
  77.  
  78. Command Lines
  79. -------------
  80.  
  81. [Command lines are very non-Mac. You don't need to use them unless you 
  82. need to use mosmllex, or are bootstrapping a new version.]
  83.  
  84. If mosml cannot find the image file, or if the command key is held down 
  85. when mosml is launched, then mosml will display a single question mark 
  86. and await a command line. [The command key is the one with an apple or
  87. a "freeway interchange" symbol on it.]
  88.  
  89. The Moscow ML documentation describes command lines. The command line 
  90. options are specific to the image loaded. The general format is: 
  91.   <image-name> <command-line-options>
  92.  
  93. Examples:
  94.  
  95. :mosml.image -stdlib Bang:mosml:src:mosmllib:
  96. :mosml.image -stdlib Bang:mosml:src:mosmllib: -P full
  97. :mosmllexe :src:toolssrc:Deplex.lex
  98.  
  99. Note: when specifying -stdlib, or -I include paths, it is best to provide 
  100. complete pathnames. A relative name for the image is fine since generally 
  101. it will go unused after the image is loaded, but paths are recorded 
  102. verbatim and become useless as soon as chDir() is executed.
  103.  
  104. When launched with the command key down, mosml will type the command line 
  105. it would have executed had no keys been held down. This can be copied and 
  106. pasted into the mosml console to customize the startup, e.g., add "-P full" 
  107. or "-P none" after the typed command line to change the set of library files 
  108. initially loaded. See the Moscow ML documentation for these sets.
  109.  
  110. WARNING: The command line parser will barf at pathnames with spaces in them. 
  111. The entire path from the root to the image file, and to stdlib, should only 
  112. contain volumes and directories without spaces (or returns!) in their names.
  113.  
  114. Library Status
  115. --------------
  116.  
  117. Although much of it is UNIX derived, a surprising amount of the library 
  118. now works with the Mac. In particular, walking directory structures, and 
  119. getting information about files, elapsed/used time, time of day, and dates 
  120. are all working. In fact, as of this release, the Mac version is ahead of 
  121. the DOS and UNIX versions in capability. In particular, the Mac version:
  122. - reports time spent in GC and Multifinder when timing functions
  123. - has the mosmldep capability built into a new make function
  124. - has the linker integrated into the toplevel environment.
  125.  
  126. One compromise was necessary in Path.sml -- it assumes that the pathname 
  127. string can be used to determine if a path is relative to the current 
  128. working directory or absolute (relative to "root"). While it is always the 
  129. case that Mac pathnames starting with ":" are relative, all other pathnames 
  130. can be relative or absolute. The Mac tries its darndest to find the file 
  131. somewhere. So, I made the following choice: if the name starts with a ":" 
  132. then it's relative, else if it contains a ":" it's absolute, else it's 
  133. relative. This seems to handle common cases (i.e., it's rare to store files 
  134. at root level). Path.sml also has assumptions built in about how pathname 
  135. arcs "." and ".." behave. These are just file (or directory) names on the 
  136. Mac. The Mac approach of "::" meaning up versus ":" meaning down is so 
  137. dissimilar to the UNIX approach that I gave up and left the UNIX version 
  138. of "." and ".." processing in place.
  139.  
  140. There are also some differences in how file system links work. Mac aliases 
  141. are not 100% like UNIX links. For example, readLink() returns the absolute 
  142. pathname of the original file on the Mac. Also, stat on the Mac is actually 
  143. lstat [I think; I'm not a UNIX guru either!].
  144.  
  145. Configuration
  146. -------------
  147.  
  148. mosml remembers your Styles preferences in a Preferences Folder file.
  149.  
  150. [You need to understand Mac resources and ResEdit for the rest of the 
  151. Configuration section to make sense. Don't worry, you don't need to 
  152. know any of this to use mosml.]
  153.  
  154. The Mac version of mosml simulates UNIX environment variables with 
  155. resources of type 'ENV '. The resource number doesn't matter, the 
  156. resources are identified by name. The format of an 'ENV ' resource is 
  157. simply a C string. mosml only looks for one 'ENV ' variable called 
  158. CAMLRUNPARAM. It is used to configure the memory manager. I don't know 
  159. where it's documented (probably the Caml Light distribution). A sensible 
  160. value for this string is provided as an 'ENV ' resource in the mosml 
  161. application. If the resource is not found, another sensible value is used.
  162.  
  163. You may add 'ENV ' resources to the mosml application (or to the system, 
  164. although I wouldn't recommend it) and they can be read using the function 
  165. Process.getEnv; here's an example...
  166.  
  167. - chDir "Bang:mosml:src:mosmllib:"; load "Process.uo";
  168. > val it = () : unit
  169. - > val it = () : unit
  170. - Process.getEnv "VERSION";
  171. > val it = SOME "mosml 1.30e" : string option
  172. - 
  173.  
  174. There is also a 'STR#' resource in the mosml application called 
  175. econfigstrs. The five strings in this string list are used to form the 
  176. default command line and console window title. They are:
  177.  
  178. - image name              :mosml.image   [*]
  179. - stdlib relative path    :src:mosmllib: [*]
  180. - optional                -P
  181. - optional                default
  182. - console name            Mosml Console
  183.  
  184. When mosml uses the default command line, it converts the stdlib relative 
  185. path and the image name (marked with [*]) to absolute pathnames before 
  186. passing them to the image.
  187.  
  188. Mac toplevel
  189. ------------
  190.  
  191. The mosml toplevel environment on the Macintosh is extended from the 
  192. UNIX/DOS version. There are five new names:
  193.  
  194. make           -- see below
  195. link           -- see below
  196. moolevel       -- see below
  197. getDir         -- same as FileSys.getDir
  198. gc_full_major  -- same as Memory.gc_full_major
  199.  
  200. The first three are documented below. The last two are used by the Command 
  201. menu. gc_full_major is useful to force a garbage collect, before a benchmark 
  202. test for example.
  203.  
  204. The make and link functions can be used to build complete mosml applications 
  205. without any other tools, i.e., without a UNIX shell or make program. 
  206. Together with the separate mosmllex and mosmlyac, make and link can be used 
  207. to bootstrap mosml. [If you start from the UNIX distribution you will also 
  208. need perl, e.g., MacPerl, and you may need to preprocess some files with 
  209. the C preprocessor or by hand -- the Mac source distribution has these files 
  210. included "pre-processed."]
  211.  
  212. make
  213. ----
  214.  
  215. The make command compiles all files in a directory needing recompilation. 
  216. It has all the compile capabilities of mosmlc, plus it finds dependencies 
  217. among the files. It only compiles what needs to be compiled.
  218.  
  219. make : string -> string -> string list -> string -> unit
  220.  
  221. Evaluating:
  222.  
  223.   make <oset> <stdlib> [<dir1>..<dirN>] <path>
  224.  
  225. is equivalent to running mosmlc as follows:
  226.  
  227.   mosmlc -P <oset> -stdlib <stdlib> -I <dir1> ..  -I <dirN> <files...>
  228.  
  229. where <files...> is a subset of the files in directory <path> determined by 
  230. tracing out the dependencies among the files and their need for compilation.
  231.  
  232. The make command uses the mosmldeps parser to find dependencies for all 
  233. files in a directory, computes the transitive closure of these dependencies, 
  234. finds a consistent ordering for the files, tests each file in turn to see if 
  235. it needs compilation (including tests upon modification times of units 
  236. outside the target directory as long as they're visible to find_in_path()), 
  237. and compiles the files if necessary. It takes as arguments -stdlib and -I 
  238. paths and -P so it can be used to compile the library and compiler 
  239. directories.
  240.  
  241. A file needs compilation if:
  242.    1- there is no corresponding object file, "object"
  243.    2- the mtime of the object is older than the epoch
  244.    3- the mtime of the source is newer than mtime of the object
  245.    4- the mtime of any dependency is newer than the mtime of the object
  246. where the epoch is a built in time variable, currently Time.zeroTime.
  247.  
  248. Make keeps a cache of file dependencies; when run a second or subsequent 
  249. time the cache is consulted and verified based on the mtime of the source 
  250. file. This can save considerable time. If you ever need to flush this 
  251. cache (although I can't think of why you would) see moolevel below.
  252.  
  253. Caveats: make doesn't know about cpp, yacc, lex, sed, awk, perl, etc. It 
  254. does report when it finds ".grm" files without corresponding ".sig" and 
  255. ".sml" files, for example, (and the same for .mlp & .lex) but these must be 
  256. made manually. I have created a mosmlyac-mac which I have used to compile 
  257. the .grm files, and as I said above, mosml can run mosmllex with the command 
  258. line, and I have used this technique to compile the .lex files.
  259.  
  260. moolevel
  261. --------
  262.  
  263. moolevel : int ref
  264.  
  265. moolevel controls the verbosity of make.
  266.  
  267. 0: no messages
  268. 1: error messages
  269. 2: compile messages
  270. 3: progress messages
  271.  
  272. It defaults to 1, but I personally like level 2.
  273.  
  274. As a special hack, if moolevel is negative, then it is negated, and the 
  275. cache of file dependencies is cleared. You should never need this.
  276.  
  277. link
  278. ----
  279.  
  280. link : string -> bool * bool -> string -> string  \
  281.               -> string list -> string list -> unit
  282.  
  283. link is the link portion of mosmlc.
  284.  
  285. Evaluating:
  286.  
  287.   link <file> (<g>,<h>) <oset> <stdlib> [<dir1>..<dirN>] [<file1>..<fileN>]
  288.  
  289. is equivalent to running mosmllnk as follows
  290.  
  291.   mosmllnk -o <file> {-g} {-noheader} -P <oset> -stdlib <stdlib> \
  292.            -I <dir1> ..  -I <dirN> <file1>..<fileN>
  293.  
  294. where -g is included if <g> is true, -noheader is included if <h> is true.
  295.  
  296. If <oset> is "" then it is replaced by "default"
  297. If <oset> is "lorder" then link does the following:
  298. 1- trace out all load dependencies of <file1>..<fileN>
  299. 2- include in the list of files to be linked all other files depended upon
  300.    if they can be found in any of the specified paths
  301. 3- construct a legal link order for the files
  302. 4- then link this list as usual
  303.  
  304. Typically, simply specifying your Main program to be linked will find all 
  305. the required .uo files and put them in the right order.
  306.  
  307. Examples
  308. --------
  309.  
  310. To create a new mosml project, put all the source files in a new directory, 
  311. "project." Don't put any incomplete or irrelevant sources in the same 
  312. directory or they will be compiled, too. Assuming your project only depends 
  313. on library files, evaluate:
  314.  
  315. let val base = "pathname of the mosml directory"
  316. in
  317.   make "full" (base ^ "mosmllib") [] (base ^ "project")
  318. end;
  319.  
  320. to compile all your files. Evaluate this each time you have made changes in 
  321. your sources to keep the object files up to date.
  322.  
  323. Here is a sample make and link script to build mosml.image:
  324.  
  325. (* ********************************** *)
  326.  
  327. val home = "Bang"; (* your path to the mosml folder goes here! *)
  328.  
  329. moolevel := 2;
  330.  
  331. (* to compile the toplevel mosml image and the lexer *)
  332.  
  333. let val base = home ^ ":mosml:src:"
  334. in
  335.   make "none" (base ^ "mosmllib") [] (base ^ "mosmllib");
  336.   make "none" (base ^ "mosmllib") [] (base ^ "compiler");
  337.   make "none" (base ^ "mosmllib") [(base ^ "compiler")] (base ^ "toolssrc");
  338.   make "none" (base ^ "mosmllib") [(base ^ "compiler")] (base ^ "lex")
  339. end;
  340.  
  341. (* to build the toplevel mosml image into file "testtop.image" *)
  342.  
  343. let val base = "<home>" ^ ":mosml:src:"
  344. in
  345.   chDir base; chDir "::";
  346.   link "testtop.image"
  347.        (true,true) (* -g -noheader *)
  348.        "lorder" (base ^ "mosmllib") [(base ^ "compiler"),(base ^ "toolssrc")]
  349.        ["Maine.uo"]
  350. end;
  351.  
  352. (* another way to build the toplevel mosml image into file "testtop.image" *)
  353.  
  354. let val base = home ^ ":mosml:src:"
  355. in
  356.   chDir base; chDir "::";
  357.   link "testtop.image"
  358.        (true,true) (* -g -noheader *)
  359.        "none" (base ^ "mosmllib") [(base ^ "compiler"),(base ^ "toolssrc")]
  360.  
  361.        ["List.uo", "Char.uo", "Strbase.uo", "String.uo", "BasicIO.uo",
  362.         "Vector.uo", "Misc.uo", "Array.uo", "StringCvt.uo", "Word8.uo",
  363.         "Word8Vector.uo", "CharVector.uo", "Word8Array.uo", "CharArray.uo",
  364.         "Obj.uo", "Nonstdio.uo", "Substring.uo", "Path.uo", "Time.uo",
  365.         "OS.uo", "FileSys.uo", "Lexing.uo", "Parsing.uo", "Miscsys.uo",
  366.         "Printexc.uo", "Filename.uo", "Fnlib.uo", "Sort.uo", "Stack.uo",
  367.         "Arg.uo", "Hasht.uo", "Memory.uo", "Config.uo", "Mixture.uo",
  368.         "Const.uo", "Smlexc.uo", "Prim.uo", "Instruct.uo", "Lambda.uo",
  369.         "Smlprim.uo", "Globals.uo", "Location.uo", "Units.uo", "Types.uo",
  370.         "Smlperv.uo", "Asynt.uo", "Asyntfn.uo", "Parser.uo", "Lexer.uo",
  371.         "Primdec.uo", "Infixst.uo", "Ovlres.uo", "Synchk.uo", "Infixres.uo",
  372.         "Elab.uo", "Tr_env.uo", "Pr_lam.uo", "Match.uo", "Front.uo",
  373.         "Back.uo", "Pr_zam.uo", "Opcodes.uo", "Prim_opc.uo", "Buffcode.uo",
  374.         "Labels.uo", "Code_dec.uo", "Reloc.uo", "Emitcode.uo", "Emit_phr.uo",
  375.         "Sigmtch.uo", "Crc.uo", "Compiler.uo", "Predef.uo", "Prim_c.uo",
  376.         "Symtable.uo", "Patch.uo", "Tr_const.uo", "Rtvals.uo", "Load_phr.uo",
  377.         "Exec_phr.uo", "Link.uo", "Deppars.uo", "Deplex.uo",
  378.         "Smltope.uo", "Maine.uo"]
  379. end;
  380.  
  381. (* to build the lexer into file "mosmllex" *)
  382.  
  383. let val base = home ^ ":mosml:src:"
  384. in
  385.   chDir base; chDir "::";
  386.   link "mosmllex"
  387.        (true,true) (* -g -noheader *)
  388.        "none" (base ^ "mosmllib") [(base ^ "lex"),(base ^ "compiler")]
  389.  
  390.        ["List.uo", "Vector.uo", "Array.uo", "Char.uo", "Strbase.uo", 
  391.         "String.uo", "StringCvt.uo", "Word8.uo", "Word8Vector.uo", 
  392.         "Word8Array.uo", "CharVector.uo", "CharArray.uo", "Obj.uo", 
  393.         "BasicIO.uo", "Nonstdio.uo", "Lexing.uo", "Parsing.uo", 
  394.         "Miscsys.uo", "Printexc.uo", "Filename.uo", "Fnlib.uo", 
  395.         "Sort.uo", "Arg.uo", "Hasht.uo", "Syntax.uo", "Scan_aux.uo", 
  396.         "Gram_aux.uo", "Grammar.uo", "Scanner.uo", "Lexgen.uo", 
  397.         "Output.uo", "Mainlex.uo"]
  398. end;
  399.  
  400. (* ********************************** *)
  401.  
  402. eConsole User Notes
  403. -------------------
  404.  
  405. 1. Interacting with the interpreter
  406.  
  407. Interaction with the interpreter's read-eval-print (REP) loop is done 
  408. inside the "Mosml Console" window. The contents of the interaction window 
  409. can be edited by the user. This window also acts as the default standard 
  410. output port (and input port). Consequently, the interpreter sends its 
  411. output to the interaction window. User input and system output are 
  412. displayed with different fonts. By default, user input is in bold face 
  413. (but this and other attributes of the window can be changed with the 
  414. "Styles..." item in the Edit menu).
  415.  
  416. Normally, the user types an expression and then "sends" it to the 
  417. interpreter to be evaluated. The result of the evaluation is then output 
  418. to the interaction window. The preferred way of evaluating an expression 
  419. is to place the insertion point (caret) immediately after the expression 
  420. to evaluate and then typing the <enter> key. An alternative method is to 
  421. use the <opt-return> (i.e. press the <return> key while pressing the 
  422. <option> key). When <enter> is pressed, the sequence of "user input" 
  423. characters immediately preceding the insertion point are sent to the 
  424. interpreter. Because it doesn't check for a properly formed expression, 
  425. the <enter> key is useful for programs doing text oriented input. Arbitrary 
  426. text can also be sent to the interpreter by selecting the text and typing 
  427. <opt-return> or <enter>.
  428.  
  429. These interaction mechanisms also work from windows associated to files 
  430. (i.e., in an edit buffer). However, the result of evaluation is always 
  431. displayed in the interaction window.
  432.  
  433. 2. Basic editing
  434.  
  435. It is assumed that you are familiar with standard Macintosh editing 
  436. techniques. If not, you should consult your Getting Started disks and 
  437. Macintosh users' manuals.
  438.  
  439. On all keyboards the following keys are defined:
  440.  
  441.     delete - erase character before cursor position
  442.        tab - indent current line
  443.     return - insert a new line and move to the left margin (and then
  444.              do a <tab> if autoindent is selected for the window)
  445. opt-return - send the expression preceding the insertion point
  446.      enter - send the user input preceding the insertion point
  447.  
  448. 3. Special keys
  449.  
  450. On extended keyboards the following special keys are supported:
  451.  
  452.    F1 - F4 - equivalent to Undo, Cut, Copy and Paste
  453.   F5 - F15 - function keys (not used)
  454.       del> - erase character after the insertion point
  455.       home - scroll text to the top of the edit buffer
  456.        end - scroll text to the bottom of the edit buffer
  457.    page up - scroll text up a page
  458.  page down - scroll text down a page
  459.  
  460. Note that these last four do not move the insertion point, just scroll.
  461.  
  462. 4. Arrow keys
  463.  
  464. Arrow keys (when available) move the insertion point in the corresponding 
  465. direction:
  466.  
  467.       left - move cursor to the left one character
  468.      right - move cursor to the right one character
  469.         up - move cursor up one line
  470.       down - move cursor down one line
  471.  
  472. Arrow keys can be modified with the <shift>, <option>, and <command> keys.
  473.  
  474. The <shift> key may be used to extend the text selection per Apple 
  475. standards. Each selection has an anchor end and an active end. Generally, 
  476. the active end is the last end you moved, the anchor end doesn't move. When 
  477. the <shift> key is held down, the selection's active end is moved by the 
  478. arrow keys.
  479.  
  480. The <option> key may be used with the arrow keys to move the insertion 
  481. point left or right by word, or up or down by page. <Shift> and <option> 
  482. together may be used to move the active end of the selection left or right 
  483. by words, or up or down by pages.
  484.  
  485. The <command> key may be used with the arrow keys to move the insertion 
  486. point left or right to the beginning or end of the line, or up or down to 
  487. the beginning or end of the text. <Shift> and <command> together may be 
  488. used to move the active end of the selection to start or end of the line 
  489. or text.
  490.  
  491. When <shift>, <option>, and <command> are held down together, the up or 
  492. left arrow will make the beginning of the selection the active end, and the 
  493. down or right arrow will make the end of the selection the active end.
  494.  
  495.  
  496. 5. Emacs commands
  497.  
  498. [Sorry, with this version most Emacs commands are absent.]
  499.  
  500. A small subset of Emacs compatible command keys are supported by the editor.
  501. Some of these commands make use of the <control> key.
  502.  
  503. The following table lists the Emacs compatible command keys using the 
  504. following abbreviations:
  505.   C = <control> key, M = <option> key (Emacs' "meta" key).
  506.  
  507. Commands which move the insertion point:
  508.  
  509.   C-f      - forward character
  510.   C-M-f    - forward S-expression
  511.   C-b      - backward character
  512.   C-M-b    - backward S-expression
  513.   C-a      - beginning of line
  514.   C-M-a    - beginning of S-expression
  515.   C-m      - select enclosing S-expression
  516.   C-M-m    - select enclosing S-expression
  517.   C-e      - end of line
  518.   C-M-e    - end of S-expression
  519.   C-p      - previous line
  520.   C-n      - next line
  521.  
  522. Commands which modify the buffer:
  523.  
  524.   C-d      - delete forward (same as del> key)
  525.   C-del>   - delete to end of line
  526.   C-k      - same as C-del>
  527.   C-o      - open line
  528.  
  529. Other commands:   M-return - same as <opt-return>
  530.  
  531. 6. Mouse
  532.  
  533. The editing action is specified by the number of mouse button clicks:
  534.  
  535.     single - position insertion point
  536.     double - select word
  537.     triple - select line
  538.  
  539. Dragging after one of these clicks extends the selection by character, word,
  540. or line respectively; the anchor point is the original click position, the 
  541. active end is the other end of the selection. After a click-drag, the 
  542. active end can be moved with <shift> clicks or <shift> arrow keys. The 
  543. anchor and active ends of the selection can be swapped with
  544. <option+shift+click>, or <option+shift+command> up/down or left/right arrow 
  545. keys.
  546.  
  547.  
  548. 7. Scrolling
  549.  
  550. Holding down <command>, <shift>, <option>, and <control> keys speeds up 
  551. scrolling when mousing in the arrows of the scroll bar. The more keys you 
  552. hold down the faster it scrolls (exponentially).
  553.  
  554.  
  555. 8. Editor limitations
  556.  
  557. The text size is limited by memory space. There is a limit of 32,000 lines 
  558. (not characters) per window. The editor has been used with files several 
  559. hundred kilobytes in size.
  560.  
  561. Credits: Thanks to Marc Feeley for contributing to the eConsole User Notes.
  562.  
  563.