climacs-announce

climacs-announce@common-lisp.net

17 discussions

[climacs-announce] Climacs Progress Report, July 2006
by Troels Henriksen 24 Jul '06

24 Jul '06

Dear list members, Welcome to another installment of an exciting Climacs progress report? In the three months since the last progress report was posted, a lot of work has been done on Climacs - many bugs have been fixed, a lot of refactoring has been performed and a large amount of features, even some pretty major ones, have been added. Some notable changes are: * Highlighting of operators in Lisp syntax based on whether they are special operators or macros, instead of just having a list of symbols that should be highlighted (as Emacs does). * A generic on-line help/documentation facility has been added to ESA and integrated with Climacs - we now have basic documentation commands like GNU Emacs (C-h f, C-h k, etc). * Backup files are now version numbered. * A Visible Region command has been added. * Keyboard macros now support numeric arguments. * A new command parser has been developed for ESA, with the result that unsupplied arguments are now supported (through *unsupplied-argument-marker*), making it possible to define commands that take arguments (as opposed to just calling `accept' in the body) and still have them be invokable through gestures. * A host of new search/replace commands: Multiple Query Replace, Query Exchange, Multiple Query Replace From Buffer, String Search, Reverse String Search, Word Search and Reverse Word Search. * Incremental search has been improved, making it more comparable to the one in GNU Emacs. * The Lisp syntax has been drastically improved, it can now indent many more forms than it used to, and it has SLIME-like handling of in (in-package) forms. Of course, the major addition is probably the merging of Swine (from CLIM-Desktop) with the Lisp-syntax - Climacs, by itself, is now a reasonable tool for hacking Common Lisp code. The Swine-parts have also been improved since the merge, and has very intelligent parameter hinting and intelligent completion of keywords for keyword arguments (ie., when you symbol-complete at a point where only a keyword symbol would make sense, the possible completions will be chosen from among the relevant keyword arguments.). * There has been a lot of refactoring, for example implementation of Taylor Campbell's proposal for a uniform motion/editing function signature. Motion and editing commands can now be found in the files motion.lisp and editing.lisp, where the bulk of the functions are autogenerated (by macros) from basic building blocks. Also, almost all commands have been moved to a new CLIMACS-COMMANDS package, where they are implemented utilizing functionality exported by other packages. Syntaxaware-yet-not-GUI-oriented functions have been moved to the new CLIMACS-CORE package, and the CLIMACS-BASE package has had a fairly large amount of functions moved to other packages. * The main entry point(s) have been moved to a new CLIMACS package, so Climacs can now be invoked by running (climacs:climacs) instead of (climacs-gui:climacs). This is for consistency with other CLIM applications (notably Beirc and Gsharp). The GUI code itself still lives in CLIMACS-GUI. * Documentation has been added to the user guide (Doc/climacs-user.texi) for the new help and search/replace commands. Personally, I (Troels Henriksen) was not aware of this user guide until just recently, and thus had not updated it with my own work. If you add, or change, new commands, please consider adding them to this user guide - while it is unlikely that anyone actually uses Climacs, and need this guide, I think it is easier to keep it reasonably updated at all times, than to rewrite a lot of it from scratch at some point in the future. * I also hadn't paid much notice to the test suites - I'm probably the only one who has broken these tests, but if you are mucking around with the stuff tested by these suites, please run them before committing. :) They have recently been updated to work with the major changes to Climacs. Also, there has been a large amount of bugfixes and additions of minor functionality. Climacs' design is now reasonably clean, with clear boundaries between the various subsystems, which should make it easier for newcomers to understand the code and make contributions. There is no overarching plan that defines what will happen to Climacs next, but personally, I have been looking at implementing a "group" facility (like the one in Hemlock, but with more features) and improving the non-Lisp syntaxes, almost all of which need drastic improvements (speed-wise as well as functionality-wise). As always, integration with other CLIM applications is an interesting idea, but work like this is probably more suited for projects like CLIM-Desktop than Climacs proper. Climacs is still alive, and it is still a promising project. -- \ Troels "Athas" /\ Henriksen

1 0

[climacs-announce] Progress report
by Troels Henriksen 23 Apr '06

23 Apr '06

(I have been asked to write up a progress report. I'm new to this, so please bear with me.) Dear list-members, Since the last progress report, Climacs has been cleaned up in a number of areas, though not much major functionality has been added. Some of the major improvements are: * Climacs will now be more well-behaved when using execute-frame-command thanks to Christophe Rhodes. This opens up the possibility of integrating CLIM-applications through cross-application scripting. * Thanks to Timothy Moore, Climacs should now run under Allegro Common Lisp CLIM(tm) - including modern mode. * ESA has finally been factored out of the main Climacs module and into its own. This should ease maintenance, as ESA previously had to be maintained in both the Climacs and Gsharp repositories. * Climacs now support local options lists, where a file can specify options for Climacs by putting "-*- {Option-name: Value;}* -*-" in the first line of the file. In Emacs, this feature is known as the local variables list. * The Lisp syntax module has been extended with various new functions for easier navigation of the parse tree (exploitation of this can be seen in the CLIM-desktop repo) as well as conversion of parser tokens to the Lisp objects they represent. A number of bugs have been fixed as well. Of course, there has been the usual bugfixes and new commands (for example an "Indent Expression" command for the Lisp syntax module). Hopefully, the cleanups and gradual maturing of the editor will cause more feature-oriented commits over the next few months. The future of Climacs is as bright as ever, and with the general maturing of the free CLIM universe, integration with other CLIM programs should soon come. The "self-documenting" aspect of Climacs should also receive some attention over the next weeks. -- \ Troels "Athas" Henriksen /\ - Insert witty signature

1 0

[climacs-announce] Latest Progress
by John Q 17 Jan '06

17 Jan '06

Dear list-members, This is the semi-annual [ahem - must do better...] update on progress for those who don't follow climacs-cvs closely. Since the last report there have been a number of developments, not the least of which are reports of actual users who are not also climacs developers. This has come about partly as a result of Dwight Holman's clim-desktop project, which enables users to build an image containing an integrated set of clim-based applications, including, of course, climacs. The other parts of clim-desktop are Clouseau (an inspector), the Listener, a debugger, Closure (a web browser), Beirc (an IRC client) and Swine, which extends climacs to use swank (the Slime backend) to provide some slime-like functionality. Clim-desktop adds the following commands and functionality: Eval Last Expression C-c C-e Macroexpand 1 C-c C-m Macroexpand All C-c M-m Eval Region C-c C-r Compile Definition C-c C-c Compile And Load File C-c C-k Compile File C-c M-k Edit Definition M-. Return From Definition M-, (together with compiler note and cross reference display and navigation) Hyperspec Lookup C-c C-d h (using Closure) Arglist Lookup C-c C-d a Swine Completion M-Tab Swine Fuzzy Completion C-c M-i (arglists shown in minibuffer on #\Space) Inspect Buffer C-c C-d C-b Inspect Window C-c C-d C-w (using Clouseau) And, of course, COMMON-LISP:ED will open climacs! Other user-visible changes to climacs include: * Mouse left-click positions the cursor, right-click copies, and middle-click pastes * Describe Key Briefly C-h c, Where Is C-h w, Describe Bindings C-h b * Splitting and resizing windows is prettier (Dwight Holman again) * The package of a lisp file is detected and displayed in the info-pane * The beginnings of a User Manual (Robert Strandh) And Marcus Pearce has added significant functionality by tying together Christophe Rhodes' prolog-sytax to his (Christophe's) paiprolog, an expansion and ISOfication of the sexp-based Prolog from Norvig's 'Paradigms of Artificial Intelligence Programming' (PAIP). Behind the scenes there was a proliferation of command-tables and command-containing files, Christophe and David Lewis helped implement per-syntax commands, and Max-Gerd Retzlaff tidied up some pathname and pane-naming issues. In terms of infrastructure, the refactoring of certain functionality into the ESA ('Emacs Style Application') system seems to have worked, with ESA now being used in Gsharp and newcomer Ftd; Aleksandar Bakic (with the assistance of Derek Peschel) continued his work on cl-automaton. As to future directions Creighton Hogg will be progressively adding documentation to the commands in-program, and Nicholas Sceaux is working on the abstraction of the LR-parser functionality used in lisp-syntax. So this announcement marks the point at which climacs became genuinely useful to lisp developers: Robert reports that developing Gsharp in climacs (using clim-desktop) is a real pleasure, not least because, being lisp all the way down, nits in the development environment are only a M-., edit and C-c C-c away from being fixed. There is still a long way to go (and it is the essence of a programmable development environment that it is never finished), but future is looking good. Best regards, JQS __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

1 0

[climacs-announce] latest progress
by John Q Splittist 29 Aug '05

29 Aug '05

Dear list members, There has been considerable progress since the last update. Not least of which is that we have arranged for Robert to be transferred to an isolated location on the other side of the planet where he will have nothing to do but think about single-address operating systems and improve climacs' mcclim infrastructure. (That is, Robert is on sabbatical in Auckland, NZ, for a year.) Significant developments include: * Robert has factored out some base climacs functionality into a separate ESA (for 'Emacs-Style Application') package, which should make building applications using emacs/climacs interaction (a combination of key-chords and minibuffer commands) relatively simple. An example is included in the esa.lisp file. Among the goodies you get for free by using ESA are keyboard macros and nested command tables. * In preparation for buffer/syntax/view-customized commands pane-specific command tables have been introduced. * Aleksandar Bakic has added cl-automaton (derived from dk.brics.automaton by Anders Møller) as a basis for regular expression searching. New commands Regex Search Forward and Regex Search Backward should allow you to experiment with this. See the comments at the beginning of cl-automaton/regexp.lisp for an explanation of the regex syntax, which can be subtly different from Emacs or Perl regexps, and which includes some intriguing new constructs. * Robert's LR lisp parser (used in the 'Lisp', as opposed to the old 'Common Lisp', syntax) has been filled out a bit, and some preliminary use made to exploit the parse. For example lisp tokens are now presented as symbols and strings (enabling you to click to choose strings for, say M-% Query Replace) and inapplicable reader-conditionalized forms are now greyed out (there is a *climacs-features* variable to customize this). Try M-x Accept String and mousing around in the buffer; now press the Meta key while mousing - note the different treatment of double-quote-delimited strings. * But one of the big uses of the lisp parse is in indentation. Based on Robert's indentation infrastructure a large number of lisp forms are now indented correctly (many thanks to Christophe Rhodes), in a number of cases far better than emacs. By basing indentation on syntactic rather than textual structure things like ignoring comments are fairly easy. Check out the code towards the end of lisp-syntax.lisp and add indentation for your own favourite forms! * There is a new 'Fundamental' syntax destined to replace the unfortunately-named 'Basic' syntax. * The climacs.asd system definition has been reworked to reflect real dependencies by Andreas Fuchs (with Taylor R. Campbell diagnosing an issue with slidemacs). * A number of new commands have been added, including: Zap to Character and Zap to Object (thanks to Dwight Holman), Mark Word, Mark Whole Buffer, Mark Expression, Comment Region, Uncomment Region, Beginning of Definition, End of Definition, Backward Sentence, Forward Sentence, Not Modified, Set Fill Column, Kill Word, Backward Kill Word, Forward Page, Backward Page, Count Lines Page, Count Lines Region, What Cursor Position, Delete Horizontal Space, Scroll Other Window, Kill Sentence, Backward Kill Sentence, Mark Page, Forward List, Backward List, Up List, Backward Up List, Down List, Backward Kill Expression, Kill Expression, Just One Space, Scroll Other Window Up, Append Next Kill, Set Visited File Name and Revert Buffer. These are, in general, bound to the usual emacs keys. Some commands have had numeric argument handling additions, and some have been renamed (eg. Cut Out -> Kill Region) for consistency with emacs practice. A comparison of some climacs, Gnu Emacs, TI Explorer Zmacs, Hemlock and TECO EMACS commands is available at http://perso.wanadoo.fr/a.d.m/climacs-commands.html . Less significant developments include: * A simple backups feature has been added (when saving a file, an existing file will be renamed with an appended '~'). * Read-only buffers have been added, with Find File Read Only and Toggle Read Only to act on them. * The display cursor functionality has been factored out of each syntax (so cursors are now drawn the same everywhere), and the ability to display the mark has been added - use Toggle Visible Mark to make the mark appear and disappear. The future holds the possibility of (yet) another parsing infrastructure, making it even simpler to add certain types of syntaxes to climacs; a help system; interaction with swank; and (further out, perhaps) interaction with other (Mc)Clim applications. Best regards, JQS/a.d.m

1 0

[climacs-announce] latest progress
by Robert Strandh 14 Jul '05

14 Jul '05

Dear mailing list member, Here is a summary of the progress that has been made since the last progress report. First, as promised, the new Lisp syntax continues to evolve. Lexemes are parsed into Common Lisp symbols and presented as such whenever possible. This opens the possibility of having clickable symbols and/or of having information displayed when the cursor is over a symbol, though not much has been done to exploit that possibility yet. A framework for indentation of Common Lisp code is in place, and indentation functions exist for some common constructs such as defun, defgeneric, defmethod, defclass, with-slots, let, let*, cond, when, unless, and prog1. This indentation framework is smarter than that of Emacs and does not make mistakes when names of CL functions are used as local variables, etc., though Emacs indent function is of course more mature than what Climacs can do at the moment. I encourage everyone to check out this framework and add an indent function for his or her favorite CL construct. The one for `loop' will be quite challenging, but some others can be quite simple, especially since I provide macros to create indent functions for simple constructs. Christophe Rhodes has released his atypical syntax module for editing lute notation. The code is available at this location: http://www.doc.gold.ac.uk/~mas01cr/tabcode-20050708.tar.gz His syntax module is used in the ECOLM project that you can read about here: http://vega.soi.city.ac.uk/~dlewis/.home/ For the ILC2005 presentation, Brian Mastenbrook wrote another atypical syntax module called `slidemacs' which lets the buffer contents be presented as slides. Minor fixes have been made by myself, Brian Mastenbrook, Dan Barlow, Christophe Rhodes Dirk Gerrits reported a bug in undo/redo that has been fixed. Dan Barlow is rumored to be working on cleaning up key bindings, and Aleksandar Bakic is rumored to be working on giving Climacs regex support. -- Robert Strandh --------------------------------------------------------------------- Greenspun's Tenth Rule of Programming: any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp. ---------------------------------------------------------------------

1 0

[climacs-announce] latest progress
by Robert Strandh 02 Jun '05

02 Jun '05

Dear mailing list member, There have been a few exciting developments since the previous progress report. First, we (me, Brian Mastenbrook, Christophe Rhodes) have a paper about Climacs syntax protocols accepted at the ILC 2005. In it, we explain the difference between per-buffer and per-window syntax updating and give examples of modules that use these methods. When reading what my co-authors had written, I was struck by the number of syntax modules that already exist for Climacs and how varied they are: a very complete syntax module for ISO Prolog, a module for Tabcode notation used for Lute scores, a module for Testing and Test Control Notation 3 (TTCN3), and of course existing but incomplete syntax modules for Common Lisp and HTML. Second, due to difficulties achieving good performance with the Earley parser, I have written an alternative parser based on incremental LR parsing technology. I also wrote the definitions necessary for this module to parse Common Lisp. This syntax module is named "Lisp" to distinguish it from the one called "Common Lisp". It is experimental for now, so both are available. The incremental LR parser keeps a parse tree for the entire buffer up to date. It is thus a per-buffer module, which would be impossible with the current Earley parser. Parsing all of lisp-syntax.lisp (around 1000 lines) takes around 2 seconds on my machine, but this is only done when the file is initially loaded, or when edits to the buffer are made that makes the contents parse entirely differently from last time, such as when a closing parenthesis is introduced at the beginning of the buffer. In almost all cases, the incremental LR parser is able to patch the existing parse tree. As an example, typing a function definition at the beginning of a buffer containing lisp-syntax. lisp requires less than 10ms per keystroke to update the entire parse tree. Current feature of the "Lisp" syntax module include C-M-b and C-M-f (backward and forward expression), C-M-x (eval defun), and of course syntax highlighting of strings, keywords, and comments. One interesting feature of the LR parser that I implemented is that the lexer is a generic function that depends on the state of the parser. This method is slower than the one used for the Earley parser, but we could afford this since the parser is incremental. The consequences of this lexer organization is that the parser could enter a state in which a totally different language, with different lexemes, is to be parsed. This feature opens the door to modular parsers allowing us to parse a string of PHP code inside an HTML buffer, or to check the grammar of strings and comments of a program. Plans are to factor out code that could be common for more LR-based syntax modules, either into syntax.lisp or to a new file, but probably the former since there are definitions like that of a parse tree that look very similar in the Earley parser and in the LR parser. I also haven't given up on trying to make the Earley parser truly incremental in the same way that the LR parser now is. Plans also include writing a new LALR parser generator, simply because the one in Climacs uses generic functions instead of tables for the traditional `action' and `goto' (called `new-state' in Climacs) functions of LR parsing. The new parser generator would have to discover inheritance relations between parser states. Once such a generator exists, I might rewrite the HTML syntax module to take advantage of it. For a detailed list of updates, I refer you to the CVS archives. Take care, -- Robert Strandh --------------------------------------------------------------------- Greenspun's Tenth Rule of Programming: any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp. ---------------------------------------------------------------------

1 0

[climacs-announce] latest progress
by Robert Strandh 28 Apr '05

28 Apr '05

Dear mailing-list member, There is no doubt that the most exciting thing that has happened since the previous progress report is that Climacs now has a syntax module for Common Lisp. A group of four students: Nada Ayad, Julien Cazaban, Pascal Fong Kye, and Bruno Mery, have been working for the past two months or so to get this working. The first commits were made last week (just in time for me to announce it at the Amsterdam Lisp meeting), and we have seen a steady stream of improvements since then. In theory, the project is due tomorrow, so there is definitely the possibility that this stream will stop after that. So feel free to play around with the features, submit patches, add new features, etc. I am discovering the features myself now, so I am sure I do not yet have the full picture. Yesterday, I tested some of the syntax highlighting features, and I am already impressed. For instance, trying to use a digit that is not valid for the radix in the CL #nrxxx construct makes the token change colors. There are still some problems, of course, that may or may not be fixed by tomorrow. I advice against major modifications on your part before that. Other improvements since the previous progress report: * Improvements to Prolog syntax. (thanks to Christophe Rhodes) * Improvements to HTML syntax (organize the grammar around concepts in the standard, more elements, performance improvements). * Performance improvements of the Earley Parser in the form of precomputed prediction rules and a faster test for whether a rule has been predicted. Also avoid generic-function dispatch on functions that are called frequently. (thanks in part to Christophe Rhodes) The next speed improvement to the parsing framework might be to allow for a "manual" test to determine whether a rule is valid for prediction. To illustrate this idea for CL syntax: currently, whenever an expression is expected, all rules that handle the dispatch macro character #\# will be predicted. However, most often, the next lexeme is not #\#, so these predictions will not be used further. They must, however, be traversed when the completer searches this state for valid incomplete items. All this is costly. A simple test that makes it possible to test the next lexeme when a rule is about to be predicted could cut down on this work considerably. A similar phenomenon will occur in HTML mode when each inline element will be predicted for each word in an ordinary paragraph of text. Keep up the good work. -- Robert Strandh --------------------------------------------------------------------- Greenspun's Tenth Rule of Programming: any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp. ---------------------------------------------------------------------

1 0

[climacs-announce] latest progress
by Robert Strandh 06 Apr '05

06 Apr '05

Dear Mailing-list member, Nearly three weeks have gone by since the previous progress report. The main reason for that is that I have had some computer trouble (my main development computer was pirated, and I decided to reinstall a newer OS), and some other difficulties that I won't bore you with. The net result is that there has not been as much progress on Climacs from me as I had hoped. Nevertheless, Christophe Rhodes and Aleksandar Bakic have been making great progress in my absence. Perhaps the most exciting thing that happened is that Christophe Rhodes write a syntax module for Prolog. This work, together with the oddities of Prolog syntax, has exposed some limitations to the current parsing framework (based on a modified Earley parsing algorithm), but generally confirmed that writing a syntax module using this framework is not exceptionally hard. There is still some code factoring needed, especially with respect to parse-stack-driven redisplay. And I still don't know how to write a general-purpose protocol for exploiting the parse stack in interesting ways other than for redisplay. Here is a list of what happened since the previous report: * Improved the parsing framework by abstracting out certain features from html-syntax.lisp to syntax.lisp in order to make them more generally useful. Also did some code factoring. * Implementation of the undo protocol for the persistent buffer implementation. (thanks to Aleksandar Bakic) * Made several improvements to HTML-mode. Now, the add-rule macro is used so as to regroup all aspects of an HTML construct instead of having the grammar rule close to the code for creating the grammar. Introduced a macro `add-html-rule' inspired by the work of Christophe Rhodes on the Prolog syntax. Added grammar rules for recognizing string and the DIR and LANG attributes. Improved the code for recognizing the HREF attribute. * Fixed a file-order problem in climacs.asd (thanks to Aleksandar Bakic) * Syntax module for the Prolog programming language (see above). (thanks to Christophe Rhodes) * Fixed a redisplay bug reported by Christophe Rhodes. -- Robert Strandh --------------------------------------------------------------------- Greenspun's Tenth Rule of Programming: any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp. ---------------------------------------------------------------------

1 0

[climacs-announce] latest progress
by Robert Strandh 17 Mar '05

17 Mar '05

Dear mailing list member, As usual, this message is meant for those of you who do not follow the climacs-cvs mailing list. This past week, work has been concentrated to two different areas: Aleksandar Bakic has been working on implementing a line-oriented persistent implementation of the buffer protocol. He also continues to clean up the rest of the Climacs code in order to remove dependencies on a particular buffer implementation. I have continued my work on syntax modules. In particular, I have been working on the HTML syntax module, again not in order to make the HTML syntax module directly usable, but in order to use it as a model for how other, more important, syntax modules might be written. I encourage anyone who is interested in a complete HTML syntax module (and who knows a bit more about HTML than I do) to check it out and to add new functionality. Here is an itemized list of what happened the past week: * The HTML module is able to do syntax highlighting of HTML tags (green), of parse errors (red), of the title text (boldface). * Climacs no longer depends on a particular McCLIM backend. (thanks to Andreas Fuchs) * Added the <a> tag to HTML syntax * Line oriented persistent implementation of the buffer protocol using an adaptation of binary sequences by Robert Will. (thanks to Aleksandar Bakic) * Performance improvements and cleanups to the line oriented persistent implementation of the buffer protocol (thanks to Aleksandar Bakic) * Factored out incremental lexer from HTML syntax to the general syntax module, so that it can be useful from other syntax modules. * Documented the incremental lexer protocol. * Improvements to the buffer-test module. (thanks to Aleksandar Bakic) * Moved the code for updating positions of syntactic entities out of the specific syntax modules, so that it is now automatic for all classes that inherit from the parse-tree class. * Fixed a bug in update-syntax for HTML syntax. -- Robert Strandh --------------------------------------------------------------------- Greenspun's Tenth Rule of Programming: any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp. ---------------------------------------------------------------------

1 0

[climacs-announce] latest progress
by Robert Strandh 10 Mar '05

10 Mar '05

Dear mailing list member, The past week, I have concentrated my effort on the HTML syntax module, not because HTML is particularly interesting to the Climacs project, but because it is the syntax module that I currently use to determine what parsing-related functionality can be generalized, abstracted out, and used to implement other syntax modules. We are particularly interested in seeing how these generalizations can be used to implement the Common Lisp syntax module. Aleksandar Bakic continues to work on persistent buffer implementations. He has now started working on a line-oriented persistent buffer implementation that we hope will improve overall performance of Climacs buffer operations. Christophe Rhodes has been very helpful by pointing out potential problems with buffer delegation and with problems in the interaction between Climacs display functions and McCLIM cut-and-paste functionality. Here is an itemized list of what happened the past week: * Made html-syntax display from the sequence of lexemes as opposed to from the buffer itself * Split off html-syntax into a separate package. * Fixes of typos and minor problems in the documentation, and updates to the documentation related to delegating-buffer. (thanks to Aleksandar Bakic) * Performance improvements to the persistent buffer implementation (thanks to Aleksandar Bakic) * Introduced functions to traverse a parse stack encoded in the sequence of parser states that the Earley parser generates. * Modified the html-syntax to display from the parse states as long as a valid parse of the buffer exists, and from the sequence of lexemes when no valid parse exists. -- Robert Strandh --------------------------------------------------------------------- Greenspun's Tenth Rule of Programming: any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp. ---------------------------------------------------------------------

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

climacs-announce