elisp/geiser-chicken.el

   1 ;; geiser-chicken.el -- chicken's implementation of the geiser protocols
   2
   3 ;; Copyright (C) 2014, 2015 Daniel Leslie
   4
   5 ;; Based on geiser-guile.el by Jose Antonio Ortego Ruize
   6
   7 ;; This program is free software; you can redistribute it and/or
   8 ;; modify it under the terms of the Modified BSD License. You should
   9 ;; have received a copy of the license along with this program. If
  10 ;; not, see <http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5>.
  11
  12 ;; Start date: Sun Mar 08, 2009 23:03
  13
  14
  15 (require 'geiser-connection)
  16 (require 'geiser-syntax)
  17 (require 'geiser-custom)
  18 (require 'geiser-base)
  19 (require 'geiser-eval)
  20 (require 'geiser-edit)
  21 (require 'geiser-log)
  22 (require 'geiser)
  23
  24 (require 'compile)
  25 (require 'info-look)
  26
  27 (eval-when-compile (require 'cl))
  28
  29
  30 (defconst geiser-chicken-builtin-keywords
  31   '("and-let*" "assume" "compiler-typecase" "cond-expand" "condition-case"
  32     "cut" "cute" "declare" "define-constant" "define-inline" "define-interface"
  33     "define-record" "define-record-type" "define-specialization"
  34     "define-syntax-rule" "define-type" "define-values" "dotimes" "ecase"
  35     "fluid-let" "foreign-lambda" "foreign-lambda*" "foreign-primitive"
  36     "foreign-safe-lambda" "foreign-safe-lambda*" "functor" "handle-exceptions"
  37     "import" "let*-values" "let-location" "let-optionals" "let-optionals*"
  38     "let-values" "letrec*" "letrec-values" "match-letrec" "module"
  39     "parameterize" "regex-case" "require-extension" "select" "set!"
  40     "unless" "use" "when" "with-input-from-pipe" "match" "match-lambda"
  41     "match-lambda*" "match-let" "match-let*" "receive"))
  42
  43 ;;; Customization:
  44
  45 (defgroup geiser-chicken nil
  46   "Customization for Geiser's Chicken flavour."
  47   :group 'geiser)
  48
  49 (geiser-custom--defcustom geiser-chicken-binary
  50   (cond ((eq system-type 'windows-nt) '("csi.exe" "-:c"))
  51         ((eq system-type 'darwin) "csi")
  52         (t "csi"))
  53   "Name to use to call the Chicken executable when starting a REPL."
  54   :type '(choice string (repeat string))
  55   :group 'geiser-chicken)
  56
  57 (geiser-custom--defcustom geiser-chicken-load-path nil
  58   "A list of paths to be added to Chicken's load path when it's
  59 started."
  60   :type '(repeat file)
  61   :group 'geiser-chicken)
  62
  63 (geiser-custom--defcustom geiser-chicken-compile-geiser-p t
  64   "Non-nil means that the Geiser runtime will be compiled on load."
  65   :type 'boolean
  66   :group 'geiser-chicken)
  67
  68 (geiser-custom--defcustom geiser-chicken-init-file "~/.chicken-geiser"
  69   "Initialization file with user code for the Chicken REPL.
  70 If all you want is to load ~/.csirc, set
  71 `geiser-chicken-load-init-file-p' instead."
  72   :type 'string
  73   :group 'geiser-chicken)
  74
  75 (geiser-custom--defcustom geiser-chicken-load-init-file-p nil
  76   "Whether to load ~/.chicken when starting Chicken.
  77 Note that, due to peculiarities in the way Chicken loads its init
  78 file, using `geiser-chicken-init-file' is not equivalent to setting
  79 this variable to t."
  80   :type 'boolean
  81   :group 'geiser-chicken)
  82
  83 (geiser-custom--defcustom geiser-chicken-extra-keywords nil
  84   "Extra keywords highlighted in Chicken scheme buffers."
  85   :type '(repeat string)
  86   :group 'geiser-chicken)
  87
  88 (geiser-custom--defcustom geiser-chicken-case-sensitive-p t
  89   "Non-nil means keyword highlighting is case-sensitive."
  90   :type 'boolean
  91   :group 'geiser-chicken)
  92
  93
  94 ;;; REPL support:
  95
  96 (defun geiser-chicken--binary ()
  97   (if (listp geiser-chicken-binary)
  98       (car geiser-chicken-binary)
  99     geiser-chicken-binary))
 100
 101 (defun geiser-chicken--parameters ()
 102   "Return a list with all parameters needed to start Chicken.
 103 This function uses `geiser-chicken-init-file' if it exists."
 104   (let ((init-file (and (stringp geiser-chicken-init-file)
 105                         (expand-file-name geiser-chicken-init-file)))
 106         (n-flags (and (not geiser-chicken-load-init-file-p) '("-n"))))
 107   `(,@(and (listp geiser-chicken-binary) (cdr geiser-chicken-binary))
 108     ,@n-flags "-include-path" ,(expand-file-name "chicken/" geiser-scheme-dir)
 109     ,@(apply 'append (mapcar (lambda (p) (list "-include-path" p))
 110                              geiser-chicken-load-path))
 111     ,@(and init-file (file-readable-p init-file) (list init-file)))))
 112
 113 (defconst geiser-chicken--prompt-regexp "#[^;]*;[^:0-9]*:?[0-9]+> ")
 114
 115 ;;; Evaluation support:
 116
 117 (defun geiser-chicken--geiser-procedure (proc &rest args)
 118   (let ((fmt
 119          (case proc
 120            ((eval compile)
 121             (let ((form (mapconcat 'identity (cdr args) " ")))
 122               (format ",geiser-eval %s %s" (or (car args) "#f") form)))
 123            ((load-file compile-file)
 124             (format ",geiser-load-file %s" (car args)))
 125            ((no-values)
 126             ",geiser-no-values")
 127            (t
 128             (let ((form (mapconcat 'identity args " ")))
 129               (format "(geiser-%s %s)" proc form))))))
 130     ;;(message fmt)
 131     fmt))
 132
 133 (defconst geiser-chicken--module-re
 134   "( *module +\\(([^)]+)\\|[^ ]+\\)\\|( *define-library +\\(([^)]+)\\|[^ ]+\\)")
 135
 136 (defun geiser-chicken--get-module (&optional module)
 137   (cond ((null module)
 138          (save-excursion
 139            (geiser-syntax--pop-to-top)
 140            (if (or (re-search-backward geiser-chicken--module-re nil t)
 141                    (looking-at geiser-chicken--module-re)
 142                    (re-search-forward geiser-chicken--module-re nil t))
 143                (geiser-chicken--get-module (match-string-no-properties 1))
 144              :f)))
 145         ((listp module) module)
 146         ((stringp module)
 147          (condition-case nil
 148              (car (geiser-syntax--read-from-string module))
 149            (error :f)))
 150         (t :f)))
 151
 152 (defun geiser-chicken--module-cmd (module fmt &optional def)
 153   (when module
 154     (let* ((module (geiser-chicken--get-module module))
 155            (module (cond ((or (null module) (eq module :f)) def)
 156                          (t (format "%s" module)))))
 157       (and module (format fmt module)))))
 158
 159 (defun geiser-chicken--import-command (module)
 160   (geiser-chicken--module-cmd module "(use %s)"))
 161
 162 (defun geiser-chicken--enter-command (module)
 163   (geiser-chicken--module-cmd module ",m %s" module))
 164
 165 (defun geiser-chicken--exit-command () ",q")
 166
 167 (defun geiser-chicken--symbol-begin (module)
 168   (save-excursion (skip-syntax-backward "^-()>") (point)))
 169
 170 ;;; Error display
 171
 172 (defun geiser-chicken--display-error (module key msg)
 173   (newline)
 174   (when (stringp msg)
 175     (save-excursion (insert msg))
 176     (geiser-edit--buttonize-files))
 177   (and (not key) msg (not (zerop (length msg)))))
 178
 179 ;;; Trying to ascertain whether a buffer is Chicken Scheme:
 180
 181 (defconst geiser-chicken--guess-re
 182   (regexp-opt (append '("csi" "chicken") geiser-chicken-builtin-keywords)))
 183
 184 (defun geiser-chicken--guess ()
 185   (save-excursion
 186     (goto-char (point-min))
 187     (re-search-forward geiser-chicken--guess-re nil t)))
 188
 189 (defun geiser-chicken--external-help (id module)
 190   "Loads chicken doc into a buffer"
 191   (browse-url (format "http://api.call-cc.org/cdoc?q=%s&query-name=Look+up" id)))
 192
 193 ;;; Keywords and syntax
 194
 195 (defun geiser-chicken--keywords ()
 196   `((,(format "[[(]%s\\>" (regexp-opt geiser-chicken-builtin-keywords 1)) . 1)))
 197
 198 (geiser-syntax--scheme-indent
 199  (receive 2)
 200  (match 1)
 201  (match-lambda 0)
 202  (match-lambda* 0)
 203  (match-let scheme-let-indent)
 204  (match-let* 1)
 205  (match-letrec 1)
 206  (declare 0)
 207  (cond-expand 0)
 208  (let-values scheme-let-indent)
 209  (let*-values scheme-let-indent)
 210  (letrec-values 1)
 211  (letrec* 1)
 212  (parameterize scheme-let-indent)
 213  (let-location 1)
 214  (foreign-lambda 2)
 215  (foreign-lambda* 2)
 216  (foreign-primitive 2)
 217  (foreign-safe-lambda 2)
 218  (foreign-safe-lambda* 2)
 219  (set! 1)
 220  (let-optionals* 2)
 221  (let-optionals 2)
 222  (condition-case 1)
 223  (fluid-let 1)
 224  (and-let* 1)
 225  (assume 1)
 226  (cut 1)
 227  (cute 1)
 228  (when 1)
 229  (unless 1)
 230  (dotimes 1)
 231  (compiler-typecase 1)
 232  (ecase 1)
 233  (use 0)
 234  (require-extension 0)
 235  (import 0)
 236  (handle-exceptions 2)
 237  (regex-case 1)
 238  (define-inline 1)
 239  (define-constant 1)
 240  (define-syntax-rule 1)
 241  (define-record-type 1)
 242  (define-values 1)
 243  (define-record 1)
 244  (define-specialization 1)
 245  (define-type 1)
 246  (with-input-from-pipe 1)
 247  (with-output-to-pipe 1)
 248  (select 1)
 249  (functor 3)
 250  (define-interface 1)
 251  (module 2))
 252
 253 ;;; REPL startup
 254
 255 (defconst geiser-chicken-minimum-version "4.8.0.0")
 256
 257 (defun geiser-chicken--version (binary)
 258   (shell-command-to-string (format "%s -e \"(display (chicken-version))\""
 259                                    binary)))
 260
 261 (defun connect-to-chicken ()
 262   "Start a Chicken REPL connected to a remote process."
 263   (interactive)
 264   (geiser-connect 'chicken))
 265
 266 (defun geiser-chicken--startup (remote)
 267   (compilation-setup t)
 268   (let ((geiser-log-verbose-p t)
 269         (geiser-chicken-load-file (expand-file-name "chicken/geiser/emacs.scm" geiser-scheme-dir)))
 270     (if geiser-chicken-compile-geiser-p
 271       (geiser-eval--send/wait (format "
 272 ;; Sadly, (use import compile-file) must be run at top-level, so we have a stdout binding
 273 (define geiser-stdout (current-output-port))
 274 (current-output-port (make-output-port (lambda a #f) (lambda a #f)))
 275 (use utils)
 276 (compile-file \"%s\")
 277 (import geiser)
 278 (current-output-port geiser-stdout)
 279 "
 280                                       geiser-chicken-load-file))
 281       (geiser-eval--send/wait (format "(load \"%s\")"
 282                                       geiser-chicken-load-file)))))
 283
 284 ;;; Implementation definition:
 285
 286 (define-geiser-implementation chicken
 287   (unsupported-procedures '(callers callees generic-methods))
 288   (binary geiser-chicken--binary)
 289   (arglist geiser-chicken--parameters)
 290   (version-command geiser-chicken--version)
 291   (minimum-version geiser-chicken-minimum-version)
 292   (repl-startup geiser-chicken--startup)
 293   (prompt-regexp geiser-chicken--prompt-regexp)
 294   (debugger-prompt-regexp nil)
 295   (enter-debugger nil)
 296   (marshall-procedure geiser-chicken--geiser-procedure)
 297   (find-module geiser-chicken--get-module)
 298   (enter-command geiser-chicken--enter-command)
 299   (exit-command geiser-chicken--exit-command)
 300   (import-command geiser-chicken--import-command)
 301   (find-symbol-begin geiser-chicken--symbol-begin)
 302   (display-error geiser-chicken--display-error)
 303   (external-help geiser-chicken--external-help)
 304   (check-buffer geiser-chicken--guess)
 305   (keywords geiser-chicken--keywords)
 306   (case-sensitive geiser-chicken-case-sensitive-p))
 307
 308 (geiser-impl--add-to-alist 'regexp "\\.scm$" 'chicken t)
 309 (geiser-impl--add-to-alist 'regexp "\\.release-info$" 'chicken t)
 310 (geiser-impl--add-to-alist 'regexp "\\.meta$" 'chicken t)
 311 (geiser-impl--add-to-alist 'regexp "\\.setup$" 'chicken t)
 312
 313 (provide 'geiser-chicken)