2003-11-24 John Harper * version 0.17 2003-05-08 John Harper * rep/util/repl.jl (,collect): print memory usage statistics 2003-07-08 John Harper * rep/xml/reader.jl (read-tag-body): unreverse items when creating the item. Adapted from a patch from Alexander V. Nikolaev 2003-03-18 John Harper * rep/data/string-util.jl (string-capitalized-p, capitalize-string): fixed zero-length string case. Pointed out and fixed by Charles Stewart , though I used a slightly different patch 2003-02-25 John Harper * version 0.16.2 2002-09-29 John Harper * rep/lang/interpreter.jl (define-special-variable): define manually, not using backquote, which seems to sometimes not be loaded when this is used 2002-09-21 John Harper * rep/vm/compiler/modules.jl (compiler-boundp): check if arg is a symbol 2002-08-01 John Harper * rep/xml/reader.jl (read-param-list): skip whitespace around '=' characters in attribute lists 2002-06-22 John Harper * version 0.16.1 * Makefile.in: include rep/xml in installed modules * rep/vm/compiler/modules.jl (find-structure): catch the error that happens if the module can't be loaded and return nil 2002-06-20 John Harper * version 0.16 * rep/xml/reader.jl, rep/xml/printer.jl: some code I wrote when I was interested in making rep speak xml-rpc. I didn't finish it, but, if I recall correctly, the xml parser and printer worked well enough that it might be useful for toy problems.. 2002-04-21 John Harper * rep/util/autoloader.jl (make-autoloader): propagate arbitrary arguments after the two we're interested in 2002-04-14 John Harper * rep/data/queues.jl: rewritten so that enqueuing is O(1) not O(n) 2002-04-13 John Harper * rep/threads/proxy.jl: new module, untested, written a long time ago and never used * rep/lang/profiler.jl: don't use the "interval" when printing results, it's totally bogus.. * rep/user.jl (parse-options): in --debug mode, break on failed checks, etc 2002-03-30 John Harper * rep/net/rpc.jl: more reliable/predictable error handling. Also when closing a socket, report failures on any requests pending on that socket (avoids hanging forever..) 2002-03-24 John Harper * rep/vm/compiler/inline.jl (max-inline-depth): increased from 8 to 64 2002-03-09 John Harper * rep/util/repl.jl (repl-eval, define-repl-command): export these functions - they may be useful for custom repls 2002-03-03 John Harper * rep/data/objects.jl: added an object-lambda macro that's useful when the body of the object (i.e. the method switch) needs to be implemented by hand 2002-02-27 John Harper * rep/net/rpc.jl (make-proxy): use a table of weak references to cache rpc proxies 2002-02-09 John Harper * rep/util/repl.jl (do-readline): new function to avoid loading and using readline if stdin isn't a tty 2002-01-20 John Harper * rep/data/trie.jl: new module. A useful data structure for encoding word lists as character trees 2001-12-20 John Harper * rep/net/rpc.jl: new (incompatible) rpc protocol. It now allows three types of calls, synchronous, asynchronous (a callback will be called with the result) and one-way 2001-12-14 John Harper * rep/io/streams.jl (format-hooks-alist): initialize this correctly, so the function values are added, not their names 2001-10-28 John Harper * version 0.15.2 2001-10-19 John Harper * rep/util/repl.jl: renamed ,dis as ,disassemble (since the unique prefix thing will accept ,dis anyway) 2001-10-11 John Harper * rep/lang/interpreter.jl (default-error-handler): catch and ignore errors that happen in the error handler (to avoid a possible infinite loop..) 2001-10-01 John Harper * version 0.15 2001-09-15 John Harper * rep/www/cgi-get.jl (self-test): new function. Some test cases * rep/www/quote-url.jl (quote-url, unquote-url): defined in terms of string-replace now (self-test): new function. A few test cases for this module * rep/regexp.jl (string-replace): the TEMPLATE parameter may now be a function, e.g. (string-replace "[ab]" (lambda (s) (1+ (aref s (match-start)))) "foobar") -> "foocbr" 2001-09-02 John Harper * rep/io/file-handlers/tilde.jl (tilde-file-handler): fixed last change to this file so that it actually does expand the stuff after the tilde sometimes! * rep/vm/compiler/rep.jl (compile-log): new function, handles the new `log' function (which optionally has a BASE parameter). Compiles this into two calls to log and a divide * rep/util/repl.jl: fixed ,reload and ,unload commands not to try to unload structures that don't actually exist 2001-08-31 John Harper * rep/test/framework.jl (run-all-self-tests, run-module-self-tests): these both return the number of failed tests now 2001-08-27 John Harper * rep/util/repl.jl: meta commands may now be specified using unique prefixes, instead of their whole name 2001-08-24 John Harper * rep/io/file-handlers/tilde.jl (tilde-file-handler): in expand-file-name handler, only try to expand non-null things after the tilde 2001-08-16 John Harper * rep/vm/compiler/rep.jl (compile-set): raise an error if trying to set value of a non-symbol 2001-08-13 John Harper * rep/vm/compiler/rep.jl (compile-letrec): when compiling the lambda for the second time, turn off all output (to avoid repeating error messages) * rep/vm/compiler/utils.jl (silence-compiler): new fluid variable (compiler-message): only print messages if silence-compiler is false * rep/threads/message-port.jl (message-fetch): rewrote wait loop so it always tries once after condition-wait failed * rep/lang/debugger.jl (print-backtrace): print backtrace in top to bottom order, not bottom to top 2001-08-10 John Harper * rep/threads/message-port.jl (message-send): remembered to actually signal the condition after enqueuing the message! 2001-08-09 John Harper * rep/threads/message-port.jl: new module, implements a simple message queue for threads using mutexes and condition variables * rep/net/rpc.jl: one minor bug fix 2001-08-08 John Harper * rep/user.jl, rep/lang/debugger.jl: renamed --rep-debug as --debug and --rep-emacs-debugger as --emacs-debug 2001-08-07 John Harper * rep/lang/define.jl (define-scan-body): only return new list structure if it's different to the original. This prevents line number information being discarded needlessly * rep/lang/debugger.jl: much improved. Supports line numbers (with emacs style embedded cookies), better backtraces, etc.. * rep/user.jl: support --rep-debug option -- launches into the debugger * rep/data/ring.jl, rep/data/queues.jl: * rep/io/file-handlers/remote/rep.jl, rep/io/file-handlers/remote/ftp.jl: * rep/lang/interpreter.jl: * rep/threads/condition-variable.jl: * rep/util/repl.jl: * scheme/misc.jl, scheme/data.jl: * unscheme/misc.jl, unscheme/data.jl: Declarations to silence compiler warnings about unused parameters * rep/vm/compiler.jl: * rep/vm/compiler/utils.jl, rep/vm/compiler/scheme.jl, rep/vm/compiler/rep.jl, rep/vm/compiler/modules.jl, rep/vm/compiler/inline.jl, rep/vm/compiler/bindings.jl, rep/vm/compiler/basic.jl: Better error reporting, including (gasp) line numbers 2001-08-02 John Harper * rep/threads/condition-variable.jl (condition-variable-wait): new optional TIMEOUT parameter. The function returns false if the timeout expires. Note that even if this is the case the function will still re-obtain the mutex before exiting. Also, release the mutex and suspend the thread atomically * rep/threads/mutex.jl (obtain-mutex): new optional TIMEOUT parameter. The function returns false if the timeout expired and the mutex couldn't be obtained, true otherwise 2001-08-01 John Harper * rep/vm/compiler/modules.jl (symbol-value-1): return false for variables with local bindings (compiler-macroexpand-1): ignore macro calls whose name has a local bindings * rep/util/repl.jl (repl-iterate): ignore empty lines 2001-07-31 John Harper * rep/data/objects.jl (object): reverted last change (factoring out lambda expressions). It moves them out of the scope of the `self' parameter, which is a bad thing 2001-07-30 John Harper * rep/data/objects.jl: move method bodies that are lambda expressions into a let block outside the object's lambda in the expansion, then reference their new names. This avoids consing a new closure each time a method is called 2001-07-28 John Harper * rep/io/file-handlers/tilde.jl: fixed the logic for substituting ~ for the user's home directory at initialization * rep/lang/error-helper.jl (for-each-structure): ignore null structures (possible if called while creating a structure?) 2001-07-26 John Harper * rep/util/repl.jl: don't print results that are #undefined * rep/lang/interpreter.jl, rep/util/gaol.jl (define-value): finally deleted * rep/lang/interpreter.jl: export a self-referential binding of #undefined * rep/lang/error-helper.jl: new module -- given an error, try to deduce what could have caused, and how the user can avoid it in future. Currently only handles some void-value errors * rep/lang/interpreter.jl (default-error-handler): call the error-helper function * rep/data/objects.jl: objects now have an implicit `self' binding -- the object representing themself (or their derived self). Also fixed a bug where the BASE-OBJECT parameter could be evaluated zero or multiple times, instead of just once 2001-07-22 John Harper * rep/util/repl.jl: use the standard error handler, instead of a cut-and-pasted version 2001-07-17 John Harper * rep/lang/interpreter.jl (letrec): allow right-hand-sides of letrec bindings to have more than one form * rep/io/file-handlers/remote/rep.jl (remote-rep-output-filter): don't print annoying messages about unhandled input 2001-07-15 John Harper * rep/user.jl: catch errors signalled during command line option processing, pass them to the default error handler and quit. This avoids the horrible `error -> (void-value foo)' style error messages 2001-07-02 John Harper * version 0.14 2001-06-29 John Harper * rep/net/rpc.jl: added some (disabled) debugging code * rep/net/rpc.jl: minor changes 2001-06-28 John Harper * rep/net/rpc.jl (async-rpc-call, make-proxy, rpc-output-handler): support async (`one way') rpc requests * rep/data.jl (vector->list, list->vector): new functions * rep/net/rpc.jl (make-proxy): precalculate global-id value 2001-06-27 John Harper * rep/net/rpc.jl: added some comments, some API changes 2001-06-26 John Harper * rep/net/rpc.jl (call-with-rpc-servant): new function * rep/net/rpc.jl: misc changes. Added support for global servant ids (prefixed with ip address and port number) * rep/net/rpc.jl: new module -- simple Lisp syntax based RPC mechanism over TCP streams 2001-06-14 John Harper * rep/vm/compiler/rep.jl (compile-cond): disabled dead-code warnings after constant conditions, they're too annoying to be useful 2001-05-04 John Harper * rep/vm/compiler/rep.jl (trans-defvar): fixed typo in the last change (using , in a non-backquote form) 2001-05-01 John Harper * rep/vm/compiler/rep.jl (trans-defvar): if the defvar has a constant doc string, add it to the documentation database 2001-04-30 John Harper * rep/lang/interpreter.jl (define-special-variable): new macro, a combination of defvar and setq. It always declares the variable special and it always sets the value 2001-03-26 John Harper Work to make rep self-testing. The framework and some tests exist, but I still need to add unit tests for many modules: * rep/test/framework.jl: self-testing framework. Provides `assert', 'check' and `test' macros, as well as random other stuff for supporting these. * rep/test/data.jl: tests for rep.data module * rep/data/queues.jl: added self tests * rep/user.jl: added --check option * rep/util/repl.jl: added a `,check' command * Makefile.in: added a `check' target * rep/io/file-handlers/remote/rep.jl (remote-rep-while): use accept-process-output-1 instead of accept-process-output (remote-rep-output-filter): ignore blank lines 2001-03-22 John Harper * version 0.13.5 2001-03-21 John Harper * rep/io/file-handlers/tar.jl (tarfh-call-tar): only call tarfh-check-tar-program if the given tar file actually exists 2001-03-12 John Harper * rep/io/file-handlers/tar.jl (tarfh-alternative-gnu-tar-programs): added `gnutar' and the GNU tar emulation script to this list (tarfh-list-regexp): hacked this to also recognize the date format used by Solaris tar 2001-02-13 John Harper * rep.jl (debug-entry, debug-exit, debug-error-entry): declare using defvar 2001-02-12 John Harper * rep/data/string-util.jl (string-upper-case-p, string-lower-case-p): only return t if the string contains at least one upper/lower case character 2001-01-27 John Harper * rep/i18n/xgettext.jl (scan): fixed typo when scanning `lambda' forms (was scanning the car (!?) instead of the cddr) 2001-01-14 John Harper * rep/util/gaol.jl (gaol-safe-functions): added listp 2001-01-08 John Harper * rep/util/repl.jl (repl-iterate): change the error handler reading normal forms to catch premature-end-of-stream, not end-of-stream 2001-01-04 John Harper * version 0.13.4 2000-12-29 John Harper * rep/threads/condition-variable.jl: new file, implemented the usual condition variable interface (but not quite strong enough for SRFI-18 compatibility, condition-variable-wait would need a TIMEOUT parameter) 2000-12-20 John Harper * rep/util/gaol.jl (gaol-safe-functions): added string-split and string-replace 2000-12-03 John Harper * version 0.13.3 2000-11-27 John Harper * scheme/data.jl: when defining `>' and similar predicates, use `rep#FOO' to get the rep versions, instead of just relying on the fact that their local bindings haven't been created yet 2000-11-26 John Harper * rep/lang/define.jl (define-scan-form): don't expand (i.e. delete) declaration forms 2000-11-21 John Harper * rep/vm/peephole.jl (peephole-optimizer): added transformation `{jpt,jpn,jtp,jnp} X; jmp Y; X: --> {jnp,jtp,jpn.jpt} Y; X:', can help some `do' loops e.g. 2000-11-12 John Harper * rep/util/repl.jl (completion-generator): pass this function as an argument to `readline' (i.e. don't call it rl-completion-generator) 2000-10-23 John Harper * version 0.13.2 2000-10-18 John Harper * Makefile.in: patch from Scott Heavner to fix `install' shell scripting 2000-09-29 John Harper * rep/lang/define.jl: track bound variables, then don't expand calls to these special forms or macros 2000-09-28 John Harper * version 0.13.1 2000-09-27 John Harper * rep/io/file-handlers/remote/ftp.jl (remote-ftp-get-file): work around bug in `ls .' with my (wu) ftpd * rep/system/pwd-prompt.jl: import rep.io.streams and rep.lang.math 2000-09-26 John Harper * rep/lang/define.jl (define-scan-form): don't expand structure or define-structure forms (any internal definitions they contain should be treated as top-level within the structure) 2000-09-24 John Harper * rep/data.jl (remove-if, remove-if-not): new functions 2000-09-22 John Harper * rep/vm/compiler/modules.jl (note-require): try to fix this slightly in the presence of unmodularized files 2000-09-20 John Harper * version 0.13 2000-09-19 John Harper * rep/net/domain-name.jl: new file, some domain name functions (from TITAN) * rep/regexp.jl (string-split): new function * rep.jl, rep/user.jl, rep/io/files.jl, rep/vm/compiler/modules.jl: *root-structure* is now replaced by *user-structure* 2000-09-18 John Harper * rep/vm/compiler/modules.jl (current-module): this now defaults to *user-structure* not *root-structure* 2000-09-17 John Harper * rep/lang/doc.jl (describe-value): replaced `Built-in' by `Native' to describe subrs * rep/util/repl.jl (,describe): pass structure name to describe-value * rep/lang/interpreter.jl (nil, t, defmacro): use third arg of %define to specify documentation of these bindings * rep/lang/doc.jl (describe-value): include special-variable and immutable-binding information in the type description. Don't surround the name in parentheses unless we have details of the parameter list (documentation): don't use boundp/symbol-value to look for in-core documentation 2000-09-14 John Harper * rep/util/repl.jl (locate-binding*): only check the current module for a binding when one isn't imported, not the other way around 2000-09-12 John Harper * rep/vm/compiler/rep.jl: after lifting top-level progn forms, add progns to coalesce forms that wouldn't be compiled specially at top-level. Each progn then forms a single byte code form 2000-09-11 John Harper * Makefile.in: invoke compile-assembler before compile-compiler * rep/vm/compiler.jl (compile-assembler): new function * rep/vm/peephole.jl: rep.vm.compiler.opt moved here since it may be useful outside the compiler * rep/vm/compiler/opt.jl: remove dependences on other compiler modules * rep/util/repl.jl (locate-binding*): check the current module before looking in the imports * rep/lang/define.jl: groks doc strings in `(define SYMBOL VALUE DOC)' forms. Will move them to the body of defuns, or else leave them in the %define form * rep/vm/compiler/rep.jl (do-pass-2): extract doc strings from %define forms 2000-09-10 John Harper * rep.jl: `rep.io.streams' is exported from `rep' again. I've decided it's too fundamental not to. Changed all the modules that imported it explicitly 2000-09-09 John Harper * rep/vm/compiler/modules.jl: when compiling module definition forms, after compiling the top-level forms, ensure that the resulting lambda expression is compiled in the correct module environment 2000-09-08 John Harper * rep.jl: don't export rep.repexp, rep.system, rep.io.streams, rep.io.files, rep.io.processes, rep.io.file-handlers. If they're needed, they'll need to be imported explicitly The rationale is that `(open rep)' should just specify the language, and not unrelated random parts of the runtime environment. Also, I can imagine systems where some of these modules (e.g. rep.io.processes) aren't available * rep/vm/compiler/utils.jl (test-variable-ref, test-variable-bind, test-function-call): never use boundp to check for validity of reference. Use compiler-boundp instead. Similar for symbol-value and compiler-symbol-value * rep/vm/compiler/modules.jl (compiler-boundp): new function * rep/system.jl, rep/lang/interpreter.jl (nop, interactive): moved from rep.system to rep.lang.interpreter * rep/data.jl, rep/data/string-util.jl, rep/regexp.jl (string-replace): moved from rep.data to rep.regexp * scheme/misc.jl, unscheme/misc.jl: explicitly reference all used bindings in rep.io.streams * rep/user.jl: * rep/data/records.jl: * rep/i18n/xgettext.jl: * rep/io/file-handlers/tilde.jl, rep/io/file-handlers/tar.jl, rep/io/file-handlers/remote.jl: * rep/io/file-handlers/remote/utils.jl, rep/io/file-handlers/remote/rep.jl, rep/io/file-handlers/remote/rcp.jl, rep/io/file-handlers/remote/ftp.jl: * rep/lang/profiler.jl, rep/lang/doc.jl, rep/lang/debugger.jl: * rep/mail/addr.jl: * rep/util/ispell.jl, rep/util/gaol.jl, rep/util/date.jl, rep/util/base64.jl: * rep/vm/disassembler.jl, rep/vm/compiler.jl: * rep/vm/compiler/inline.jl, rep/vm/compiler/basic.jl: * rep/www/quote-url.jl, rep/www/fetch-url.jl, rep/www/cgi-get.jl: Added necessary imports of the modules removed from `rep' interface * rep/util/repl.jl: new command `,whereis VAR' 2000-09-07 John Harper * rep/util/time.jl: new module, a few utilities for converting timestamps to scalars and vice versa. From TITAN 2000-09-06 John Harper * rep/vm/compiler/modules.jl: added `(declare (language LANG))' declaration * rep/data/objects.jl (object): added a second method syntax: (METHOD-NAME FUNCTION) (in addition to ((METHOD-NAME . PARAM-LIST) BODY...)). This allows arbitrary functions to be used as method implementations 2000-09-05 John Harper * rep/module-system.jl: don't explcitly export `provide', `require' and `featurep', this is done from C code now * rep/data/records.jl: instead of using a static (higher-order) record-constructor function, create a local function for each record type. This allows the constructor parameter list to include all standard rep lambda-list features (i.e. including keywords and default values, etc..) * Makefile.in: lisp depends on ../src/.libexec 2000-09-04 John Harper * rep/vm/compiler/scheme.jl: when compiling let* and letrec forms, scan out inner defines before passing the forms to the rep compilers * rep/vm/compiler/unscheme.jl: same thing * scheme/syntax-funs.jl (expand-letrec): expand inner defines in body by hand; `lambda' would miss them since they come after the initialising `set!' forms * rep/i18n/xgettext.jl: track the current module name while scanning, and export it via the current-module fluid 2000-09-03 John Harper * rep/util/repl.jl: added command `,locate SYM' to find the module that a variable is bound in * rep/lang/doc.jl (describe-value): fixed bug of not looking for the documentation of functions not yet autoloaded * rep/structures.jl (locate-binding): new function * rep/data/string-util.jl (string-replace): new function * rep/data.jl: autoload string-replace * rep/lang/doc.jl: store doc strings under keys `MODULE#SYMBOL' instead of just `SYMBOL'. (The old-style keys are still checked when searching for documentation.) Changed some function parameter lists to include a STRUCTURE parameter * rep/lang/compat-doc.jl: new file, a compatibility layer for the 'lisp-doc module in the last rep release * rep/util/repl.jl: `,describe' command scans the imported modules for the binding of the thing being queried * rep/vm/compiler/modules.jl: export current-module * rep/vm/compiler/rep.jl, rep/vm/compiler/basic.jl: changed for new rep.lang.doc function parameters * rep/util/repl.jl (repl-completions): new function 2000-09-02 John Harper * rep/util/gaol.jl (define-gaol-structure): new function, used to assign a module name to a gaol * rep/util/ispell.jl: use accept-process-input-1 so as not to call other process handlers asynchronously 2000-08-27 John Harper * rep/vm/compiler/inline.jl, rep/vm/compiler/basic.jl: now evaluate default values of #!optional and #!key parameters * rep/vm/disassembler.jl, rep/vm/bytecode-defs.jl: foo-arg-with-default is now foo-arg*, these now push a variable number of values * rep/data.jl (remove, remq): new functions 2000-08-25 John Harper * rep/vm/compiler/rep.jl (pass-1): recursively flatten `progn' forms (correctly now) * rep/vm/compiler/utils.jl (compiler-constant-p, compiler-constant-value): handle keyword symbols 2000-08-21 John Harper * rep/i18n/xgettext.jl (scan): scan bodies of define-structure and structure forms 2000-08-17 John Harper * rep/util/gaol.jl (gaol-define-vm): new function, installs a given virtual machine in the gaol * rep/vm/compiler/bindings.jl: added `(unused VARS...)' declaration to selectively turn off unused variable warnings * rep/lang/doc.jl, rep/vm/compiler/utils.jl, rep/vm/compiler/inline.jl, rep/vm/compiler/basic.jl: support default values in #!optional and #!key params * rep/vm/disassembler.jl, rep/vm/bytecode-defs.jl (optional-arg-with-default, keyword-arg-with-default): new instructions * rep/util/gaol.jl: added `intern' and `do' 2000-08-16 John Harper * rep/vm/compiler/utils.jl (test-function-call): don't warn about too many args if the function has #!key params * rep/vm/compiler/rep.jl (compile-condition-case): when creating an unused binding for `(condition-case nil ...)' mark it as referenced to avoid a compiler warning * rep/vm/compiler/utils.jl (remember-function): handle #!optional, #!rest and #!key (compiler-deprecated): new function * rep/vm/compiler/inline.jl (push-inline-args): handle #!optional and #!rest. Error out if #!key is encountered * rep/vm/compiler/basic.jl (compile-form-1): compile keyword symbols as constants (compile-lambda-spec): handle #!optional, #!rest and #!key, deprecated &optional and &rest * all lisp files: use #!optional and #!rest instead of deprecated &optional and &rest 2000-08-15 John Harper * scheme/data.jl (symbol?, string-ci>?, string-ci>=?): fixed these functions * scheme/data.jl: use standard rep cons accessors. R5RS says that ``it is an error to take the c[ad]r of the empty list''. But §1.3.2 notes that detection of ``is an error'' situations is not required * rep/vm/compiler/scheme.jl: use standard cons accessors; compile `list-ref' and `list-tail' using `nth' and `nthcdr' instructions * rep/vm/compiler/unscheme.jl: use `list-ref' and `list-tail' inliners from the scheme compiler * rep/vm/compiler/rep.jl: added inliner properties for cadddr * rep/vm/compiler/unscheme.jl, rep/vm/compiler/scheme.jl: when copying rep-compile-fun properties, also copy rep-compile-opcode if it's present 2000-08-13 John Harper * rep/vm/compiler/opt.jl: new patterns, `push 0; num-eq -> zerop', `zerop; not -> not-zero-p' * rep/vm/bytecodes.jl, disassembler.jl (not-zero-p): new instruction * rep/data/sort.jl, rep/io/file-handlers/tar.jl, rep/io/file-handlers/remote/utils.jl, rep/io/file-handlers/remote/rep.jl, rep/io/file-handlers/remote/rcp.jl, rep/io/file-handlers/remote/ftp.jl, rep/lang/doc.jl, rep/lang/define.jl, rep/lang/backquote.jl, rep/util/date.jl, rep/util/base64.jl, rep/vm/disassembler.jl, rep/vm/compiler.jl, rep/vm/compiler/utils.jl, rep/vm/compiler/src.jl, rep/vm/compiler/opt.jl, rep/vm/compiler/modules.jl, rep/vm/compiler/lap.jl, rep/vm/compiler/inline.jl, rep/vm/compiler/basic.jl, rep/www/cgi-get.jl: added `(declare (unsafe-for-call/cc))' * rep/system/environ.jl: rewritten to use tail recursion instead of side effects * rep/vm/compiler/bindings.jl: don't allocate variables to slots if they're modified after a function has been called. (Due to call/cc the function could return multiple times, but it would get the _same_ values for any slot-allocated bindings, even if they have since been modified). The `(unsafe-for-call/cc)' declaration can be used to prevent this (but it may lead to incrorrect results...) * rep/util/repl.jl (repl): install a low-level exception handler to catch interrupt signals 2000-08-12 John Harper * rep/vm/compiler/modules.jl (compile-structure-def): fixed compilation of non-top-level structure definitions 2000-08-11 John Harper * rep/lang/doc.jl (doc-file-set): pass 'no-lock flag to gdbm-open * rep/vm/compiler/rep.jl (compile-cond): fixed bug of not propagating return-follows information to body-less final conditions. This meant that things like `(define (test a) (and a (test a)))' wouldn't have had the tail call made into a jump This has a _huge_ effect on the prime benchmark, iterations per minute increases by 60%! For comparison: current rep 2580 (1.0) qscheme-0.3.3 1860 (.72) scheme48-0.53 835 (.32) ; in benchmark mode guile-0.4 314 (.12) ; with (debug-disable 'debug) 300MHz mobile Pentium II; code as follows: (define (prime n) (letrec ((primep (lambda (n primes) (or (null primes) (and (not (zerop (remainder n (car primes)))) (primep n (cdr primes))))))) (let loop ((i 2) (candidate 2) (primes '())) (cond ((not (primep candidate primes)) (loop i (+ 1 candidate) primes)) ((= i n) candidate) (t (loop (+ 1 i) (+ 1 candidate) (cons candidate primes))))))) (define (test) (let loop ((count 1)) (prime 100) (format standard-output "%d\n" count) (loop (+ 1 count)))) I need a new benchmark now.. 2000-08-10 John Harper * rep/lang/doc.jl (describe-value): bytecode subrs no longer include arg spec * rep/vm/compiler.jl, rep/vm/compiler/utils.jl, rep/vm/compiler/unscheme.jl, rep/vm/compiler/src.jl, rep/vm/compiler/scheme.jl, rep/vm/compiler/rep.jl, rep/vm/compiler/opt.jl, rep/vm/compiler/no-lang.jl, rep/vm/compiler/modules.jl, rep/vm/compiler/lap.jl, rep/vm/compiler/inline.jl, rep/vm/compiler/bindings.jl, rep/vm/compiler/basic.jl: Many compiler improvements: first order closure analysis; stack allocation of uncaptured bindings; fixed `case' statements without else clauses * rep/vm/compiler/const.jl, rep/vm/compiler/asm.jl: deleted * rep/util/repl.jl: fixed ,compile-proc command * rep/vm/disassembler.jl, rep/vm/bytecodes.jl, rep/vm/bytecode-defs.jl, rep/vm/assembler.jl: various changes to the vm architecture. Bumped major version 2000-08-03 John Harper * rep/i18n/xgettext.jl: yanked the useful bits of src/rep-xgettext.jl into a library module to enable customized xgettext scripts to be written * rep/vm/assembler.jl: a higher-level assembler * rep/vm/disassembler.jl: split into two functions * rep/vm/bytecodes.jl, rep/vm/bytecode-defs.jl (bytecode-ref): new function 2000-08-02 John Harper * rep/module-system.jl (define-structures): new macro, for defining >1 structure from the same set of definitions * rep/vm/compiler/modules.jl (module-exports-p): handle first-class structures in imports list 2000-08-01 John Harper * rep/io/file-handlers/tar.jl, rep/io/file-handlers/remote/rep.jl, rep/io/file-handlers/remote/rcp.jl, rep/io/file-handlers/remote/ftp.jl, rep/util/base64.jl: don't use 0NN octal syntax 2000-07-31 John Harper * rep.jl: always define _ * unscheme.jl, scheme.jl, scheme/syntax-funs.jl: export \#define as %define, then use this for `define' forms * rep/data/symbol-table.jl, rep/io/file-handlers.jl, rep/util/gaol.jl: use structure-define instead of structure-set * rep/user.jl: setq creates bindings in this structure * rep/vm/compiler/unscheme.jl, rep/vm/compiler/scheme.jl, rep/vm/compiler/rep.jl: use %define instruction * rep/vm/compiler/modules.jl (compile-structure-def): don't drop unknown configuration items * rep/vm/disassembler.jl, rep/vm/bytecode-defs.jl (%define): new instruction * rep/lang/interpreter.jl (#f, #t): set to '() and 't respectively * rep/lang/interpreter.jl, rep/lang/math.jl, rep/lang/define.jl, rep/lang/data.jl, rep/lang/module-system.jl: use %define to create definitions * rep/lang/module-system.jl: new clauses `(set-binds)' and `(export-all)' in module configuration language 2000-07-30 John Harper * dump.jl: deleted this file, it needs a lot of attention before being useful again.. * unscheme.jl, scheme.jl, scheme/syntax-funs.jl, scheme/data.jl, unscheme/data.jl: various changes for distinct () object. This means that the scheme implementations no longer have to confuse 'nil and '() * rep/vm/compiler/const.jl (compile-constant): check for '() not 'nil when emitting `nil' instruction * rep/lang/interpreter.jl: (defconst `nil' ()) and (defconst t t), exporting both of them * rep/user.jl: call this structure `user', not `rep.user' * rep/vm/compiler/rep.jl (compile-list*): compile `list*' forms into a sequence of `cons' instructions * rep/vm/compiler/unscheme.jl, rep/vm/compiler/scheme.jl: use rep list* compiler 2000-07-29 John Harper * rep/vm/compiler/rep.jl (compile-apply): compiles `apply' calls * rep/vm/disassembler.jl, rep/vm/bytecode-defs.jl: new instruction `apply'. Bumped bytecode minor version * rep/vm/compiler.jl, rep/vm/compiler/unscheme.jl: support for unscheme language * unscheme.jl, unscheme/syntax.jl, unscheme/syntax-funs.jl, unscheme/misc.jl, unscheme/data.jl: _Another_ scheme implementation! This one intentionally ignores the Scheme standard where it helps the language fit the rep environment (see unscheme.jl for the details) * scheme/utils.jl: define and export #f and #t as themselves * scheme/syntax-funs.jl: don't depend on value of #f, just quote and return it where necessary * scheme/data.jl: no need for special `/'. Redefine symbol? to ignore #f and #t 2000-07-28 John Harper * rep/lang/define.jl (define-macro): new macro, similar to `define' but not quite so general * rep/util/repl.jl (repl): fixed bug when completing * scheme/misc.jl: export `load-file' as `load' 2000-07-27 John Harper * rep/util/repl.jl: core repl is now called for each line of input. Also functions to create repl state objects. Allows tricks like running a replicated repl on a remote system * rep/user.jl: handle --help option if seen 2000-07-25 John Harper * rep/util/base64.jl: more code borrowed from Jade that may be useful * rep/util/ispell.jl: ripped this code from Jade to provide a generally useful ispell interface 2000-07-24 John Harper * rep/vm/compiler/scheme.jl (compile-case): compile `case' forms, cut-n-pasted from the `rep' compiler * rep/vm/compiler/modules.jl (compiler-macroexpand-1): handle autoloading macros 2000-07-23 John Harper Wholesale reorganization of the lisp code, to support the new hierarchical module layout. Various other changes to support this. Also changed `case' to be a macro. * rep/user.jl: new location of user-startup code * rep/www/quote-url.jl, rep/www/fetch-url.jl: a couple of modules for doing www/url stuff * rep/vm/compiler/no-lang.jl: new compiler language module, supports the module configuration language, and nothing else * rep/util/autoloader.jl: new file, for doing generic autoloading of modules that provide arbitrary features * rep/data/objects.jl: new file, a macro for basic message-passing objects, with single inheritance of methods * rep/data/symbol-table.jl, rep/data/string-util.jl, rep/data/sort.jl, rep/data/ring.jl, rep/data/records.jl, rep/data/queues.jl: * rep/io/file-handlers/tilde.jl, rep/io/file-handlers/tar.jl, rep/io/file-handlers/remote.jl: * rep/io/file-handlers/remote/utils.jl, rep/io/file-handlers/remote/rep.jl, rep/io/file-handlers/remote/rcp.jl, rep/io/file-handlers/remote/ftp.jl: * rep/lang/profiler.jl, rep/lang/doc.jl, rep/lang/define.jl, rep/lang/debugger.jl, rep/lang/backquote.jl: * rep/mail/addr.jl: * rep/system/pwd-prompt.jl, rep/system/environ.jl: * rep/threads/utils.jl, rep/threads/mutex.jl: * rep/util/repl.jl, rep/util/memoize.jl, rep/util/gaol.jl, rep/util/date.jl: * rep/vm/disassembler.jl, rep/vm/compiler.jl, rep/vm/bytecodes.jl, rep/vm/bytecode-defs.jl: * rep/vm/compiler/utils.jl, rep/vm/compiler/src.jl, rep/vm/compiler/scheme.jl, rep/vm/compiler/rep.jl, rep/vm/compiler/opt.jl, rep/vm/compiler/modules.jl, rep/vm/compiler/lap.jl, rep/vm/compiler/inline.jl, rep/vm/compiler/const.jl, rep/vm/compiler/bindings.jl, rep/vm/compiler/basic.jl, rep/vm/compiler/asm.jl: * rep/www/cgi-get.jl: * scheme/utils.jl, scheme/syntax.jl, scheme/syntax-funs.jl, scheme/misc.jl, scheme/data.jl: New locations for these old files. Many have aliases so the old names still work * rep.jl, rep/system.jl, rep/structures.jl, rep/lang.jl, rep/lang/interpreter.jl, rep/lang/math.jl, rep/module-system.jl, rep/data.jl, rep/io/streams.jl, rep/io/files.jl, rep/io/file-handlers.jl: bootstrap code for the various modules in the new configuration * tilde.jl, threads.jl, tar-file-handler.jl, symbol-table.jl, string-util.jl, sort.jl, scheme-utils.jl, scheme-syntax.jl, scheme-syntax-funs.jl, scheme-misc.jl, scheme-data.jl, ring.jl, rep-repl.jl, rep-packages.jl, rep-autoload.jl, remote.jl, remote-utils.jl, remote-rep.jl, remote-rcp.jl, remote-ftp.jl, records.jl, queues.jl, pwd-prompt.jl, profiler.jl, mutex.jl, memoize.jl, mailaddr.jl, lisp-doc.jl, init.jl, gaol.jl, environ.jl, disassembler.jl, define.jl, debug.jl, date.jl, compiler.jl, compiler-utils.jl, compiler-src.jl, compiler-scheme.jl, compiler-rep.jl, compiler-opt.jl, compiler-modules.jl, compiler-lap.jl, compiler-inline.jl, compiler-const.jl, compiler-bindings.jl, compiler-basic.jl, compiler-asm.jl, cgi-get.jl, bytecodes.jl, bytecode-defs.jl, backquote.jl, autoload.jl: deleted or moved to a deeper position 2000-07-21 John Harper * rep-repl.jl, rep-packages.jl, init.jl, gaol.jl, symbol-table.jl: updated for removal of `%' from some function names * init.jl (define-structure-alias): new macro * compiler.jl, compiler-utils.jl, compiler-scheme.jl, compiler-rep.jl, compiler-opt.jl, compiler-modules.jl, compiler-inline.jl, compiler-basic.jl: reorganized some modules * compiler.jl (compile-directory): Recurse into subdirectories 2000-07-20 John Harper * version 0.12.4 * rep-repl.jl (repl): fixed bug of not prompting for continuation lines when a whole form isn't read 2000-07-19 John Harper * compiler-rep.jl (trans-defvar): call make-variable-special on the symbol (but this is still broken..) 2000-07-18 John Harper * lisp-doc.jl (documentation): only try to deref SYMBOL if it's bound (otherwise interpreted code may fall over?) * gaol.jl: store all state in gaol, don't keep it locally then rebuild the gaol from that. Deprecated some old functions, new interface is basically gaol-define, gaol-define-special, gaol-define-file-handler. Also added gaol-open * compiler-modules.jl: signal errors when trying to reference unknown structures 2000-07-16 John Harper * gaol.jl (gaol-safe-functions): added more safe functions 2000-07-15 John Harper * gaol.jl (make-gaol): install a null virtual machine 2000-07-14 John Harper * compiler-utils.jl (declare-inline): handler for `(declare (inline NAMES...))' marking functions that should be inlined (remember-function): optional arg BODY, so that functions previously declared inline can be stored * compiler-rep.jl (do-pass-1): pass defun bodies to remember-function, in case they've been declared inline (do-pass-2): defsubst forms are compiled as defuns now * compiler-modules.jl (variable-stem): new function to extract the local name of a variable * compiler-basic.jl (compile-form-1): removed code to check for 'compile-inline property. This was totally bogus after the module system arrived * compiler-inline.jl (compile-inline-function): deleted * init.jl (defsubst): just an alias for defun now * init.jl (throw): now in lisp (raise-exception): deleted, now in C 2000-07-12 John Harper * define.jl (define-scan-form): don't expand let-fluids forms since compiler handles them specially * version 0.12.3 2000-07-11 John Harper * define.jl (define-scan-form): expand macros one at a time, checking the results for things that shouldn't be expanded * compiler-modules.jl (compiler-macroexpand-1): set macro-environment to compiler-macroexpand-1, not compiler-macroexpand * init.jl (let): don't wrap named lets expansions in a progn block anymore, the misfeature being worked around is fixed now 2000-07-09 John Harper * lisp-doc.jl (doc-file-ref): pass `no-lock' flag to gdbm-open * rep-repl.jl (repl): only catch end-of-stream errors when reading, not when evaluating * init.jl (setcar, setcdr): no longer pseudonyms for rplaca and rplacd (they return the inserted value, not the cell) * compiler-rep.jl: removed code making setc[ad]r compile as rplac[ad] 2000-07-08 John Harper * compiler-modules.jl (compile-structure-def): compile bodies of non-top-level structures (so they can access their environment) * init.jl (catch, unwind-protect, condition-case): these are all now macros (in terms of call-with-catch, call-with-unwind-protect and call-with-error-handlers respectively. These functions are written in terms of the call-with-exception handler primitive). This has no effect on compiled code * rep-packages.jl, gaol.jl (call-with-catch, call-with-unwind-protect, call-with-error-handlers): added 2000-07-07 John Harper * rep.jl (rep): do the file-exists-p test when loading scheme scripts * mutex.jl, disassembler.jl, date.jl, cgi-get.jl, bytecodes.jl: use define-structure instead of structure 2000-07-05 John Harper * rep.jl: load-all "autoload" not "autoload.jl" 2000-07-03 John Harper * gaol.jl (gaol-safe-functions): added define-value 2000-06-29 John Harper * define.jl (define-scan-form): fix bug when extracting doc strings and interactive decls 2000-06-27 John Harper * profiler.jl: front-end for a basic profiler * rep-repl.jl: added `,profile FORM' command 2000-06-25 John Harper * ring.jl (ring->list): new function 2000-06-23 John Harper * ring.jl: encapsulate rings in datums, cleaned up the api (added ring-append, ring-ref, ring-replace. ring-ref counts from zero unlike the old get-from-ring), no longer uses macros for inlining 2000-06-22 John Harper * version 0.12.2 * compiler-inline.jl (compile-tail-call): when modifying bindings in-place, remember to emit a `pop-all' instruction if the value stack is non-empty * init.jl (member-if): new function 2000-06-21 John Harper * compiler-rep.jl (compile-list): if (= #args 0) emit `push nil' instead of `list #0' (also fixes a bug of stack use not being incremented with zero args) 2000-06-19 John Harper * compiler-rep.jl (do-pass-2): don't evaluate constants, pass-1 doesn't * init.jl (defconst): don't evaluate constants (the compiler doesn't) * dump.jl, disassembler.jl, compiler-utils.jl, bytecode-defs.jl: s/0x/#x/ and s/0[0-9]/#o[0-9]/ * gaol.jl: can now create multiple gaols (though each has the same default contents). This allows gaolled code to defun to its heart's content without affecting anything else. New function make-gaol returns a gaol (a structure), gaol-eval and gaol-load optionally take a gaol as their second arg * tar-file-handler.jl: when reading files from (non-huge) tar archives unpack the entire contents. This unpacked version is kept around for a while to service subsequent reads to other files in the same archive (this is a huge win when reading compressed sawfish themes) 2000-06-18 John Harper * version 0.12.1 * compiler-rep.jl (compile-declare): push `nil' onto the stack (since all forms are assumed to leave a value on the stack) 2000-06-16 John Harper * version 0.12 2000-06-14 John Harper * define.jl (define): strip leading progn's from expanded bodies of defines that expand to defuns (so that doc strings etc are visible) 2000-06-10 John Harper * compiler-opt.jl (peephole-optimizer): remove some zero additions and subtractions 2000-06-09 John Harper * init.jl: added some more doc strings 2000-06-08 John Harper * records.jl (record-printer): if the value returned from the discloser function is a string, print it without surrounding quotes * records.jl (define-record-type): removed the NAME argument, it's not very useful, and conflicts with the definition in SRFI 9 (http://srfi.schemers.org/srfi-9/) 2000-06-07 John Harper * compiler-basic.jl (compile-lambda): when adding doc strings, don't concatenate lambda-doc onto actual doc, add two separate items to the database * lisp-doc.jl (doc-file-ref, doc-file-set): functions to access doc files (add-documentation-params): store a parameter-list for a named function in the doc file * compiler-opt.jl (peephole-optimizer): when threading jmp instructions, ignore instructions that wouldn't change (fixes a non-termination case) * compiler-opt.jl (constant-optimizer): remember to update constant-index so that the resulting vector contains no unused entries 2000-06-05 John Harper * compiler-modules.jl (compile-top-level-structure, compile-top-level-define-structure): new exported functions * compiler-rep.jl: leave top-level structure definitions unexpanded in output * rep-repl.jl (,load-file): will now load more than one file * scheme.jl, scheme-utils.jl, scheme-syntax-funs.jl, scheme-misc.jl, scheme-data.jl, compiler-scheme.jl: prefix most exported non-r4rs symbols by `#' (not allowed in scheme identifiers) * compiler-modules.jl (compile-structure-ref): check open-modules for structure being referenced as well * scheme-data.jl (symbol?): (symbol? '()) => #f (string->symbol): copy the name if a symbol needs to be created and interned * define.jl (define-scan-form): don't mistake (let () ..) for a named let 2000-06-04 John Harper * rep-repl.jl (rl-completion-generator): fix from Ceri to prepend `^' to start of word, also quote the word being completed * define.jl (define-scan-form): don't expand `structure-ref' forms * compiler-rep.jl: merge `normal' top-level forms into progn statements in pass-1, which then get compiled in pass-2 * compiler-modules.jl (compile-structure-def): leave `open' and `access' config statements as-is * compiler-basic.jl (macroexpand-pred): used to stop expanding macros when a form with a special compiler is found * compiler-modules.jl (parse-interface): fix typo * scheme.jl: no need to export %while anymore * compiler-utils.jl (compiler-constant-p, compiler-constant-value): anything that isn't a cons or a symbol is now treated as a (self-evaluating) constant, mainly to allow #f and #t to be constant-folded * compiler-scheme.jl: enabled constant folding support * compiler-modules.jl: pass-1 and pass-2 functions now take and return the complete list of forms, not just one at a time * compiler-scheme.jl, compiler-rep.jl (pass-1, pass-2): operate on the entire body in one go 2000-06-02 John Harper * init.jl (fluid-let): renamed as `let-fluids'. Updated all users * rep-repl.jl: removed *repl-in-struct* defvar, replaced by fluid repl-in-struct 2000-06-01 John Harper * rep-repl.jl (rl-completion-generator): new function, generates completions for readline (from Ceri Storey ) * compiler-basic.jl (compile-form-1): don't call test-function-call if the form has a special handler * compiler-rep.jl: handle non-top-level declarations * compiler-bindings.jl: support (declare (bound VARS...)) and (declare (special VARS...)) to flag variable bindings that the compiler would otherwise be unaware of * remote-ftp.jl, disassembler.jl, compiler-utils.jl: added declarations to prevent warnings for jade-only functions * backquote.jl (backquote-listify): don't call `eval' to unquote constants, use a special purpose backquote-eval to avoid security breaches * scheme-syntax-funs.jl: new file, defines expand-FOO functions for each non-trivial Scheme syntax form. Since nothing is redefined here, doing this removes the need for the gratuitous rep# and hand-expanded macros * scheme-syntax.jl: most macros just call expand-FOO * init.jl (make-guardian): use a rest argument in the returned closure so that `(G nil)' can be distinguished from `(G)' * init.jl (call-after-load): new function, eval-after-load just calls this now 2000-05-31 John Harper * init.jl (with-object): new macro, uses call-with-object * compiler-rep.jl (with-object): flushed compiler for this special form * disassembler.jl, bytecode-defs.jl (bindobj): flushed this insn * init.jl (prog1): new macro, in terms of lambda 2000-05-30 John Harper * init.jl (while): new macro, basic tail-recursive definition * define.jl (define-scan-form): removed `while' from the list of special forms 2000-05-27 John Harper * scheme-misc.jl, records.jl, queues.jl: updated for datum printer interface 2000-05-26 John Harper * compiler-src.jl (coalesce-constants, mash-constants): new functions, in preparation for more constant optimizations * lisp-doc.jl (describe-lambda-list): new function * compiler-scheme.jl: list? no longer == listp * compiler-basic.jl (compile-lambda): add the argument spec to the front of any doc string * scheme-data.jl (boolean?): fixed (list?): no longer equivalent to rep's listp, scheme standard says this must only return #t if its last cdr is the empty list (string-ci>?): fixed * init.jl (lcm): handle 0...N args 2000-05-25 John Harper * compiler-basic.jl (compile-lambda-spec): if the spec contains special variables, don't encode it (compile-lambda): don't error out if special variables in spec * compiler-rep.jl: added special handlers for `defun' and `defmacro', otherwise non-top-level calls to these macros don't get compiled properly * rep-repl.jl: added `,time' command * lisp-doc.jl (describe-value): don't check for calls to jade-byte-code * init.jl (eval-after-load): don't use `&aux' * dump.jl: don't `set' lexical variables * disassembler.jl: understand new opcodes, new parameter list encoding * debug.jl: updated for new lexical environment structure (of interpreted code) * compiler.jl (compile-form): generate calls to `run-byte-code' instead of `jade-byte-code' * compiler-utils.jl (remember-function): don't `set' lexical variables (get-lambda-vars): ignore `&aux' keys * compiler-src.jl (fold-constants): use `compiler-symbol-value' instead of `eval' to dereference functions * compiler-rep.jl: don't compile calls to `eval' (compile-condition-case): changed this for the modified semantics of the `errorpro' instruction (doesn't require name of variable to bind, always binds the next lexical slot) * compiler-opt.jl: added some peephole patterns for changing simple constant add and subtract sequences into `inc' or `dec' instructions * compiler-inline.jl: removed all support for `&aux' keyword * compiler-bindings.jl (emit-binding): don't emit arg when binding lexically * compiler-basic.jl (compile-lambda): generate the new-style byte code subrs (with parameter spec encoded as a fixnum) * bytecode-defs.jl: deleted `eval', `bind' is now arg-less (and uses the old eval opcode) * bytecodes.jl (byte-insns-with-constants): removed `bind' 2000-05-23 John Harper * scheme-misc.jl (eof-object?): fixed to return #f or #t * compiler-scheme.jl: code and properties to piggyback the rep compiler for predicates that just needs boolean results translated * compiler-opt.jl: delete `test-scm[-f]; scm-test' pairs of instructions * bytecodes.jl, bytecode-defs.jl, disassembler.jl (test-scm, test-scm-f): new instructions, map from rep booleans to scheme booleans * rep.jl: option aliases: --call -> -f, --load -> -l, --quit -> -q New option --scheme,-s to load a file of Scheme code * scheme.jl, scheme-misc.jl: export %load-suffixes * scheme-syntax.jl (delay): don't use `rep#lambda' in expansion, probably not available in caller's environment * scheme-misc.jl (write-char): use `rep#write', not `write' (load): removed this definition, must use the subr (so the file is loaded in the caller's environment..) * compiler-modules.jl (compile-module-body): remember to create a binding of `current-language' 2000-05-22 John Harper * scheme-syntax.jl (cond): now expands into an `if' chain, this is to enable simple handling of `(TEST => FUNCTION)' syntax (case): remember to add the key to the expansion * scheme-misc.jl (close-input-port, close-output-port): detect and ignore files that have already been closed * scheme-data.jl (char?): defined and exported (complex?): always returns #t not #f (string->number): defined using make-nil-predicate * memoize.jl (memoize-function): renamed as `memoize' and removed the code to work on symbol values 2000-05-17 John Harper * debug.jl: added `up' and `down' commands; catch errors during `print' commands * compiler-rep.jl (compile-fluid-let): re-enabled this, the segmentation faults it used to cause seem to have mysteriously disappeared 2000-05-16 John Harper * debug.jl (error-entry): make this work again * init.jl (default-error-handler): new function, stuffed into error-handler-function * rep.jl, rep-repl.jl: call default-error-handler or error-handler-function to print errors 2000-05-15 John Harper * gaol.jl: added some more safe functions * date.jl, remote-ftp.jl, remote-rep.jl, tar-file-handler.jl: use string->number to parse numbers, not read-from-string (otherwise e.g. 08 causes a read error) * scheme-data.jl (string->number, number->string): deleted, use built-in versions of these functions * debug.jl: adapted for new return from debug-frame-environment (but this doesn't work 100%?) 2000-05-14 John Harper * init.jl (and): fixed bug `(and 1 nil) => 1' * compiler-modules.jl (compile-module): added interactive spec 2000-05-13 John Harper * compiler-rep.jl: compile `=' using num-eq insn (compile-case): use memql and eql for comparisons instead of memq and eq * bytecode-defs.jl, disassembler.jl (memql, num-eq): new insns * scheme-data.jl (memv): defined by wrapping memql 2000-05-12 John Harper * lisp-doc.jl (apropos-output, apropos-function, apropos-variable, describe-variable, describe-variable-1, describe-function): deleted these functions, they're all useless since they call symbol-value (from the wrong structure) (describe-function-1): renamed describe-value, takes two args VALUE and NAME (optional), then describes the value to standard-output. Handles both functions and variables (documentation): added optional second arg VALUE, the value of the symbol in the caller's environment * rep-repl.jl: added `,describe' and `,apropos' commands, removed `,doc' 2000-05-11 John Harper * init.jl (or, and): implement base cases explicitly, (or) => nil, (and) => t * scheme-syntax.jl (and): add base case (and) => #t * init.jl (structure, define-structure): INTERFACE is now optional * init.jl, compiler-modules.jl (%parse-interface, parse-interface): accept `()' as null interface 2000-04-30 John Harper * string-util.jl (mapconcat): new function 2000-04-28 John Harper * records.jl: detect and report unknown fields 2000-04-24 John Harper * rep-repl.jl: new commands `,compile' and `,compile-proc' * init.jl, scheme.jl, scheme-data.jl: added cons accessors c....r * compiler.jl: export compile-module (compile-function): ignore already compiled functions, don't signal an error. And fix the method of testing for compiledness * compiler-modules.jl (compile-module): new function, compile all non-compiled functions in a named structure 2000-04-23 John Harper * records.jl: implements record-like data structures. Based on the Scheme48 record interface 2000-04-22 John Harper * compiler.jl (compile-function): this now works properly since it respects the structure that the closure is made in * compiler-utils.jl (compiler-constant-p): don't check that the `quote' symbol is from the `rep' structure (kludge) * compiler-scheme.jl, compiler-rep.jl: at top-level, splice in `begin' and `progn' forms, allows macros to expand to blocks of top-level definitions * compiler-modules.jl: track the current language being compiled, also provides a means for telling the compiler which module is being compiled in * compiler-basic.jl (compile-lambda): removed the SEQUENCER arg, use the compiler-sequencer language property * compiler-utils.jl (compiler-constant-p, compiler-constant-value): accept all numeric types * compiler-const.jl (compile-constant): only emit fixnums using immediate push insns 2000-04-21 John Harper * queues.jl: new file, implement the scheme48 queue interface * init.jl (fluid-let): new macro * debug.jl: rewritten to use fluid instead of special variables * bytecode-defs.jl, disassembler.jl (fluid-ref, fluid-set, fluid-bind): new insns * compiler.jl, compiler-vars.jl, compiler-utils.jl, compiler-src.jl, compiler-scheme.jl, compiler-rep.jl, compiler-opt.jl, compiler-modules.jl, compiler-lap.jl, compiler-inline.jl, compiler-const.jl, compiler-bindings.jl, compiler-basic.jl: rewritten to use fluid instead of special variables * symbol-table.jl: new file, wrapper around anonymous structures for efficient symbol tables * init.jl (realp, rationalp, inexactp): new functions 2000-04-18 John Harper * compiler.jl, compiler-vars.jl, compiler-utils.jl, compiler-rep.jl, compiler-inline.jl: track the maximum depth of the binding stack while compiling forms, then embed this into the `stack' property of byte code forms/subrs * disassembler.jl: groks the new layout of the `stack' arg 2000-04-17 John Harper * scheme-misc.jl (input-port?, output-port?, peek-char): implemented properly now * init.jl (streamp): in lisp now * compiler-modules.jl (compiler-symbol-value): this now recognizes autoload values, loading them before returning 2000-04-16 John Harper * scheme-syntax.jl (lambda): now scans out leading internal defines into a letrec * compiler*.jl: track which lexical bindings have been modified and which have been captured by closures, then use this information to optimize tail recursion. Also renamed a load of compiler functions to get rid of needless `comp-' prefixes * define.jl, scheme-syntax.jl (define): now supports curried functions, e.g. (define ((plus a) b) (+ a b)), then (plus 1) evaluates to the function that adds one to its argument 2000-04-15 John Harper * gaol.jl: don't need to build trampoline code anymore, can just use %eval-in-structure * compiler-rep.jl (compile-save-environment): deleted * bytecode-defs.jl, disassembler.jl: removed `bindenv' instruction * gaol.jl: updated for special environment being stored with the structure 2000-04-14 John Harper * disassembler.jl, bytecode-defs.jl: removed `dset' bytecode * compiler-basic.jl (comp-compile-lambda): when noting the parameter bindings, reverse the list * bytecode-defs.jl: bumped major version to 10 (unbindall-0, pop-all): new instructions * disassembler.jl: updated for new insns * scheme-syntax.jl (do): implemented using named let, not while, since the Scheme report requires that each iteration get new bindings for each variable * init.jl (do): implemented this iteration syntax from Scheme, expands to a named let * compiler-inline.jl (comp-do-tail-call): don't just setq the new values of the variables, create wholly new bindings (in case the previous bindings have been captured by any closures) 2000-04-12 John Harper * gaol.jl: updated for new set-file-handler-environment semantics * rep-repl.jl: added commands `,step' and `,expand'. `,help' now prints two columns * debug.jl: now works with the module system * init.jl, compiler-modules.jl: changed module definition syntax, the config section is now a single form or list of forms, instead of the kludge of extracting them from the head of the module body. This way no extra indentation is introduced for the body. Existing modules only need changing if they have more than one config form * scheme.jl, scheme-syntax.jl, scheme-misc.jl, scheme-data.jl: updated for new module configuration syntax 2000-04-11 John Harper * remote-rep.jl, remote-ftp.jl: export all interactive functions * init.jl (let): fixed bug of interpreting (let () ..) as a named let (due to (symbolp '())) 2000-04-10 John Harper * rep-packages.jl (rep-files-interface): added jade-only file operations (since they need to be in the `rep' structure) * init.jl (eval-and-print): deleted, probably evals in the wrong structure for most uses 2000-04-09 John Harper Changes to make sawmill work with the module system, and to make things in general work more smoothly * init.jl: set `*root-structure*' to rep (declare): macro to ignore declarations (defsubst): put the actual function body in the `compiler-inline' property * compiler.jl, compiler-vars.jl, compiler-utils.jl, compiler-rep.jl, compiler-modules.jl, compiler-inline.jl: various compiler fixes/improvements to make things work largely as they did before (!) Also now supports top-level declarations, currently only `(declare (in-module FOO))' to tell the compiler where to look for bindings outside any actual module definition * rep.jl: set `*root-structure*' to user * gaol.jl: removed support for redefining `require', miscellaneous fixes * define.jl: reverted to handling all let forms specially, macroexpanding them prevents the compiler doing some optimizations * threads.jl, string-util.jl, sort.jl, rep-repl.jl, rep-packages.jl, environ.jl, define.jl, debug.jl, backquote.jl: added `(in-module rep)' declaration 2000-04-07 John Harper Many changes to support the new module system: * init.jl: subsumes lisp.jl, defines all module syntax (define-interface, structure, define-structure, etc..), defconst now declares _lexically_ scoped constants * rep-packages.jl: defines the various interfaces that the rep package implements, plus other basic structures * rep-repl.jl: implements the default repl, borrows Scheme48's idea of using `,' to introduce meta-commands (e.g. to control and inspect the state of the module system) * rep.jl: use the new repl; try to work out when to `require' and when to `load' command line options * rep-autoload.jl, autoload.jl: split autoloading into two parts, rep-autoload contains decls for the `rep' module, autoload contains those for the default user module * gaol.jl: modularized; uses an anonymous structure to create the sandboxed environment * bytecodes.jl, bytecode-defs.jl: split into two modules, no longer exports op-FOO constants, instead a macro `(bytecode FOO)' * compiler.jl, compiler-vars.jl, compiler-utils.jl, compiler-src.jl, compiler-scheme.jl, compiler-rep.jl, compiler-opt.jl, compiler-modules.jl, compiler-lap.jl, compiler-inline.jl, compiler-const.jl, compiler-bindings.jl, compiler-basic.jl, compiler-asm.jl: the compiler has now been modularized; it also groks the module configuration forms, and can compile for whatever base language (rep, scheme, ..?) a module is actually using. Scheme support is currently minimal (working but sub-optimal code) * scheme.jl, scheme-utils.jl, scheme-syntax.jl, scheme-misc.jl, scheme-data.jl: support for interpreting scheme code, any modules with `(open scheme)' instead of `(open rep)' will find a minimal r4rs scheme environment (without macros) * tilde.jl, tar-file-handler.jl, remote.jl, remote-utils.jl, remote-rep.jl, remote-rcp.jl, remote-ftp.jl: updated to use new method of declaring file handlers (the define-file-handler function) * ring.jl, mutex.jl, memoize.jl, lisp-doc.jl, disassembler.jl, date.jl, cgi-get.jl: modularized * define.jl: macroexpand fully, then just scan through lambda bodies 2000-04-13 John Harper * version 0.11.3 2000-04-11 John Harper * init.jl (let): fixed bug of interpreting (let () ..) as a named let (due to (symbolp '())) 2000-04-09 John Harper * version 0.11.2 2000-03-29 John Harper * compiler.jl (compile-file): prevent top-level macro expansions being expanded again if we want to see them in their original form * lisp.jl (define-value): support non-constant variable forms.. but for how long..? * lisp.jl (defmacro, defun, defconst, define-value): now macros * compiler.jl (comp-compile-defun, comp-compile-defmacro): deleted 2000-03-24 John Harper * remote-ftp.jl: some lisp-1 fixes 2000-03-21 John Harper * lisp.jl (call-with-current-continuation): just define-value to the value of call/cc instead of using a lambda * gaol.jl (gaol-safe-functions): added case 2000-03-20 John Harper * mutex.jl: fixed some stupid typos (by Damon Anderson ) 2000-03-14 John Harper * lisp.jl (prog2): now a macro * compiler.jl (comp-compile-prog2): deleted * lisp.jl (setq-default): now a macro * compiler.jl (comp-trans-setq-default): deleted * lisp.jl (dynamic-wind): defined in terms of call-with-barrier * lisp-doc.jl (describe-function-1): handle macros, improper parameter lists; some cosmetic improvements 2000-03-13 John Harper * compiler.jl (compile-file): only expand macros if the form wouldn't be compiled anyway (comp-trans-if, comp-trans-and, comp-trans-or): deleted (comp-compile-let): deleted * lisp.jl (let, let*): now defined as macros, `let' supports Scheme's named lets for iteration (if, and, or, function): defined as macros * define.jl: only expand macros when absolutely necessary; handle named lets; handle multi-action setq and setq-default forms 2000-03-12 John Harper * version 0.11.1 2000-03-11 John Harper * lisp.jl (load-all): added back the restriction of not loading from the current directory * compiler.jl (compile-file): copy permissions from source to dest file 2000-03-10 John Harper * compiler.jl: compile (null X) using `not', instead of `null' 2000-03-09 John Harper * compiler.jl: non-trivial changes to make the compiler eliminate intra-function tail recursion. Also fixed some bugs when handling defsubst's * compiler-opt.jl: modified `jmp X; ... Y: --> jmp X; Y:' pattern to handle `return' instructions as well as gotos, and to delete until the end of the instruction stream if no subsequence label. Also fixed bug stopping the optimization being applied 2000-03-08 John Harper * compiler.jl (comp-compile-case): don't dup before the default branch 2000-03-05 John Harper * version 0.11 2000-03-04 John Harper * string-util.jl: new file, some string functions (case manipulation) * dump.jl: replaced most instances of integerp by fixnump 2000-03-01 John Harper * dump.jl: dump strings correctly again (still doesn't handle non-fixnum numbers though) * lisp-doc.jl: use GDBM instead of SDBM (no data size limits) 2000-02-29 John Harper * define.jl: bug fixes -- handle interactive decls and doc strings 2000-02-28 John Harper * define.jl (define-parse): remember in `(define FOO BAR)' to scan BAR for internal definitions 2000-02-27 John Harper * gaol.jl: added a load more safe functions to the list. Also allow `tables' to be required * compiler.jl: misc fixes for math stuff. Also fixed compilation of transitive comparisons (no guarantee they would evaluate all arguments previously) * bytecodes.jl, disassembler.jl: deleted op-numeq and op-num-noteq. op-lsh changed to op-ash 2000-02-25 John Harper * lisp.jl (positivep, negativep, oddp, evenp, abs, %, modulo, lcm): new functions (some are just pseudonyms) * bytecodes.jl (op-quotient, op-floor, op-ceiling, op-truncate, op-round, op-exp, op-log, op-sin, op-cos, op-tan, op-sqrt, op-expt): new instructions * compiler.jl: generate code for math functions * diassembler.jl: grok the math functions * sort.jl, date.jl: use `quotient' instead of `/' 2000-02-20 John Harper * compiler.jl: remember that define-value defines lexical variables. When compiling files, don't read-and-macroexpand in both passes, just the first, storing the results for input to the second pass 2000-02-19 John Harper * threads.jl (with-threads-blocked): now autoloaded * gaol.jl (gaol-safe-functions): added define and with-internal-definitions 2000-02-17 John Harper * lisp.jl (load-all): remove the (broken) restiction on not loading from the current directory * lisp.jl (prin1-to-string, read-from-string, setcar, setcdr, string=, string<, caar, cadr, cadr, cdar, cdar, cddr, cddr, caddr, caddr, call-with-current-continuation): changed these from macros to functions * compiler.jl (caar, cadr, cadr, cdar, cdar, cddr, cddr, caddr, caddr, setcar, setcar, setcdr, setcdr, string=, string=, string<, string<): generate single instructions for these functions * remote-rep.jl: make this work again 2000-02-10 John Harper * gaol.jl: added macro-environment to safe specials * define.jl (with-internal-definitions): new macro, scans its body for internal defines (define-scan-form): fixed scanning `case' forms 2000-02-09 John Harper * lisp.jl (autoload-macro): new function 2000-02-08 John Harper * compiler.jl (comp-compile-case): fixed this, wasn't dup'ing the key before each comparison, only before the first * define.jl: now that macros can find the macro environment they were invoked through, it's possible to implement this properly, scanning out define's from all suitable forms automatically * compiler-opt.jl (comp-peephole-opt): fix typo in `jt X; nil --> jpt X' pattern 2000-02-06 John Harper * mutex.jl: new file, moved the mutexes from threads.jl * threads.jl (with-threads-blocked): new macro * disassembler.jl, compiler.jl, bytecodes.jl: new instructions op-permit, op-forbid * threads.jl: removed the thread functions, they're in C code now 2000-02-03 John Harper * compiler.jl (compile-file): write a newline character at the end of the output file 2000-02-01 John Harper * memoize.jl (memoize-function): use `equal' hash-tables to cache results * define.jl (lambda*): macro similar to lambda, but scans out internal definitions * compiler.jl (comp-constant-function-p, comp-constant-function-value): expand macros before testing 2000-01-31 John Harper * lisp-doc.jl (documentation): fix for macro objects * define.jl: new file, scheme-like `define' macro * compiler.jl: handle improper lists in lambda expressions (i.e. (foo . bar) == (foo &rest bar)) 2000-01-30 John Harper * debug.jl: better support for debugging in lexical environments * compiler-opt.jl (comp-peephole-opt): added pattern `jt X; nil --> jpt X' * compiler.jl (compile-compiler): compile `sort.jl' as well (it's used by compiler-opt) * lisp-doc.jl (describe-function-1): dereference closures * threads.jl: first attempt at a (very basic) threading interface 2000-01-26 John Harper * lisp-doc.jl (describe-variable): remove reference to current-buffer (not used anyway) 2000-01-24 John Harper * compiler.jl (comp-compile-case): support the new `case' statement (similar to in scheme) * lisp.jl (when): expand to an if statement, not a cond. This makes `(when t)' behave consistently with `(if t)' (pointed out by Dave Pearson) * compiler-opt.jl (comp-peephole-opt): fix error when transforming `bind X; refn #0' --> `dup; bind X' 2000-01-23 John Harper * bytecodes.jl (op-return, op-unbindall): new instructions (for tail call elimination) * compiler.jl (compile-form): emit a return instruction at the end of each code string * compiler-opt.jl (comp-peephole-opt): new patterns to back-propagate return instructions, and remove unneeded unbind instructions * disassembler.jl: output the two new instructions 2000-01-22 John Harper * bytecodes.jl: new bytecode version 9.0 (op-refn, op-setn): lexical address instructions (op-refg, op-setg): global lexical instructions (op-bindspec): create a special binding (op-bind _always_ creates lexical bindings now) * compiler.jl: separately track lexical and special bindings, then generate code as required (i.e. use lexical addressing) * compiler-opt.jl (comp-peephole-opt): updated to grok the new instructions * disassembler.jl: updated for new instructions 2000-01-14 John Harper * gaol.jl: removed redefinition of make-timer, added it to list of safe functions (since we are a lisp-1) 2000-01-12 John Harper * memoize.jl (memoize-function): wrap a function with a cache (needs a hash-table implementation to be useful..) * tar-file-handler.jl: use a guardian to allow finalization of file handles * remote.jl (remote-register-file-handle): new function, uses a guardian and a function in the after-gc-hook to correctly finalize open remote files when they are garbage collected * remote-ftp.jl, remote-rep.jl: register file handles for finalization * lisp.jl (make-guardian): new function, a means for protecting objects from being deallocated when they have no references src/2000-01-09 John Harper * version 0.10 2000-01-03 John Harper * compiler.jl (comp-compile-defun, comp-compile-defmacro): remember the functions being defined 1999-12-31 John Harper * tilde.jl: added provide decl * lisp.jl (featurep, provide, require): removed (in C again) (autoload): a function again * init.jl: require libraries instead of loading (in case they've been dumped) * dump.jl: updated for lisp-1 rep with closures 1999-12-22 John Harper * compiler.jl (comp-trans-setq, comp-trans-setq-default): signal an error if an odd number of arguments is given 1999-12-12 John Harper * version 0.9 * disassembler.jl (disassemble): escape all control codes when printing, not just newlines 1999-12-11 John Harper * date.jl (parse-date): fix calculation of day-of-week * bytecodes. (op-caar, op-cadr, op-cdar, op-cddr, op-caddr, op-cadddr, op-caddddr, op-cadddddr, op-caddddddr, op-cadddddddr): new instructions * disassembler.jl, gaol.jl: added c..r instructions * compiler.jl: optimise constant index nth and nthcdr calls to single c...r instructions where possible * compiler-opt.jl (comp-peephole-opt): fixed optimisation looking for `const; const|dup...' (comp-peephole-opt): optimise pairs of car or cdr instructions to a single instruction * lisp.jl (caar, ..., cddr, caaar, ..., cdddr): new functions 1999-12-10 John Harper * rep.jl, debug.jl: use proper readline * lisp.jl (in-hook-p): new function (add-hook): if variable is unbound, make it special before setting it 1999-12-07 John Harper * disassembler.jl, compiler.jl, bytecodes.jl (op-enclose): new instruction * lisp.jl (unless): if the condition evaluates true, then return nil, not the value of the condition (this is the behaviour in cl and elisp) 1999-12-06 John Harper * lisp.jl (letrec): new macro, as in scheme, creates mutually recursive bindings 1999-12-05 John Harper * version 0.8.1 1999-11-29 John Harper * lisp-doc.jl, compiler.jl: fixed the documentation functions for unified namespace 1999-11-28 John Harper * version 0.8 1999-11-25 John Harper * tilde.jl, tar-file-handler.jl, sort.jl, rep.jl, remote-rep.jl, remote-rcp.jl, remote-ftp.jl, lisp.jl, lisp-doc.jl, gaol.jl, environ.jl, dump.jl, disassembler.jl, debug.jl, compiler.jl, compiler-opt.jl, cgi-get.jl, bytecodes.jl, backquote.jl, autoload.jl: updated for single namespace and scheme-like function semantics 1999-11-21 John Harper * gaol.jl (gaol-add-file-handler, gaol-replace-file-handler): new functions, allow access to be granted to file handlers without letting any operation be performed 1999-11-20 John Harper * lisp.jl (string-equal-p, string-less-p): deleted * compiler.jl (comp-test-funcall): check if a locally-bound function before warning that it's undefined 1999-11-18 John Harper * lisp.jl: unless it's already bound, make the _ function return it's sole argument (until redefined by gettext module) 1999-11-15 John Harper * gaol.jl: wrapped make-timer, rebuild function env after doing a safe require, rebuilding environment affects existing restricted environments 1999-11-11 John Harper * gaol.jl: new file, provides a restricted environment for untrusted code 1999-11-10 John Harper * disassembler.jl, compiler.jl, bytecodes.jl: handle lexically scoped functions (new opcodes and special forms). macrolet form is still unimplemented in compiled code * tar-file-handler.jl, remote-rep.jl, remote-ftp.jl: updated for lexical scoping * lisp.jl (features, featurep, provide, require): defined these in Lisp now (so they get enclosed) (function): this is now a special form 1999-11-01 John Harper * tar-file-handler.jl (tarfh-alternative-gnu-tar-programs): new variable, a list of alternative programs to check when looking for GNU tar 1999-10-24 John Harper * version 0.7 1999-10-17 John Harper * tar-file-handler.jl: read-only access to files stored in tar archives, access files like `foo.tar.gz#tar/bar'; still has some problems, but works well enough 1999-10-13 John Harper * rep.jl: don't add the current directory to the head of the load-path, it's already at the end of the path where it should be * lisp.jl (load-all): don't search in the current directory (since it's unpredictable) * compiler.jl: fix bug of `last' instruction being thought to require two arguments 1999-09-14 John Harper * version 0.6 * environ.jl (unsetenv): new function 1999-09-12 John Harper * version 0.5 1999-08-31 John Harper * version 0.4 1999-08-27 John Harper * dump.jl: changed for new string data layout 1999-08-22 John Harper * version 0.3 1999-08-21 John Harper * compiler.jl (compile-batch): new command line option `--write-docs' (comp-compile-top-form): remember any declared variables that haven't already registered, change the error on finding an unregistered constant to a warning 1999-08-16 John Harper * version 0.2 1999-08-03 John Harper * version 0.1 1999-07-22 John Harper * rep.jl (rep): clear the cached input when an error occurs * debug.jl (debug-rep): implements a proper terminal-based debugger loop 1999-07-07 John Harper * remote-rep.jl (remote-rep-read-length): fix this for large numbers 1999-07-06 John Harper * remote-rep.jl, remote-ftp.jl (remote-rep-lookup-file, remote-ftp-lookup-file): new functions, chase symbolic links until the actual file is found * remote-rep.jl: new file, mostly copied from remote-ftp, but uses the rep-remote program (rsh'd onto the remote host) for all file access. Supports all file operations (unlike ftp) * remote-ftp.jl (remote-ftp-host-user-alist, remote-ftp-default-user): deleted * remote.jl (remote-host-user-alist, remote-default-user): new variables (remote-get-user): new function 1999-07-04 John Harper * tilde.jl, remote-ftp.jl: handle new operations read-symlink and make-symlink (actually, ftp doesn't do make-symlink) * compiler.jl (compile-file): preserve `#! ... !#' at start of file if present 1999-07-02 John Harper * remote-ftp.jl (remote-ftp-empty-cache): new command 1999-06-09 John Harper * rep.jl (rep): don't use `read' to read an entire form at once, instead use `read-line' to read strings until there's enough to parse a whole form * pwd-prompt.jl (pwd-prompt): fixed to actually delete the line-terminating newline, also print a newline before exiting 1999-06-06 John Harper * compiler.jl: generate an intermediate form between Lisp forms and bytecodes, a list of instructions and labels. Then run an optimisation pass (peephole) over the intermediate code before assembling it to bytecodes * compiler-opt.jl: new file, implements the low-level optimisations. Does peephole and constant-vector layout optimisations * bytecodes.jl: op-setq now pops the value from the stack. Deleted op-pushi-pair, replaced by op-pushi-neg and op-pushi-pair-pos, for pushing negative and positive values respectively * disassembler.jl: updated for new opcodes * pwd-prompt.jl: new file, implement pwd-prompt function for the console 1999-06-03 John Harper * rep.jl: loading a script implies --batch (but not when loaded via the -l option). Don't print the banner until immediately before entering the read-eval-print loop 1999-05-27 John Harper * cgi-get.jl (cgi-get-params): new file, process the QUERY_STRING from a CGI get command 1999-05-15 John Harper * date.jl (date-day-of-week): new function, given date/day/month, gives the day of week (parse-date): accept ISO 8601 calendar format 1999-04-28 John Harper * compiler.jl (compile-batch): new function 1999-04-19 John Harper * compiler.jl (compile-file): minor fix to error handling 1999-03-30 John Harper * remote-ftp.jl (remote-ftp-chmod): make errors give a warning since some (many?) ftpd's don't support it and it's probably mostly harmless * compiler.jl (comp-compile-lambda): minor fix 1999-03-17 John Harper * rep.jl (rep): don't catch 'quit 1999-03-14 John Harper * rep.jl: add the current directory to the load-path 1999-03-12 John Harper * rep.jl: any bare command-line arguments are passed to load 1999-03-10 John Harper * compiler.jl (compile-file): ensure that the temporary output file is deleted 1999-03-07 John Harper * compiler.jl (comp-compile-lambda): only put the doc-string in the bytecode vector if it wasn't written to the db * lisp-doc.jl (documentation): only try to get the value of the function or variable if it's actually bound 1999-03-03 John Harper * rep.jl: print a message if unknown command-line options are encountered src/1999-02-28 John Harper * MAJOR CHANGES: separated all LISP interpreter specific parts into a separate library, librep (Read-Eval-Print) 1999-02-12 John Harper * tilde.jl: canonicalise the user-home-directory before comparing it against the original default-directory 1999-02-02 John Harper * compiler.jl (comp-push-label-addr): new function, replaces comp-get-label-addr (comp-write-raw-op): deleted this function 1999-02-01 John Harper * rm-mail-dir.jl (rm-mail-dir-auto-scan-hook): new hook 1999-01-31 John Harper * html-decode.jl: only underline links (anchors with href field). Add anchors to a list that's returned to the caller * html-display.jl (html-display-goto-anchor): new command * find-url.jl: support for anchors specified in URLs * bytecodes.jl: several pushi instructions * compiler.jl (comp-write-raw-op): new function (comp-compile-constant): use pushi instructions to compile integers where possible * disassembler.jl (disassemble): support pushi instructions 1999-01-28 John Harper * find-url.jl (find-file-as-url): new command * html-display.jl (html-display): if the given URL is nil, and the source buffer has a file name, set the URL to the file: version of the filename * html-decode.jl (html-decode): more bug fixes 1999-01-27 John Harper * mime-decode.jl (mime-encode-mmencode): new function, wrapper for the base64 and quoted-printable coders, if possible and desirable, then an external `mmencode' program is used to do the translation * find-url.jl, html-display.jl: fix which view to display in 1999-01-26 John Harper * rm-mime.jl: bind the `w' prefix in read-mail mode to the `html-display-map' * html-display.jl (html-display-current-link): search up the extent stack correctly (html-display-map): autoload'able * mime-decode.jl (mime-decode): handle `text/html' MIME parts by calling html-decode * html-decode.jl: more bug fixes 1999-01-25 John Harper * remote-ftp.jl (remote-ftp-close-all): new function (remote-ftp-close-host): made interactive 1999-01-24 John Harper * remote-ftp.jl: misc fixes to try and handle non-successful logins more gracefully; not 100% successful yet.. * ispell.jl (ispell-kill-process): keep looping while accept-process-output times out, not while it doesn't! * html-display.jl (html-display-select): handle URL's that are specified relative to the root of the current server 1999-01-22 John Harper * html-decode.jl: parse sections half-heartedly, and be slightly more clueful about unnested close tags 1999-01-21 John Harper * find-url.jl (find-url-file, find-url-ftp): detect if a file: URL contains HTML code, if so decode it * html-decode.jl (html-decode): bind html-decode-source and html-decode-point to the position of the next item to be parsed, called functions may then alter these (html-decode:script): skip