elisp/geiser-syntax.el

   1 ;;; geiser-syntax.el -- utilities for parsing scheme syntax
   2
   3 ;; Copyright (C) 2009, 2010 Jose Antonio Ortega Ruiz
   4
   5 ;; This program is free software; you can redistribute it and/or
   6 ;; modify it under the terms of the Modified BSD License. You should
   7 ;; have received a copy of the license along with this program. If
   8 ;; not, see <http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5>.
   9
  10 ;; Start date: Sun Feb 08, 2009 15:03
  11
  12 \f
  13
  14 (require 'geiser-impl)
  15 (require 'geiser-popup)
  16 (require 'geiser-base)
  17
  18 (require 'scheme)
  19
  20 (eval-when-compile (require 'cl))
  21
  22 \f
  23 ;;; Indentation:
  24
  25 (defmacro geiser-syntax--scheme-indent (&rest pairs)
  26   `(progn ,@(mapcar (lambda (p)
  27                       `(put ',(car p) 'scheme-indent-function ',(cadr p)))
  28                     pairs)))
  29
  30 (geiser-syntax--scheme-indent
  31  (begin0 1)
  32  (c-declare 0)
  33  (c-lambda 2)
  34  (case-lambda 0)
  35  (case-lambda: 0)
  36  (catch defun)
  37  (class defun)
  38  (class* defun)
  39  (compound-unit/sig 0)
  40  (define: defun)
  41  (dynamic-wind 0)
  42  (for/fold 2)
  43  (instantiate 2)
  44  (interface 1)
  45  (lambda: 1)
  46  (lambda/kw 1)
  47  (let*-values 1)
  48  (let*-values: 1)
  49  (let+ 1)
  50  (let: 1)
  51  (letrec: 1)
  52  (letrec* 1)
  53  (letrec-values 1)
  54  (letrec-values: 1)
  55  (let-values 1)
  56  (let-values: 1)
  57  (let/cc: 1)
  58  (let/ec 1)
  59  (match defun)
  60  (mixin 2)
  61  (module defun)
  62  (opt-lambda 1)
  63  (parameterize 1)
  64  (parameterize-break 1)
  65  (parameterize* 1)
  66  (pmatch defun)
  67  (quasisyntax/loc 1)
  68  (receive 2)
  69  (send* 1)
  70  (sigaction 1)
  71  (syntax-case 2)
  72  (syntax/loc 1)
  73  (type-case defun)
  74  (unit defun)
  75  (unit/sig 2)
  76  (unless 1)
  77  (when 1)
  78  (while 1)
  79  (with-fluid* 1)
  80  (with-fluids 1)
  81  (with-fluids* 1)
  82  (with-handlers 1)
  83  (with-handlers: 1)
  84  (with-method 1)
  85  (with-syntax 1))
  86
  87 \f
  88 ;;; Extra syntax keywords
  89 (defconst geiser-syntax--keywords
  90   '(("\\[\\(else\\)\\>" . 1)
  91     ("(\\(parameterize\\)\\>" . 1)))
  92
  93 (font-lock-add-keywords 'scheme-mode geiser-syntax--keywords)
  94
  95 (geiser-impl--define-caller geiser-syntax--impl-kws keywords ()
  96   "A variable (or thunk returning a value) giving additional,
  97 implementation-specific entries for font-lock-keywords.")
  98
  99 (defun geiser-syntax--add-kws ()
 100   (let ((kw (geiser-syntax--impl-kws geiser-impl--implementation)))
 101     (when kw (font-lock-add-keywords nil kw))))
 102
 103 \f
 104 ;;; A simple scheme reader
 105
 106 (defvar geiser-syntax--read/buffer-limit nil)
 107
 108 (defsubst geiser-syntax--read/eos ()
 109   (or (eobp)
 110       (and geiser-syntax--read/buffer-limit
 111            (<= geiser-syntax--read/buffer-limit (point)))))
 112
 113 (defsubst geiser-syntax--read/next-char ()
 114   (unless (geiser-syntax--read/eos)
 115     (forward-char)
 116     (char-after)))
 117
 118 (defsubst geiser-syntax--read/token (token)
 119   (geiser-syntax--read/next-char)
 120   (if (listp token) token (list token)))
 121
 122 (defsubst geiser-syntax--read/elisp ()
 123   (ignore-errors (read (current-buffer))))
 124
 125 (defun geiser-syntax--read/symbol ()
 126   (with-syntax-table scheme-mode-syntax-table
 127     (when (re-search-forward "\\(\\sw\\|\\s_\\)+" nil t)
 128       (make-symbol (match-string-no-properties 0)))))
 129
 130 (defun geiser-syntax--read/matching (open close)
 131   (let ((count 1)
 132         (p (1+ (point))))
 133     (while (and (> count 0)
 134                 (geiser-syntax--read/next-char))
 135       (cond ((looking-at-p open) (setq count (1+ count)))
 136             ((looking-at-p close) (setq count (1- count)))))
 137     (buffer-substring-no-properties p (point))))
 138
 139 (defsubst geiser-syntax--read/unprintable ()
 140   (geiser-syntax--read/token
 141    (cons 'unprintable (geiser-syntax--read/matching "<" ">"))))
 142
 143 (defun geiser-syntax--read/skip-comment ()
 144   (while (and (geiser-syntax--read/next-char)
 145               (nth 8 (syntax-ppss))))
 146   (geiser-syntax--read/next-token))
 147
 148 (defun geiser-syntax--read/next-token ()
 149   (skip-syntax-forward "->")
 150   (if (geiser-syntax--read/eos) '(eob)
 151     (case (char-after)
 152       (?\; (geiser-syntax--read/skip-comment))
 153       ((?\( ?\[) (geiser-syntax--read/token 'lparen))
 154       ((?\) ?\]) (geiser-syntax--read/token 'rparen))
 155       (?. (if (memq (car (syntax-after (1+ (point)))) '(0 11 12))
 156               (geiser-syntax--read/token 'dot)
 157             (cons 'atom (geiser-syntax--read/elisp))))
 158       (?\# (case (geiser-syntax--read/next-char)
 159              ('nil '(eob))
 160              (?| (geiser-syntax--read/skip-comment))
 161              (?: (if (geiser-syntax--read/next-char)
 162                      (cons 'kwd (geiser-syntax--read/symbol))
 163                    '(eob)))
 164              (?\\ (cons 'char (geiser-syntax--read/elisp)))
 165              (?\( (geiser-syntax--read/token 'vectorb))
 166              (?\< (geiser-syntax--read/unprintable))
 167              ((?' ?` ?,) (geiser-syntax--read/next-token))
 168              (t (let ((tok (geiser-syntax--read/symbol)))
 169                   (cond ((equal (symbol-name tok) "t") '(boolean . :t))
 170                         ((equal (symbol-name tok) "f") '(boolean . :f))
 171                         (tok (cons 'atom (make-symbol (format "#%s" tok))))
 172                         (t (geiser-syntax--read/next-token)))))))
 173       (?\' (geiser-syntax--read/token '(quote . quote)))
 174       (?\` (geiser-syntax--read/token
 175             `(backquote . ,backquote-backquote-symbol)))
 176       (?, (if (eq (geiser-syntax--read/next-char) ?@)
 177               (geiser-syntax--read/token
 178                `(splice . ,backquote-splice-symbol))
 179             `(unquote . ,backquote-unquote-symbol)))
 180       (?\" (cons 'string (geiser-syntax--read/elisp)))
 181       (t (cons 'atom (geiser-syntax--read/symbol))))))
 182
 183 (defsubst geiser-syntax--read/match (&rest tks)
 184   (let ((token (geiser-syntax--read/next-token)))
 185     (if (memq (car token) tks) token
 186       (error "Unexpected token: %s" token))))
 187
 188 (defsubst geiser-syntax--read/skip-until (&rest tks)
 189   (let (token)
 190     (while (and (not (memq (car token) tks))
 191                 (not (eq (car token) 'eob)))
 192       (setq token (geiser-syntax--read/next-token)))
 193     token))
 194
 195 (defsubst geiser-syntax--read/try (&rest tks)
 196   (let ((p (point))
 197         (tk (ignore-errors (apply 'geiser-syntax--read/match tks))))
 198     (unless tk (goto-char p))
 199     tk))
 200
 201 (defun geiser-syntax--read/list ()
 202   (cond ((geiser-syntax--read/try 'dot)
 203          (let ((tail (geiser-syntax--read)))
 204            (geiser-syntax--read/skip-until 'eob 'rparen)
 205            tail))
 206         ((geiser-syntax--read/try 'rparen 'eob) nil)
 207         (t (cons (geiser-syntax--read)
 208                  (geiser-syntax--read/list)))))
 209
 210 (defun geiser-syntax--read ()
 211   (let ((token (geiser-syntax--read/next-token))
 212         (max-lisp-eval-depth (max max-lisp-eval-depth 3000)))
 213     (case (car token)
 214       (eob nil)
 215       (lparen (geiser-syntax--read/list))
 216       (vectorb (apply 'vector (geiser-syntax--read/list)))
 217       ((quote backquote unquote splice) (list (cdr token)
 218                                               (geiser-syntax--read)))
 219       (kwd (make-symbol (format ":%s" (cdr token))))
 220       (unprintable (format "#<%s>" (cdr token)))
 221       ((char string atom) (cdr token))
 222       (boolean (cdr token))
 223       (t (error "Reading scheme syntax: unexpected token: %s" token)))))
 224
 225 (defun geiser-syntax--read-from-string (string &optional start end)
 226   (when (stringp string)
 227     (let* ((start (or start 0))
 228            (end (or end (length string)))
 229            (max-lisp-eval-depth (max max-lisp-eval-depth (- end start))))
 230       (with-temp-buffer
 231         (save-excursion (insert string))
 232         (cons (ignore-errors (geiser-syntax--read)) (point))))))
 233
 234 (defsubst geiser-syntax--form-after-point (&optional boundary)
 235   (let ((geiser-syntax--read/buffer-limit (and (numberp boundary) boundary)))
 236     (save-excursion (values (geiser-syntax--read) (point)))))
 237
 238 (defun geiser-syntax--mapconcat (fun lst sep)
 239   (cond ((null lst) "")
 240         ((not (listp lst)) (format ".%s%s" sep (funcall fun lst)))
 241         ((null (cdr lst)) (format "%s" (funcall fun (car lst))))
 242         (t (format "%s%s%s"
 243                    (funcall fun (car lst))
 244                    sep
 245                    (geiser-syntax--mapconcat fun (cdr lst) sep)))))
 246
 247 (defun geiser-syntax--display (a)
 248   (cond ((null a) "()")
 249         ((eq a :t) "#t")
 250         ((eq a :f) "#f")
 251         ((geiser-syntax--keywordp a) (format "#%s" a))
 252         ((symbolp a) (format "%s" a))
 253         ((equal a "...") "...")
 254         ((stringp a) (format "%S" a))
 255         ((and (listp a) (symbolp (car a))
 256               (equal (symbol-name (car a)) "quote"))
 257          (format "'%s" (geiser-syntax--display (cadr a))))
 258         ((listp a)
 259          (format "(%s)"
 260                  (geiser-syntax--mapconcat 'geiser-syntax--display a " ")))
 261         (t (format "%s" a))))
 262
 263 \f
 264 ;;; Code parsing:
 265
 266 (defsubst geiser-syntax--symbol-at-point ()
 267   (and (not (nth 8 (syntax-ppss)))
 268        (let ((s (thing-at-point 'symbol)))
 269          (and s
 270               (not (equal s "."))
 271               (make-symbol (substring-no-properties s))))))
 272
 273 (defsubst geiser-syntax--skip-comment/string ()
 274   (let ((pos (nth 8 (syntax-ppss))))
 275     (goto-char (or pos (point)))
 276     pos))
 277
 278 (defsubst geiser-syntax--nesting-level ()
 279   (or (nth 0 (syntax-ppss)) 0))
 280
 281 (defsubst geiser-syntax--pair-length (p)
 282   (if (cdr (last p)) (1+ (safe-length p)) (length p)))
 283
 284 (defun geiser-syntax--shallow-form (boundary)
 285   (when (looking-at-p "\\s(")
 286     (save-excursion
 287       (forward-char)
 288       (let ((elems))
 289         (ignore-errors
 290           (while (< (point) boundary)
 291             (skip-syntax-forward "-<>")
 292             (when (<= (point) boundary)
 293               (forward-sexp)
 294               (let ((s (thing-at-point 'symbol)))
 295                 (cond ((not s) (push s elems))
 296                       ((not (equal "." s)) (push (make-symbol s) elems)))))))
 297         (nreverse elems)))))
 298
 299 (defsubst geiser-syntax--keywordp (s)
 300   (and s (symbolp s) (string-match "^:.+" (symbol-name s))))
 301
 302 (defsubst geiser-syntax--symbol-eq (s0 s1)
 303   (and (symbolp s0) (symbolp s1) (equal (symbol-name s0) (symbol-name s1))))
 304
 305 (defun geiser-syntax--scan-sexps (&optional begin)
 306   (let* ((fst (geiser-syntax--symbol-at-point))
 307          (smth (or fst (not (looking-at-p "[\s \s)\s>\s<\n]"))))
 308          (path (and fst `((,fst 0)))))
 309     (save-excursion
 310       (while (not (zerop (geiser-syntax--nesting-level)))
 311         (let ((boundary (point)))
 312           (geiser-syntax--skip-comment/string)
 313           (backward-up-list)
 314           (let ((form (geiser-syntax--shallow-form boundary)))
 315             (when (and (listp form) (car form) (symbolp (car form)))
 316               (let* ((len (geiser-syntax--pair-length form))
 317                      (pos (if smth (1- len) (progn (setq smth t) len)))
 318                      (prev (and (> pos 1) (nth (1- pos) form)))
 319                      (prev (and (geiser-syntax--keywordp prev)
 320                                 (list prev))))
 321                 (push `(,(car form) ,pos ,@prev) path)))))))
 322     (mapcar (lambda (e) (cons (format "%S" (car e)) (cdr e)))
 323             (nreverse path))))
 324
 325 (defsubst geiser-syntax--binding-form-p (bfs sbfs f)
 326   (and (symbolp f)
 327        (let ((f (symbol-name f)))
 328          (or (member f '("define" "define*" "define-syntax"
 329                          "syntax-rules" "lambda" "case-lambda"
 330                          "let" "let*" "let-values" "let*-values"
 331                          "letrec" "letrec*" "parameterize"))
 332              (member f bfs)
 333              (member f sbfs)))))
 334
 335 (defsubst geiser-syntax--binding-form*-p (sbfs f)
 336   (and (symbolp f)
 337        (let ((f (symbol-name f)))
 338          (or (member f '("let*" "let*-values" "letrec" "letrec*"))
 339              (member f sbfs)))))
 340
 341 (defsubst geiser-syntax--if-symbol (x) (and (symbolp x) x))
 342 (defsubst geiser-syntax--if-list (x) (and (listp x) x))
 343
 344 (defsubst geiser-syntax--normalize (vars)
 345   (mapcar (lambda (i)
 346             (let ((i (if (listp i) (car i) i)))
 347               (and (symbolp i) (symbol-name i))))
 348           vars))
 349
 350 (defun geiser-syntax--linearize (form)
 351   (cond ((not (listp form)) (list form))
 352         ((null form) nil)
 353         (t (cons (car form) (geiser-syntax--linearize (cdr form))))))
 354
 355 (defun geiser-syntax--scan-locals (bfs sbfs form nesting locals)
 356   (if (or (null form) (not (listp form)))
 357       (geiser-syntax--normalize locals)
 358     (if (not (geiser-syntax--binding-form-p bfs sbfs (car form)))
 359         (geiser-syntax--scan-locals bfs sbfs
 360                                     (car (last form))
 361                                     (1- nesting) locals)
 362       (let* ((head (car form))
 363              (name (geiser-syntax--if-symbol (cadr form)))
 364              (names (if name (geiser-syntax--if-list (caddr form))
 365                       (geiser-syntax--if-list (cadr form))))
 366              (bns (and name
 367                        (geiser-syntax--binding-form-p bfs sbfs (car names))))
 368              (rest (if (and name (not bns)) (cdddr form) (cddr form)))
 369              (use-names (and (or rest
 370                                  (< nesting 1)
 371                                  (geiser-syntax--binding-form*-p sbfs head))
 372                              (not bns))))
 373         (when name (push name locals))
 374         (when (geiser-syntax--symbol-eq head 'case-lambda)
 375           (dolist (n (and (> nesting 0) (caar (last form))))
 376             (when n (push n locals)))
 377           (setq rest (and (> nesting 0) (cdr form)))
 378           (setq use-names nil))
 379         (when (geiser-syntax--symbol-eq head 'syntax-rules)
 380           (dolist (n (and (> nesting 0) (cdaar (last form))))
 381             (when n (push n locals)))
 382           (setq rest (and (> nesting 0) (cdr form))))
 383         (when use-names
 384           (dolist (n (geiser-syntax--linearize names))
 385             (let ((xs (if (and (listp n) (listp (car n))) (car n) (list n))))
 386               (dolist (x xs) (when x (push x locals))))))
 387         (dolist (f (butlast rest))
 388           (when (and (listp f)
 389                      (geiser-syntax--symbol-eq (car f) 'define)
 390                      (cadr f))
 391             (push (cadr f) locals)))
 392         (geiser-syntax--scan-locals bfs sbfs
 393                                     (car (last (or rest names)))
 394                                     (1- nesting)
 395                                     locals)))))
 396
 397 (defun geiser-syntax--locals-around-point (bfs sbfs)
 398   (when (eq major-mode 'scheme-mode)
 399     (save-excursion
 400       (let ((sym (unless (geiser-syntax--skip-comment/string)
 401                    (thing-at-point 'symbol))))
 402         (skip-syntax-forward "->")
 403         (let ((boundary (point))
 404               (nesting (geiser-syntax--nesting-level)))
 405           (while (not (zerop (geiser-syntax--nesting-level)))
 406             (backward-up-list))
 407           (multiple-value-bind (form end)
 408               (geiser-syntax--form-after-point boundary)
 409             (delete sym
 410                     (geiser-syntax--scan-locals bfs
 411                                                 sbfs
 412                                                 form
 413                                                 (1- nesting)
 414                                                 '()))))))))
 415
 416 \f
 417 ;;; Fontify strings as Scheme code:
 418
 419 (defun geiser-syntax--font-lock-buffer ()
 420   (let ((name " *geiser font lock*"))
 421     (or (get-buffer name)
 422         (let ((buffer (get-buffer-create name)))
 423           (set-buffer buffer)
 424           (let ((geiser-default-implementation
 425                  (or geiser-default-implementation
 426                      (car geiser-active-implementations))))
 427             (scheme-mode))
 428           buffer))))
 429
 430 (defun geiser-syntax--scheme-str (str)
 431   (save-current-buffer
 432     (set-buffer (geiser-syntax--font-lock-buffer))
 433     (erase-buffer)
 434     (insert str)
 435     (let ((font-lock-verbose nil)) (font-lock-fontify-buffer))
 436     (buffer-string)))
 437
 438 \f
 439 (provide 'geiser-syntax)
 440 ;;; geiser-syntax.el ends here