Sv: Christmas wish: Literate Elisp

[arthur miller <arthur.miller@live.com>]

[-- Attachment #1.1: Type: text/plain, Size: 2538 bytes --]

Here is a little prototype to test my idea with literal Elisp.

I have patched read-eval loop as stated in previous mail, in lread.c.
It is probably possible to implement that in Elisp, but I don't have
enough knowledge of either Emacs internals nor Elisp to do this in some
short time. It would took me a lot of time to look up all the
things I would need. Anyway, C code turned to be rather trivial, and also
completely by-passable if so desired, so I have introduced a user-customizable
variable 'emacs-lisp-allow-literal-comments', which is by default nil.

I wasn't sure in which elisp file to introduce this variable, so I have used
'simple.el' found in lisp directory of Emacs source distribution. That file
seems to have some other user customizable variables that affect elisp so I
thought it might be appropriate place.

For the byte compiler I have patched bytecomp.el, in rather brutish way, but it
seems to work. It wasn't very difficult either, but I think I have done it rather
ugly. Someone might wish to refactor that code. Anyway, it is less then
twenty lines of code, and it is by default bypassed as well. The variable
that controls it is also user customizable and found  in same file,
named 'byte-comp-allow-literal-comments'.

I have attached also a small trivial elisp file for illustration purpose.

It is just a test of an idea, and small prototype to show that it might work.
It needs more thorough testing and can probably be implemented in some better
way.

I have tested on GNU/Linux and Windows. Emacs was able to compile it's own
elisp as well as external packages I use.

As a note, the change in C is completely backwards compatible. No logical
change to elisp parser happens when 'emacs-lisp-allow-literal-comments'
variable is nil.

________________________________
Från: Emacs-devel <emacs-devel-bounces+arthur.miller=live.com@gnu.org> för Jean-Christophe Helary <jean.christophe.helary@traduction-libre.org>
Skickat: den 19 december 2019 02:50
Till: emacs-devel@gnu.org <emacs-devel@gnu.org>
Ämne: Re: Christmas wish: Literate Elisp



> On Dec 19, 2019, at 9:42, chad <yandros@gmail.com> wrote:
>
> There is a large body of existing software which will be totally unaware of your changes.

Although I think the premise of your comment is absolutely valid, I'm not so sure about the "*large* body of existing software".


Jean-Christophe Helary
-----------------------------------------------
http://mac4translators.blogspot.com @brandelune




[-- Attachment #1.2: Type: text/html, Size: 4297 bytes --]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: simple.patch --]
[-- Type: text/x-patch; name="simple.patch", Size: 479 bytes --]

--- simple.el	2019-12-20 01:06:16.849343961 +0100
+++ mysimple.el	2019-12-20 01:03:05.212467674 +0100
@@ -127,6 +127,14 @@
   :safe #'booleanp
   :version "27.1")
 
+(defcustom emacs-lisp-allow-literal-comments nil
+  "If not nil, elisp will allow you to type in top-level comments
+   without using semicolon."
+  :group 'lisp
+  :type 'boolean
+  :safe #'booleanp
+  :version "27.1")
+
 (defvar next-error-highlight-timer nil)
 
 (defvar next-error-overlay-arrow-position nil)

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #3: lread.patch --]
[-- Type: text/x-patch; name="lread.patch", Size: 906 bytes --]

--- lread.c	2019-12-20 01:07:33.264089317 +0100
+++ mylread.c	2019-12-20 01:02:38.605308850 +0100
@@ -1955,6 +1955,8 @@
   /* True on the first time around.  */
   bool first_sexp = 1;
   Lisp_Object macroexpand = intern ("internal-macroexpand-for-load");
+  Lisp_Object litcode = intern ("emacs-lisp-allow-literal-comments");
+  Lisp_Object allow_literal_comments = find_symbol_value(litcode);
 
   if (NILP (Ffboundp (macroexpand))
       || (STRINGP (sourcename) && suffix_p (sourcename, ".elc")))
@@ -2053,6 +2055,15 @@
 	  || c == NO_BREAK_SPACE)
 	goto read_next;
 
+      if (EQ (allow_literal_comments, Qt))
+        {
+          if (c != '(' && c != '#')
+            {
+              while ((c = READCHAR) != '\n' && c != -1);
+              goto read_next;
+            }
+        }
+
       if (! HASH_TABLE_P (read_objects_map)
 	  || XHASH_TABLE (read_objects_map)->count)
 	read_objects_map

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #4: bytecomp.patch --]
[-- Type: text/x-patch; name="bytecomp.patch", Size: 3207 bytes --]

--- bytecomp.el	2019-12-20 01:05:44.575414147 +0100
+++ mybytecomp.el	2019-12-20 01:03:24.409489389 +0100
@@ -154,6 +154,14 @@
   :type '(choice (const nil) function)
   :version "23.2")
 
+(defcustom byte-compile-allow-literal-comments nil
+  "If not nil, byte compiler will allow you to type
+   top-level comments without using semicolon in emacs lisp."
+  :group 'bytecomp
+  :type 'boolean
+  :safe #'booleanp
+  :version "27.1")
+
 ;; This enables file name handlers such as jka-compr
 ;; to remove parts of the file name that should not be copied
 ;; through to the output file name.
@@ -2079,8 +2087,8 @@
 	(print-level nil)
 	;; Prevent edebug from interfering when we compile
 	;; and put the output into a file.
-;; 	(edebug-all-defs nil)
-;; 	(edebug-all-forms nil)
+        ;; 	(edebug-all-defs nil)
+        ;; 	(edebug-all-forms nil)
 	;; Simulate entry to byte-compile-top-level
         (byte-compile-jump-tables nil)
         (byte-compile-constants nil)
@@ -2127,19 +2135,35 @@
 			       (= (following-char) ?\;))
 		   (forward-line 1))
 		 (not (eobp)))
-	  (setq byte-compile-read-position (point)
+
+          (setq byte-compile-read-position (point)
 		byte-compile-last-position byte-compile-read-position)
-          (let* ((lread--unescaped-character-literals nil)
-                 (form (read inbuffer))
-                 (warning (byte-run--unescaped-character-literals-warning)))
-            (when warning (byte-compile-warn "%s" warning))
-	    (byte-compile-toplevel-file-form form)))
-	;; Compile pending forms at end of file.
-	(byte-compile-flush-pending)
-	;; Make warnings about unresolved functions
-	;; give the end of the file as their position.
-	(setq byte-compile-last-position (point-max))
-	(byte-compile-warn-about-unresolved-functions))
+
+	  (if byte-compile-allow-literal-comments
+              (progn
+                (if (or (= (following-char) ?\()
+                        (= (following-char) ?\#)
+                        (= (following-char) ?\'))
+                    (progn
+                      (let* ((lread--unescaped-character-literals nil)
+                             (form (read inbuffer))
+                             (warning (byte-run--unescaped-character-literals-warning)))
+                        (when warning (byte-compile-warn "%s" warning))
+	                (byte-compile-toplevel-file-form form)))
+                  (forward-line 1)))
+            (progn
+              (let* ((lread--unescaped-character-literals nil)
+                     (form (read inbuffer))
+                     (warning (byte-run--unescaped-character-literals-warning)))
+                (when warning (byte-compile-warn "%s" warning))
+	        (byte-compile-toplevel-file-form form)))))
+
+        ;; Compile pending forms at end of file.
+        (byte-compile-flush-pending)
+        ;; Make warnings about unresolved functions
+        ;; give the end of the file as their position.
+        (setq byte-compile-last-position (point-max))
+        (byte-compile-warn-about-unresolved-functions))
       ;; Fix up the header at the front of the output
       ;; if the buffer contains multibyte characters.
       (and byte-compile-current-file

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #5: chatty.el --]
[-- Type: text/x-emacs-lisp; name="chatty.el", Size: 524 bytes --]

Elisp now alows comments without ;.

(setq emacs-lisp-allow-literal-comments nil)
(setq byte-compile-allow-literal-comments nil)

(message "Hello, World!")

It is of course possible to intertwene code
with comments anywhere in the file.

(message "Hello Again!")

Of course we can also comment-out code
just as before:

;;(message "I am silent")
In code blocs the ';' is still a comment delimiter:
(message
 ;; Here is a line commne
 "I am a bit chatty today!")

That's it for today folks!

(message "Bye bye cruel world!")