Patch to support cmucl/unicode

The patch below adds support for cmucl/unicode.  This basically adds an
implementation of %make-readtable-iterator, updates %clear-readtable for
cmucl (like sbcl), a fix for %get-dispatch-macro-character, a fix for
%get-macro-character (like allegro).

With these changes (and a small change in named-readtables.lisp  that
has already been mentioned by Stas Boukarev last month. 

With these changes cmucl passes all 36 of the tests.

Oh, one thing.  I noticed that in %clear-readtable, the last sexp is
#+common-lisp.  CMUCL has the :common-lisp feature, so the table is set
twice.  Perhaps this is oversight and the reader conditional should be
#-(or allegro sbcl cmu)?

Ray

Change log:

 * Add implementation of %make-readtable-iterator for cmucl/unicode.
 * Implement %clear-readtable for cmucl.

 * Make %get-dispatch-macro-character return NIL where cmucl actually
   has #'lisp::dispatch-char-error.  It seems named-readtables wants
   this.
 * Update %get-macro-character for cmucl, which behaves like allegro
   here.

diff -u --recursive ./cruft.lisp
/Volumes/share2/src/sourceforge/matlisp/matlisp-cvs/lib-src/named-readtables-0.9/cruft.lisp

named-readtables/SLIME interaction problem

I ran into a problem with SLIME where I was getting errors the second time I would compile a buffer with
contents such as the following:

(cl:eval-when (:compile-toplevel :load-toplevel :execute)
 (ql:quickload 'named-readtables))

(defpackage #:reader-macro-test
  (:use #:cl))

(in-package #:reader-macro-test)

(eval-when (:compile-toplevel :load-toplevel :execute)
  (named-readtables:defreadtable readtable-test
    (:merge :standard)))

(named-readtables:in-readtable readtable-test)

It turns out that the problem has to do with the way SLIME deals with the style-warning that the defreadtable
gives about overwriting the existing readtable. The defreadtable form clears out the bindings for the
existing reader, then issues the warning. SLIME parses the buffer and picks up that we're in the
#:reader-macro-test package and sets *readtable* to be the readtable that we've just clobbered and then
in SLIMEs error/warning handling code it further frobs (a copy of) the (now empty-ish) readtable and then
attempts to read using that readtable and fails.

Tobias rightly points out that SLIME should have better support for named-readtables. It also seems to me
that SLIME might want to make greater assurances about the state of the reader in its error handling code.

But the simple, expedient fix is:

[Patch]: CMUCL and Allegro 8.2 fixes

The default value of error-p optional parameter for
excl:named-readtable was changed to T in Allegro 8.2, which causes
errors whenever find-readtable is called on non existent readtable.

CMUCL has an issue with ordering of loop initializations in the loop of
define-api macro. And the spec is quite confusing on how it really should behave.
The workaround is to use (progn x (loop ...)) instead of (loop initially x ...)

Thu Dec  9 12:57:53 MSK 2010  Stas Boukarev <stassats <at> gmail.com>
  * CMUCL has an issue with ordering of loop initializations in the loop of
  define-api macro. And the spec is quite confusing on how it really should behave.
  The workaround is to use (progn x (loop ...)) instead of (loop initially x ...)
Thu Dec  9 12:56:18 MSK 2010  Stas Boukarev <stassats <at> gmail.com>
  * The default value of error-p optional parameter for
  excl:named-readtable was changed to T in Allegro 8.2, which causes
  errors whenever find-readtable is called on non existent readtable.
diff -rN -u old-named-readtables/cruft.lisp new-named-readtables/cruft.lisp
--- old-named-readtables/cruft.lisp	2010-12-09 13:07:13.521070644 +0300
+++ new-named-readtables/cruft.lisp	2010-12-09 13:07:13.522070605 +0300
@@ -85,7 +85,7 @@

 (define-cruft %find-readtable (name)
   "Return the readtable named NAME."
-  #+ :allegro     (excl:named-readtable (readtable-name-for-allegro name))
+  #+ :allegro     (excl:named-readtable (readtable-name-for-allegro name) nil)
   #+ :common-lisp (values (gethash name *named-readtables* nil)))

 

Regarding hyperdoc

luis/lichtblau,

Wrt our discussion on yesterday's evening, I think that
REGISTER-DOCUMENTATION should probably become a macro which expands to
symbols in *PACKAGE* only -- in particular, it does not expand to
symbols from the HYPERDOC package so not to impose a runtime dependency.

Essentially that is to restore to the old ways of doing things --
although the API has changed somewhat.

I didn't (and still don't) like the set-some-magic-variables way as an
_interface_ which was the reason I came up with
REGISTER-DOCUMENTATION. It seems to be the right implementation choice,
though.

Are you d'accord?

  -T.

[ANN] Named Readtables 0.9

The [editor-hints] project is pleased to announce _Named Readtables_.

What are Named Readtables?

  It's a library

       a) to help you to organize your readtable hacks, 

   and b) to help your development environment to deal with these hacks.

  For detailed information see [What are Named-Readtables?] in the
  documentation.

Foretaste

  DEFREADTABLE (analogously to DEFPACKAGE) can be used to specify the
  content of a readtable.

  IN-READTABLE (analogously to IN-PACKAGE) can be used to specify what
  readtable should be used while compiling a .lisp file.

  Named-Readtables has an API very much inspired by the existing API
  of packages. But see [Important API idiosyncrasies] in the
  documentation.

Documentation

  See [Named-Readtables Documentation].

Is Israel a Democracy? -- The problem with intellectually insecure whites -- Should Christians Support Israeli Terrorism in Gaza?

The Jewish State of Israel has no constitution, nor does it name its borders. Israel's hidden constitution
is Judaism. Israel's undeclared borders range from the Nile to the Euphrates rivers. Israel's desired
jurisdiction extends over the entire Earth.

It could not be more clear that the Jewish State follows a foreign policy which obeys Jewish Law as iterated
in the Hebrew Bible, the Talmud, Maimonedes, the Cabalah, and the many commentaries and refinements of
same. The Jews are genociding the native inhabitants of Palestine, just as their religion advises, and because
their religion teaches them to do so. They treat non-Jews as if non-humans, just as their religion requires
them to do. They make perpetual war on every nation on Earth, just as their genocidal Jewish God has instructed.

The Jews of Israel are simply being Jews. Jews are an existential threat to the human race.

Israel contains one third of the Jews of the World. It is not some aberration of the Jewish spirit, but the
condensation and concentration of the perverse Jewish mentality, which malady also pervades the
remaining two thirds of Jewry, who almost unanimously support the Jewish State, and who certainly do
unanimously support
the Jewish People and its consistent and constant crimes against the human race. Israel is Jewry and the
danger of Israel is the danger of the Jewish People to all others, as the Jews have demonstrated each and
every day of their existence.

The Jews, the entire Jewish People of 15 million, will not relent until they have wiped out all non-Jews in
"Greater Israel". They will not stop destroying all other cultures, nations, religions, ethnicities,
races, competition, etc. until they are either stopped, or succeed in their ancient quest to destroy the
human race.

What Israel is doing is not some reaction to outside forces, nor was the formation of Israel a response to the
Holocaust. Israel is simply following the plan laid out in the Jews' religious texts. The Jews have openly
planned to take Palestine and genocide the native population of Palestine for some 2,500 years before the
Holocaust. The Jews have openly complained that "anti-Semitism" is a threat that gives them the right to
genocide the Palestinians, not merely since the advent of Nazism, but for some 2,500 years.

My thoughts about markup and docstrings

Yesterday I talked with David Lichtblau on #lisp, and he told me he's
currently working on structured docstrings. This subject falls under
editor-hints' scope (cf. items Documentation Retrieval, and Pretty
Docstrings in the [TODO] list.)

I promised him to write up my thoughts about the topic and post it here.

My stand on docstrings is that docstrings are totally inappropriate for
documentation purposes. In my view, docstrings should be used to
summarize what a function does in one, or two sentences for the reader
of the code, not the user of the code. 

The rationale behind that thinking is that elaborate docstrings would
take up too much screen space, and would seperate a) the body of a
function from its lambda-list, and b) the function definition
from other function definitions.

What I want is a DEFINE-DOCUMENTATION macro to define elaborate
documentation for a function, macro, &c. And I want Slime to bring me to
a) the rendered documentation of a symbol-at-point, and b) the source of
that documentation. (Cf. item Source Locations in [TODO].)

I think you probably expected comments regarding the implementational
model. I don't have any actually, as long as it's powerful enough to
reflect MarkDown and Texinfo. 

There's also Rahul Jain's DefDoc which I wanted to evaluate before
working on this. 

Re: Comments about defreadtable

Luís Oliveira wrote:
> On 28/01/2008, Robert P. Goldman <rpgoldman <at> sift.info> wrote:
>>>   2. Readtables should be named by symbols, not strings, in order to
>>>      avoid collisions between different code bases. Also, I suggest
>>>      defreadtable should signal a warning (or a style-warning) if a CL
>>>      or KEYWORD symbol is used to name a readtable. Again, the goal is
>>>      to avoid collisions.
>> I don't actually agree with this point.  Tobias has tried here to make
>> readtables act like packages, and this change would destroy that
>> commonality.  It would also make the use of readtable specifiers in mode
>> lines problematic.
> 
> I've heard that argument before. It makes perfect sense to follow the
> feel of defpackage because we're dealing with similar mechanisms. I
> think that using strings to designate readtables might be pushing the
> metaphor a bit too far, though. I think it's somewhat obvious why
> package names aren't symbols, the circularity makes my brain hurt; it
> doesn't apply to readtables.

Actually, I don't think it would be bad to have package names being
symbols --- that would apply a modularity and scoping that we sorely
lack in the package system.

Given that we lack this in the package system, we must come up with a
naming convention to overcome the lack.  Since we have to do this,
anyway, I'm inclined to suggest we just extend the same mechanism to
readtables, to keep the parallelism.

This is probably an aesthetic disagreement where neither of us will
convince the other.  I think that if we have to introduce foo.bar

Comments about defreadtable

Hello,

Here are a few random thoughts with regard to defreadtable:

  1. This mechanism seems useful enough to me that the
     non-editor-related bits could live in a separate
     package/system/project.

  2. Readtables should be named by symbols, not strings, in order to
     avoid collisions between different code bases. Also, I suggest
     defreadtable should signal a warning (or a style-warning) if a CL
     or KEYWORD symbol is used to name a readtable. Again, the goal is
     to avoid collisions.

  3. MAKE-DISPATCH-MACRO-CHARACTER functionality is missing.  Perhaps
     the :DISPATCH-MACRO-CHAR directive can check for
     (null (get-macro-character macro-char)) and create that
     dispatch-macro, or maybe another directive would be better.

--

-- 
Luís Oliveira
http://student.dei.uc.pt/~lmoliv/

Initial checkin.

Alright, RPG and me migrated the svn repository from his employer to
common-lisp.net. You can fetch the sources via

  svn checkout svn://common-lisp.net/project/editor-hints/svn

The sources contain so far only an almost complete implementation of
named readtables. Incomplete only in so far that merging of readtables
don't work so far, because it needs introspection into a readtable which
the standard doesn't offer.

I can implement this kind of introspection by shadowing
SET-MACRO-CHARACTER &c. -- although I'd like implementations to provide
this functionality themselves ultimativaly (think CDR.)

Named Readtables provide a package like namespace for readtables. Every
normal .lisp file should start with

   (in-package :foo)     ; where #<PACKAGE "FOO"> uses :EDITOR-HINTS
   (in-readtable :standard)

You can define your own named readtables via DEFREADTABLE:

  (eval-when (:compile-toplevel :load-toplevel :execute)
    (defun semicolon-reader (stream char)
     (declare (ignore char))
     (let ((comment-string (read-line stream nil "" t)))
       `(comment (string-left-trim '(#\; #\Space #\Tab) comment-string)))))

  (defreadtable :preserving-comments

Initial message to create gmane.lisp.editors.hints.devel group.

Intentionally left unblank.

--

-- 
Diese Nachricht wurde auf Viren und andere gefaerliche Inhalte untersucht
und ist - aktuelle Virenscanner vorausgesetzt - sauber.
Freebits E-Mail Virus Scanner