Update all packages

elpa/archives/gnu/archive-contents

@@ -341,7 +341,7 @@
 	     ((:keywords "killing" "convenience")
 	      (:url . "https://github.com/leoliu/easy-kill"))])
  (ebdb .
-       [(0 5 3)
+       [(0 5 4)
 	((emacs
 	  (25 1))
 	 (cl-lib
@@ -375,14 +375,16 @@
 	     ((:url . "http://elpa.gnu.org/packages/ediprolog.html")
 	      (:keywords "languages" "processes"))])
  (eglot .
-	[(1 0)
+	[(1 1)
 	 ((emacs
-	   (26 1)))
+	   (26 1))
+	  (jsonrpc
+	   (1 0 0)))
 	 "Client for Language Server Protocol (LSP) servers" tar
 	 ((:keywords "convenience" "languages")
 	  (:url . "https://github.com/joaotavora/eglot"))])
  (el-search .
-	    [(1 7 1)
+	    [(1 7 2)
 	     ((emacs
 	       (25))
 	      (stream
@@ -448,6 +450,13 @@
 			 nil "Parse and browse f90 interfaces" single
 			 ((:url . "http://github.com/wence-/f90-iface/")
 			  (:keywords))])
+ (filladapt .
+	    [(2 12 2)
+	     ((emacs
+	       (24 4)))
+	     "Adaptive fill" single
+	     ((:url . "http://elpa.gnu.org/packages/filladapt.html")
+	      (:keywords))])
  (flylisp .
 	  [(0 2)
 	   ((emacs
@@ -614,7 +623,7 @@
  (jsonrpc .
 	  [(1 0 0)
 	   ((emacs
-	     (26 1)))
+	     (25 2)))
 	   "JSON-RPC library" single
 	   ((:url . "http://elpa.gnu.org/packages/jsonrpc.html")
 	    (:keywords "processes" "languages" "extensions"))])

elpa/archives/gnu/archive-contents.signed

@@ -1 +1 @@
-Good signature from 474F05837FBDEF9B GNU ELPA Signing Agent <elpasign@elpa.gnu.org> (trust undefined) created at 2018-07-02T06:10:03-0300 using DSA
+Good signature from 474F05837FBDEF9B GNU ELPA Signing Agent <elpasign@elpa.gnu.org> (trust undefined) created at 2018-07-17T06:10:03-0300 using DSA

elpa/company-20180704.701/company-capf.el

@@ -88,8 +88,8 @@
          (let* ((table (nth 3 res))
                 (pred (plist-get (nthcdr 4 res) :predicate))
                 (meta (completion-metadata
-                      (buffer-substring (nth 1 res) (nth 2 res))
+                       (buffer-substring (nth 1 res) (nth 2 res))
-                      table pred))
+                       table pred))
                 (sortfun (cdr (assq 'display-sort-function meta)))
                 (candidates (completion-all-completions arg table pred (length arg)))
                 (last (last candidates))
@@ -112,18 +112,28 @@
                       (nth 3 res) (plist-get (nthcdr 4 res) :predicate))))
            (cdr (assq 'display-sort-function meta))))))
     (`match
-     ;; Can't just use 0 when base-size (see above) is non-zero.
+     ;; Ask the for the `:company-match' function.  If that doesn't help,
-     (let ((start (if (get-text-property 0 'face arg)
+     ;; fallback to sniffing for face changes to get a suitable value.
-                      0
+     (let ((f (plist-get (nthcdr 4 (company--capf-data)) :company-match)))
-                    (next-single-property-change 0 'face arg))))
+       (if f (funcall f arg)
-       (when start
+         (let* ((match-start nil) (pos -1)
-         ;; completions-common-part comes first, but we can't just look for this
+                (prop-value nil)  (faces nil)
-         ;; value because it can be in a list.
+                (has-face-p nil)  chunks
-         (or
+                (limit (length arg)))
-          (let ((value (get-text-property start 'face arg)))
+           (while (< pos limit)
-            (text-property-not-all start (length arg)
+             (setq pos
-                                   'face value arg))
+                   (if (< pos 0) 0 (next-property-change pos arg limit)))
-          (length arg)))))
+             (setq prop-value (or
+                               (get-text-property pos 'face arg)
+                               (get-text-property pos 'font-lock-face arg))
+                   faces (if (listp prop-value) prop-value (list prop-value))
+                   has-face-p (memq 'completions-common-part faces))
+             (cond ((and (not match-start) has-face-p)
+                    (setq match-start pos))
+                   ((and match-start (not has-face-p))
+                    (push (cons match-start pos) chunks)
+                    (setq match-start nil))))
+           (nreverse chunks)))))
     (`duplicates t)
     (`no-cache t)   ;Not much can be done here, as long as we handle
                     ;non-prefix matches.

elpa/company-20180704.701/company-pkg.el

@@ -1,4 +1,4 @@
-(define-package "company" "20180615.1508" "Modular text completion framework"
+(define-package "company" "20180704.701" "Modular text completion framework"
   '((emacs "24.3"))
   :keywords
   '("abbrev" "convenience" "matching")

elpa/company-20180704.701/company.el

@@ -403,10 +403,13 @@ be kept if they have different annotations.  For that to work properly,
 backends should store the related information on candidates using text
 properties.
 
-`match': The second argument is a completion candidate.  Return the index
+`match': The second argument is a completion candidate.  Return a positive
-after the end of text matching `prefix' within the candidate string.  It
+integer, the index after the end of text matching `prefix' within the
-will be used when rendering the popup.  This command only makes sense for
+candidate string.  Alternatively, return a list of (CHUNK-START
-backends that provide non-prefix completion.
+. CHUNK-END) elements, where CHUNK-START and CHUNK-END are indexes within
+the candidate string.  The corresponding regions are be used when rendering
+the popup.  This command only makes sense for backends that provide
+non-prefix completion.
 
 `require-match': If this returns t, the user is not allowed to enter
 anything not offered as a candidate.  Please don't use that value in normal
@@ -2507,7 +2510,6 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
                                                   (- width (length annotation)))
                           annotation))
                        right)))
-    (setq common (+ (min common width) margin))
     (setq width (+ width margin (length right)))
 
     (font-lock-append-text-property 0 width 'mouse-face
@@ -2519,11 +2521,17 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
                                           'company-tooltip-annotation-selection
                                         'company-tooltip-annotation)
                                       line))
-    (font-lock-prepend-text-property margin common 'face
+    (cl-loop
-                                     (if selected
+     with width = (- width (length right))
-                                         'company-tooltip-common-selection
+     for (comp-beg . comp-end) in (if (integerp common) `((0 . ,common)) common)
-                                       'company-tooltip-common)
+     for inline-beg = (+ margin comp-beg)
-                                     line)
+     for inline-end = (min (+ margin comp-end) width)
+     when (< inline-beg width)
+     do (font-lock-prepend-text-property inline-beg inline-end 'face
+                                         (if selected
+                                             'company-tooltip-common-selection
+                                           'company-tooltip-common)
+                                         line))
     (when (let ((re (funcall company-search-regexp-function
                              company-search-string)))
             (and (not (string= re ""))

elpa/counsel-20180717.845/counsel-autoloads.el

@@ -59,6 +59,9 @@ or radio, offer completion of all possible values.
 Otherwise, offer a variant of `eval-expression', with the initial
 input corresponding to the chosen variable.
 
+With a prefix arg, restrict list to variables defined using
+`defcustom'.
+
 \(fn SYM)" t nil)
 
 (autoload 'counsel-apropos "counsel" "\

elpa/counsel-20180717.845/counsel-pkg.el

@@ -1,2 +1,2 @@
 ;;; -*- no-byte-compile: t -*-
-(define-package "counsel" "20180625.634" "Various completion functions using Ivy" '((emacs "24.3") (swiper "0.9.0")))
+(define-package "counsel" "20180717.845" "Various completion functions using Ivy" '((emacs "24.3") (swiper "0.9.0")))

elpa/counsel-20180717.845/counsel.el

@@ -4,7 +4,7 @@
 
 ;; Author: Oleh Krehel <ohwoeowho@gmail.com>
 ;; URL: https://github.com/abo-abo/swiper
-;; Package-Version: 20180625.634
+;; Package-Version: 20180717.845
 ;; Version: 0.10.0
 ;; Package-Requires: ((emacs "24.3") (swiper "0.9.0"))
 ;; Keywords: convenience, matching, tools
@@ -46,10 +46,19 @@
 (require 'dired)
 
 ;;* Utility
-(defun counsel-more-chars (n)
+(defvar counsel-more-chars-alist
-  "Return two fake candidates prompting for at least N input."
+  '((counsel-grep . 2)
-  (list ""
+    (t . 3))
-        (format "%d chars more" (- n (length ivy-text)))))
+  "Minimum amount of characters to prompt for before fetching candidates.")
+
+(defun counsel-more-chars ()
+  "Return two fake candidates prompting for at least N input.
+N is obtained from `counsel-more-chars-alist'."
+  (let ((len (length ivy-text))
+        (n (ivy-alist-setting counsel-more-chars-alist)))
+    (when (< len n)
+      (list ""
+            (format "%d chars more" (- n len))))))
 
 (defun counsel-unquote-regex-parens (str)
   "Unquote regex parenthesis in STR."
@@ -461,11 +470,11 @@ Update the minibuffer with the amount of lines collected every
 (declare-function xref-push-marker-stack "xref")
 
 (defalias 'counsel--push-xref-marker
-  (if (require 'xref nil t)
+    (if (require 'xref nil t)
-      #'xref-push-marker-stack
+        #'xref-push-marker-stack
-    (require 'etags)
+      (require 'etags)
-    (lambda (&optional m)
+      (lambda (&optional m)
-      (ring-insert find-tag-marker-ring (or m (point-marker)))))
+        (ring-insert (with-no-warnings find-tag-marker-ring) (or m (point-marker)))))
   "Compatibility shim for `xref-push-marker-stack'.")
 
 (defun counsel--find-symbol (x)
@@ -648,10 +657,15 @@ When the selected variable is a `defcustom' with the type boolean
 or radio, offer completion of all possible values.
 
 Otherwise, offer a variant of `eval-expression', with the initial
-input corresponding to the chosen variable."
+input corresponding to the chosen variable.
+
+With a prefix arg, restrict list to variables defined using
+`defcustom'."
   (interactive (list (intern
-                      (ivy-read "Variable: "
+                      (ivy-read "Variable: " (counsel-variable-list)
-                                (counsel-variable-list)
+                                :predicate (and current-prefix-arg
+                                                (lambda (varname)
+                                                  (get (intern varname) 'custom-type)))
                                 :preselect (ivy-thing-at-point)
                                 :history 'counsel-set-variable-history))))
   (let ((doc (and (require 'cus-edit)
@@ -1267,18 +1281,18 @@ Typical value: '(recenter)."
   :type 'hook
   :group 'ivy)
 
-(defun counsel-git-grep-function (string &optional _pred &rest _unused)
+(defun counsel-git-grep-function (str &optional _pred &rest _unused)
   "Grep in the current git repository for STRING."
-  (if (and (> counsel--git-grep-count counsel--git-grep-count-threshold)
+  (or
-           (< (length string) 3))
+   (and (> counsel--git-grep-count counsel--git-grep-count-threshold)
-      (counsel-more-chars 3)
+        (counsel-more-chars))
-    (let* ((default-directory (ivy-state-directory ivy-last))
+   (let* ((default-directory (ivy-state-directory ivy-last))
-           (cmd (format counsel-git-grep-cmd
+          (cmd (format counsel-git-grep-cmd
-                        (setq ivy--old-re (ivy--regex string t)))))
+                       (setq ivy--old-re (ivy--regex str t)))))
-      (if (<= counsel--git-grep-count counsel--git-grep-count-threshold)
+     (if (<= counsel--git-grep-count counsel--git-grep-count-threshold)
-          (split-string (shell-command-to-string cmd) "\n" t)
+         (split-string (shell-command-to-string cmd) "\n" t)
-        (counsel--gg-candidates (ivy--regex string))
+       (counsel--gg-candidates (ivy--regex str))
-        nil))))
+       nil))))
 
 (defun counsel-git-grep-action (x)
   "Go to occurrence X in current Git repository."
@@ -1409,15 +1423,16 @@ INITIAL-INPUT can be given as the initial minibuffer input."
                 :unwind unwind-function
                 :history 'counsel-git-grep-history
                 :caller 'counsel-git-grep))))
+(cl-pushnew 'counsel-git-grep ivy-highlight-grep-commands)
 
 (defun counsel-git-grep-proj-function (str)
   "Grep for STR in the current git repository."
-  (if (< (length str) 3)
+  (or
-      (counsel-more-chars 3)
+   (counsel-more-chars)
-    (let ((regex (setq ivy--old-re
+   (let ((regex (setq ivy--old-re
-                       (ivy--regex str t))))
+                      (ivy--regex str t))))
-      (counsel--async-command (format counsel-git-grep-cmd regex))
+     (counsel--async-command (format counsel-git-grep-cmd regex))
-      nil)))
+     nil)))
 
 (defun counsel-git-grep-switch-cmd ()
   "Set `counsel-git-grep-cmd' to a different value."
@@ -1581,19 +1596,20 @@ done") "\n" t)))
 (defvar counsel-git-log-split-string-re "\ncommit "
   "The `split-string' separates when split output of `counsel-git-log-cmd'.")
 
-(defun counsel-git-log-function (input)
+(defun counsel-git-log-function (str)
-  "Search for INPUT in git log."
+  "Search for STR in git log."
-  (if (< (length input) 3)
+  (or
-      (counsel-more-chars 3)
+   (counsel-more-chars)
-    ;; `counsel--yank-pop-format-function' uses this
+   (progn
-    (setq ivy--old-re (funcall ivy--regex-function input))
+     ;; `counsel--yank-pop-format-function' uses this
-    (counsel--async-command
+     (setq ivy--old-re (funcall ivy--regex-function str))
-     ;; "git log --grep" likes to have groups quoted e.g. \(foo\).
+     (counsel--async-command
-     ;; But it doesn't like the non-greedy ".*?".
+      ;; "git log --grep" likes to have groups quoted e.g. \(foo\).
-     (format counsel-git-log-cmd
+      ;; But it doesn't like the non-greedy ".*?".
-             (replace-regexp-in-string "\\.\\*\\?" ".*"
+      (format counsel-git-log-cmd
-                                       (ivy-re-to-str ivy--old-re))))
+              (replace-regexp-in-string "\\.\\*\\?" ".*"
-    nil))
+                                        (ivy-re-to-str ivy--old-re))))
+     nil)))
 
 (defun counsel-git-log-action (x)
   "Add candidate X to kill ring."
@@ -2176,11 +2192,12 @@ string - the full shell command to run."
 
 (defun counsel-locate-function (input)
   "Call the \"locate\" shell command with INPUT."
-  (if (< (length input) 3)
+  (or
-      (counsel-more-chars 3)
+   (counsel-more-chars)
-    (counsel--async-command
+   (progn
-     (funcall counsel-locate-cmd input))
+     (counsel--async-command
-    '("" "working...")))
+      (funcall counsel-locate-cmd input))
+     '("" "working..."))))
 
 ;;;###autoload
 (defun counsel-locate (&optional initial-input)
@@ -2421,18 +2438,18 @@ regex string."
 (ivy-set-occur 'counsel-ag 'counsel-ag-occur)
 (ivy-set-display-transformer 'counsel-ag 'counsel-git-grep-transformer)
 
-(defun counsel-ag-function (string)
+(defun counsel-ag-function (str)
   "Grep in the current directory for STRING using BASE-CMD.
 If non-nil, append EXTRA-AG-ARGS to BASE-CMD."
-  (if (< (length string) 3)
+  (or
-      (counsel-more-chars 3)
+   (counsel-more-chars)
-    (let ((default-directory (ivy-state-directory ivy-last))
+   (let ((default-directory (ivy-state-directory ivy-last))
-          (regex (counsel-unquote-regex-parens
+         (regex (counsel-unquote-regex-parens
-                  (setq ivy--old-re
+                 (setq ivy--old-re
-                        (ivy--regex string)))))
+                       (ivy--regex str)))))
-      (counsel--async-command (format counsel-ag-command
+     (counsel--async-command (format counsel-ag-command
-                                      (shell-quote-argument regex)))
+                                     (shell-quote-argument regex)))
-      nil)))
+     nil)))
 
 ;;;###autoload
 (defun counsel-ag (&optional initial-input initial-directory extra-ag-args ag-prompt)
@@ -2457,17 +2474,16 @@ AG-PROMPT, if non-nil, is passed as `ivy-read' prompt argument."
                                      (car (split-string counsel-ag-command)))))))
   (when (null extra-ag-args)
     (setq extra-ag-args ""))
-  (let* ((args-end (string-match " -- " extra-ag-args))
+  (let* ((args-end (string-match "-- " extra-ag-args))
          (file (if args-end
-                   (substring-no-properties extra-ag-args (+ args-end 3))
+                   (substring-no-properties extra-ag-args (match-end 0))
                  ""))
          (extra-ag-args (if args-end
                             (substring-no-properties extra-ag-args 0 args-end)
                           extra-ag-args)))
     (setq counsel-ag-command (format counsel-ag-command
                                      (concat extra-ag-args
-                                             " -- "
+                                             " -- %s "
-                                             "%s"
                                              file))))
   (ivy-set-prompt 'counsel-ag counsel-prompt-function)
   (let ((default-directory (or initial-directory
@@ -2484,6 +2500,7 @@ AG-PROMPT, if non-nil, is passed as `ivy-read' prompt argument."
                         (counsel-delete-process)
                         (swiper--cleanup))
               :caller 'counsel-ag)))
+(cl-pushnew 'counsel-ag ivy-highlight-grep-commands)
 
 (defun counsel-grep-like-occur (cmd-template)
   (unless (eq major-mode 'ivy-occur-grep-mode)
@@ -2526,6 +2543,7 @@ This uses `counsel-ag' with `counsel-pt-base-command' instead of
   (interactive)
   (let ((counsel-ag-base-command counsel-pt-base-command))
     (counsel-ag initial-input)))
+(cl-pushnew 'counsel-pt ivy-highlight-grep-commands)
 
 ;;** `counsel-ack'
 (defcustom counsel-ack-base-command
@@ -2570,6 +2588,7 @@ RG-PROMPT, if non-nil, is passed as `ivy-read' prompt argument."
   (interactive)
   (let ((counsel-ag-base-command counsel-rg-base-command))
     (counsel-ag initial-input initial-directory extra-rg-args rg-prompt)))
+(cl-pushnew 'counsel-rg ivy-highlight-grep-commands)
 
 ;;** `counsel-grep'
 (defcustom counsel-grep-base-command "grep -E -n -e %s %s"
@@ -2584,14 +2603,14 @@ substituted by the search regexp and file, respectively.  Neither
 
 (defun counsel-grep-function (string)
   "Grep in the current directory for STRING."
-  (if (< (length string) 2)
+  (or
-      (counsel-more-chars 2)
+   (counsel-more-chars)
-    (let ((regex (counsel-unquote-regex-parens
+   (let ((regex (counsel-unquote-regex-parens
-                  (setq ivy--old-re
+                 (setq ivy--old-re
-                        (ivy--regex string)))))
+                       (ivy--regex string)))))
-      (counsel--async-command
+     (counsel--async-command
-       (format counsel-grep-command (shell-quote-argument regex)))
+      (format counsel-grep-command (shell-quote-argument regex)))
-      nil)))
+     nil)))
 
 (defun counsel-grep-action (x)
   "Go to candidate X."
@@ -2657,12 +2676,15 @@ When non-nil, INITIAL-INPUT is the initial search pattern."
          (setq res (ivy-read "grep: " 'counsel-grep-function
                              :initial-input initial-input
                              :dynamic-collection t
-                             :preselect (format "%d:%s"
+                             :preselect
-                                                (line-number-at-pos)
+                             (when (< (- (line-end-position) (line-beginning-position)) 300)
-                                                (regexp-quote
+                               (format "%d:%s"
-                                                 (buffer-substring-no-properties
+                                       (line-number-at-pos)
-                                                  (line-beginning-position)
+                                       (regexp-quote
-                                                  (line-end-position))))
+                                        (buffer-substring-no-properties
+                                         (line-beginning-position)
+                                         (line-end-position)))))
+
                              :history 'counsel-git-grep-history
                              :update-fn (lambda ()
                                           (counsel-grep-action (ivy-state-current ivy-last)))
@@ -2702,14 +2724,15 @@ When non-nil, INITIAL-INPUT is the initial search pattern."
     (counsel-grep initial-input)))
 
 ;;** `counsel-recoll'
-(defun counsel-recoll-function (string)
+(defun counsel-recoll-function (str)
-  "Run recoll for STRING."
+  "Run recoll for STR."
-  (if (< (length string) 3)
+  (or
-      (counsel-more-chars 3)
+   (counsel-more-chars)
-    (counsel--async-command
+   (progn
-     (format "recoll -t -b %s"
+     (counsel--async-command
-             (shell-quote-argument string)))
+      (format "recoll -t -b %s"
-    nil))
+              (shell-quote-argument str)))
+     nil)))
 
 ;; This command uses the recollq command line tool that comes together
 ;; with the recoll (the document indexing database) source:
@@ -2856,6 +2879,7 @@ otherwise continue prompting for tags."
 (declare-function org-global-tags-completion-table "org")
 (declare-function org-agenda-files "org")
 (declare-function org-agenda-set-tags "org-agenda")
+(declare-function org-tags-completion-function "org")
 
 ;;;###autoload
 (defun counsel-org-tag ()
@@ -2874,21 +2898,23 @@ otherwise continue prompting for tags."
       (unless (org-at-heading-p)
         (org-back-to-heading t))
       (setq counsel-org-tags (split-string (org-get-tags-string) ":" t)))
-    (let ((org-setting-tags t)
+    (let ((org-last-tags-completion-table
-          (org-last-tags-completion-table
+           (append (and (or org-complete-tags-always-offer-all-agenda-tags
-           (append org-tag-persistent-alist
+                            (eq major-mode 'org-agenda-mode))
-                   (or org-tag-alist (org-get-buffer-tags))
+                        (org-global-tags-completion-table
-                   (and
+                         (org-agenda-files)))
-                    (or org-complete-tags-always-offer-all-agenda-tags
+                   (unless (boundp 'org-current-tag-alist)
-                        (eq major-mode 'org-agenda-mode))
+                     org-tag-persistent-alist)
-                    (org-global-tags-completion-table
+                   (or (if (boundp 'org-current-tag-alist)
-                     (org-agenda-files))))))
+                           org-current-tag-alist
+                         org-tag-alist)
+                       (org-get-buffer-tags)))))
       (ivy-read (counsel-org-tag-prompt)
-                (lambda (str &rest _unused)
+                (lambda (str _pred _action)
                   (delete-dups
-                   (all-completions str 'org-tags-completion-function)))
+                   (all-completions str #'org-tags-completion-function)))
                 :history 'org-tags-history
-                :action 'counsel-org-tag-action
+                :action #'counsel-org-tag-action
                 :caller 'counsel-org-tag))))
 
 ;;;###autoload
@@ -3196,7 +3222,11 @@ include attachments of other Org buffers."
                    (lambda (x)
                      (when (> (length x) 2)
                        (format "%-5s %s" (nth 0 x) (nth 1 x))))
-                   (or org-capture-templates
+                   ;; We build the list of capture templates as in
+                   ;; `org-capture-select-template':
+                   (or (org-contextualize-keys
+                        (org-capture-upgrade-templates org-capture-templates)
+                        org-capture-templates-contexts)
                        '(("t" "Task" entry (file+headline "" "Tasks")
                           "* TODO %?\n  %u\n  %a")))))
             :require-match t

elpa/ess-20180701.100/ess-pkg.el

@@ -1,8 +0,0 @@
-(define-package "ess" "20180701.100" "Emacs Speaks Statistics: statistical programming within Emacs"
-  '((julia-mode "0.3"))
-  :keywords
-  '("statistics" "languages")
-  :url "http://ess.r-project.org/")
-;; Local Variables:
-;; no-byte-compile: t
-;; End:

elpa/ess-20180701.100/ess.el

@@ -1,106 +0,0 @@
-;;; ess.el --- Emacs Speaks Statistics: statistical programming within Emacs
-
-;; Copyright (C) 1989--1996 Bates, Kademan, Ritter and Smith
-;; Copyright (C) 1997--2010 A.J. Rossini, Richard M. Heiberger, Martin
-;;      Maechler, Kurt Hornik, Rodney Sparapani, and Stephen Eglen.
-;; Copyright (C) 2011--2018 A.J. Rossini, Richard M. Heiberger, Martin
-;;      Maechler, Kurt Hornik, Rodney Sparapani, Stephen Eglen,
-;;      Vitalie Spinu, and Lionel Henry.
-
-;; Author: Doug Bates
-;;     Ed Kademan
-;;     Frank Ritter
-;;     David Smith
-;; Created: October 14, 1991
-;; Maintainer: ESS-core <ESS-core@r-project.org>
-;; Keywords: statistics, languages
-;; URL: http://ess.r-project.org/
-;; Package-Requires: ((julia-mode "0.3"))
-
-;; This file is part of ESS
-
-;; This file is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-;;
-;; This file is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-;;
-;; A copy of the GNU General Public License is available at
-;; http://www.r-project.org/Licenses/
-
-;;; Commentary:
-
-;; PURPOSE
-;;
-;; Interface to the S, SAS, and XLisp dialects of statistical
-;; programming languages, with potential extensions to other
-;; languages.   Designed to be extendable to most other interactive
-;; statistical programming situations.
-
-;; BRIEF OVERVIEW
-;;
-;; Supports structured editing of S, SAS, and XLisp (statistics
-;; programming languages) functions that are integrated with a
-;; running process in a buffer.
-
-;; THE ESS MAILING LIST
-;;
-;; There is an informal mailing list for discussions of ESS.  Alpha
-;; and beta releases of ESS are also announced here.  Send mail
-;; to ess-help-request@r-project.org to join.
-
-;; OVERVIEW OF ESS
-;;
-;; S is a statistics programming language developed at Bell Labs
-;; particularly suited for descriptive and exploratory statistics.
-;; s-mode is built on top of comint (the general command interpreter
-;; mode written by Olin Shivers), and so comint.el (or comint.elc)
-;; should be either loaded or in your load path when you invoke it.
-;;
-;; Aside from the general features offered by comint such as
-;; command history editing and job control, inferior S mode
-;; allows you to dump and load S objects into and from external
-;; files, and to display help on functions.  It also provides
-;; name completion while you do these.  For more detailed
-;; information see the documentation strings for inferior-ess,
-;; inferior-ess-mode, ess-mode, and comint-mode.  There are also
-;; many variables and hooks available for customizing (see
-;; the variables below that have document strings that start
-;; with an "*").
-
-;; INSTALLATION
-;; See README and S-site for details.
-
-;; GETTING RELEASES OF ESS
-;; ===> http://ess.r-project.org
-;;
-
-;; CREDITS.
-;; Thanks to shiba@shun.isac.co.jp (Ken'ichi "Modal" Shibayama) for
-;;   the indenting code.
-;; Thanks also to maechler@stat.math.ethz.ch (Martin Maechler) for
-;;   suggestions and bug fixes.
-;; ess-eval-line-and-step is based on a function by Rod Ball
-;;   (rod@marcam.dsir.govt.nz)
-;; Also thanks from David Smith to the previous authors for all their
-;; help and suggestions.
-;; And thanks from Richard M. Heiberger, Kurt Hornik, Martin
-;; Maechler, and A.J. Rossini to David Smith.
-
-;; BUG REPORTS
-;; Please report bugs to ess-bugs@r-project.org
-;; Comments, suggestions, words of praise and large cash donations
-;; are also more than welcome, but should generally be split between
-;; all authors :-).
-
-;;; Code:
-
-(require 'ess-site)
-
-(provide 'ess)
-
-;;; ess.el ends here

elpa/ess-20180717.825/allnews.info

@@ -3,6 +3,14 @@ allnews.texi.
 
 Changes and New Features in development version:
 
+   * ESS[R]: Interaction with inferior process in non-R files within
+     packages (for instance C or C++ files) has been improved.  This is
+     a work in progress.
+
+   * ESS[R]: 'ess-r-package-use-dir' (which sets the working directory
+     to the root of the current package) now works with any mode (e.g.
+     in C or C++ files within '/src').
+
    * This is the last release to support Emacs older than 25.1 Going
      forward, only GNU Emacs 25.1 and newer will be supported.  Soon
      after this release, support for older Emacs versions will be
@@ -104,15 +112,32 @@ Changes and New Features in development version:
      customization to 'inferior-ess-R-program'.  These variables are
      treated as risky variables.
 
-   * Customization of ess-smart-S-assign-key has been reworked.  Use
+   * 'ess-smart-S-assign' changed name to 'ess-insert-S-assign'.  By
-     '(setq ess-smart-S-assign-key nil)' to disable smart assignment at
+     default, it provides similar functionality.  Since many users
-     any time instead of '(ess-toggle-underscore nil)'.  To use another
+     dislike this functionality, it is easier to disable; set
-     key, you should set the value of 'ess-smart-S-assign-key' before
+     'ess-smart-S-assign-key' to nil.  The following functions have been
-     ESS is loaded.  The following functions have been made obsolete.
+     made obsolete and will be removed in the next release of ESS:
-     You should customize ess-smart-S-assign-key instead:
+     ess-smart-S-assign, ess-toggle-S-assign, ess-toggle-S-assign-key,
-     ess-toggle-S-assign, ess-toggle-S-assign-key,
+     ess-disable-smart-S-assign.
-     ess-unset-smart-S-assign-key, ess-activate-smart-S-assign-key,
+
-     ess-disable-smart-S-assign
+   * The option ess-S-assign has been removed.  Customize new option
+     'ess-assign-list' instead.
+
+   * 'C-c C-=' is now bound to 'ess-cycle-assignment' by default See the
+     docstring for details.  New user customization option
+     'ess-assign-list' controls what assignment operators are cycled
+     through.
+
+   * The ESS initialization process has been further streamlined.  If
+     you update the autoloads (which installation from 'package-install'
+     does), you should not need to '(require 'ess-site)' at all, as
+     autoloads should automatically load ESS when it is needed (e.g.
+     the first time an R buffer is opened).  In order to defer loading
+     your ESS config, you may want to do something like
+     '(with-require-after-load "ess" <ess-config-here>)' in your Emacs
+     init file.  Users of the popular 'use-package' Emacs package can
+     now do '(use-package ess :defer t)' to take advantage of this
+     behavior.
 
    Changes and New Features in 17.11:
 

elpa/ess-20180717.825/announc.info

@@ -215,6 +215,14 @@ File: announc.info,  Node: New Features,  Prev: License,  Up: Announce
 
 Changes and New Features in development version:
 
+   * ESS[R]: Interaction with inferior process in non-R files within
+     packages (for instance C or C++ files) has been improved.  This is
+     a work in progress.
+
+   * ESS[R]: 'ess-r-package-use-dir' (which sets the working directory
+     to the root of the current package) now works with any mode (e.g.
+     in C or C++ files within '/src').
+
    * This is the last release to support Emacs older than 25.1 Going
      forward, only GNU Emacs 25.1 and newer will be supported.  Soon
      after this release, support for older Emacs versions will be
@@ -316,15 +324,32 @@ Changes and New Features in development version:
      customization to 'inferior-ess-R-program'.  These variables are
      treated as risky variables.
 
-   * Customization of ess-smart-S-assign-key has been reworked.  Use
+   * 'ess-smart-S-assign' changed name to 'ess-insert-S-assign'.  By
-     '(setq ess-smart-S-assign-key nil)' to disable smart assignment at
+     default, it provides similar functionality.  Since many users
-     any time instead of '(ess-toggle-underscore nil)'.  To use another
+     dislike this functionality, it is easier to disable; set
-     key, you should set the value of 'ess-smart-S-assign-key' before
+     'ess-smart-S-assign-key' to nil.  The following functions have been
-     ESS is loaded.  The following functions have been made obsolete.
+     made obsolete and will be removed in the next release of ESS:
-     You should customize ess-smart-S-assign-key instead:
+     ess-smart-S-assign, ess-toggle-S-assign, ess-toggle-S-assign-key,
-     ess-toggle-S-assign, ess-toggle-S-assign-key,
+     ess-disable-smart-S-assign.
-     ess-unset-smart-S-assign-key, ess-activate-smart-S-assign-key,
+
-     ess-disable-smart-S-assign
+   * The option ess-S-assign has been removed.  Customize new option
+     'ess-assign-list' instead.
+
+   * 'C-c C-=' is now bound to 'ess-cycle-assignment' by default See the
+     docstring for details.  New user customization option
+     'ess-assign-list' controls what assignment operators are cycled
+     through.
+
+   * The ESS initialization process has been further streamlined.  If
+     you update the autoloads (which installation from 'package-install'
+     does), you should not need to '(require 'ess-site)' at all, as
+     autoloads should automatically load ESS when it is needed (e.g.
+     the first time an R buffer is opened).  In order to defer loading
+     your ESS config, you may want to do something like
+     '(with-require-after-load "ess" <ess-config-here>)' in your Emacs
+     init file.  Users of the popular 'use-package' Emacs package can
+     now do '(use-package ess :defer t)' to take advantage of this
+     behavior.
 
    Changes and New Features in 17.11:
 

elpa/ess-20180717.825/ess-autoloads.el

@@ -5,6 +5,113 @@
 (add-to-list 'load-path (directory-file-name
                          (or (file-name-directory #$) (car load-path))))
 
+
+;;;### (autoloads nil "ess" "ess.el" (0 0 0 0))
+;;; Generated autoloads from ess.el
+
+(autoload 'ess-mode "ess" "\
+Major mode for editing ESS source.
+Optional arg ALIST describes how to customize the editing mode.
+Optional arg PROC-NAME is name of associated inferior process.
+
+\\{ess-mode-map}
+
+Extra binding to note:  'ESC C-\\' indent-region.
+
+Entry to this mode runs the hooks in ess-mode-hook.
+
+You can send text to the inferior ESS process from other buffers containing
+ESS source.
+    `ess-eval-region' sends the current region to the ESS process.
+    `ess-eval-buffer' sends the current buffer to the ESS process.
+    `ess-eval-function' sends the current function to the ESS process.
+    `ess-eval-line' sends the current line to the ESS process.
+    `ess-beginning-of-function' and `ess-end-of-function' move the point to
+        the beginning and end of the current ESS function.
+    `ess-switch-to-ESS' switches the current buffer to the ESS process buffer.
+    `ess-switch-to-end-of-ESS' switches the current buffer to the ESS process
+        buffer and puts point at the end of it.
+
+    `ess-eval-region-and-go', `ess-eval-buffer-and-go',
+        `ess-eval-function-and-go', and `ess-eval-line-and-go' switch to the S
+        process buffer after sending their text.
+
+    `ess-load-file' sources a file of commands to the ESS process.
+
+\\[ess-indent-command] indents for ESS code.
+\\[backward-delete-char-untabify] converts tabs to spaces as it moves back.
+Comments are indented in a similar way to Emacs-lisp mode:
+       `###'     beginning of line
+       `##'      the same level of indentation as the code
+       `#'       the same column on the right, or to the right of such a
+                 column if that is not possible.(default value 40).
+                 \\[indent-for-comment] command automatically inserts such a
+                 `#' in the right place, or aligns such a comment if it is
+                 already inserted.
+\\[ess-indent-exp] command indents each line of the syntactic unit following point.
+
+Variables controlling indentation style:
+ `ess-tab-always-indent'
+    Non-nil means TAB in ESS mode should always reindent the current line,
+    regardless of where in the line point is when the TAB command is used.
+ `ess-auto-newline'
+    Non-nil means automatically newline before and after braces inserted in S
+    code.
+ `ess-indent-offset'
+    Indentation of ESS statements within surrounding block.
+    The surrounding block's indentation is the indentation of the line on
+    which the open-brace appears.
+ `ess-offset-block'
+    Indentation of blocks opened with curly braces or anonymous parentheses.
+ `ess-offset-arguments'
+    Indentation of function arguments or bracket indices.
+ `ess-offset-arguments-newline'
+    Indentation of function arguments or bracket indices when the opening
+    delimiter is immediately followed by a newline.
+ `ess-offset-continued'
+    Indentation style for continued statements.
+ `ess-align-nested-calls'
+    Functions whose nested calls should be aligned.
+ `ess-align-arguments-in-calls'
+    Calls in which arguments should be aligned.
+ `ess-align-continuations-in-calls'
+    Whether ignore indentation after an operator in calls
+ `ess-align-blocks'
+    Blocks that should always be aligned vertically.
+ `ess-indent-from-lhs'
+    Whether function calls given as argument should be indented from the
+    parameter name.
+ `ess-indent-from-chain-start'
+    Whether to indent arguments from the first of several consecutive calls.
+ `ess-indent-with-fancy-comments'
+    Non-nil means distinguish between #, ##, and ### for indentation.
+
+Furthermore, \\[ess-set-style] command enables you to set up predefined ess-mode
+indentation style. At present, predefined style are `BSD', `GNU', `K&R', `C++',
+`CLB' (quoted from C language style).
+
+\(fn &optional ALIST PROC-NAME IS-DERIVED)" nil nil)
+
+(autoload 'ess-parse-errors "ess" "\
+Jump to error in last loaded ESS source file.
+With prefix argument, only shows the errors ESS reported.
+
+RESET is for compatibility with `next-error' and is ignored.
+
+\(fn &optional SHOWERR RESET)" t nil)
+
+(autoload 'ess-dump-object-into-edit-buffer "ess" "\
+Edit an ESS OBJECT in its own buffer.
+Without a prefix argument, this simply finds the file pointed to by
+`ess-source-directory'.  If this file does not exist, or if a
+prefix argument is given, a dump() command is sent to the ESS process to
+generate the source buffer.
+
+\(fn OBJECT)" t nil)
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ess" '("ess-")))
+
+;;;***
 
 ;;;### (autoloads nil "ess-arc-d" "ess-arc-d.el" (0 0 0 0))
 ;;; Generated autoloads from ess-arc-d.el
@@ -270,113 +377,6 @@ ESS[JAGS]: Major mode for JAGS.
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ess-lsp-l" '("Lisp-editing-alist")))
 
-;;;***
-
-;;;### (autoloads nil "ess-mode" "ess-mode.el" (0 0 0 0))
-;;; Generated autoloads from ess-mode.el
-
-(autoload 'ess-mode "ess-mode" "\
-Major mode for editing ESS source.
-Optional arg ALIST describes how to customize the editing mode.
-Optional arg PROC-NAME is name of associated inferior process.
-
-\\{ess-mode-map}
-
-Extra binding to note:  'ESC C-\\' indent-region.
-
-Entry to this mode runs the hooks in ess-mode-hook.
-
-You can send text to the inferior ESS process from other buffers containing
-ESS source.
-    `ess-eval-region' sends the current region to the ESS process.
-    `ess-eval-buffer' sends the current buffer to the ESS process.
-    `ess-eval-function' sends the current function to the ESS process.
-    `ess-eval-line' sends the current line to the ESS process.
-    `ess-beginning-of-function' and `ess-end-of-function' move the point to
-        the beginning and end of the current ESS function.
-    `ess-switch-to-ESS' switches the current buffer to the ESS process buffer.
-    `ess-switch-to-end-of-ESS' switches the current buffer to the ESS process
-        buffer and puts point at the end of it.
-
-    `ess-eval-region-and-go', `ess-eval-buffer-and-go',
-        `ess-eval-function-and-go', and `ess-eval-line-and-go' switch to the S
-        process buffer after sending their text.
-
-    `ess-load-file' sources a file of commands to the ESS process.
-
-\\[ess-indent-command] indents for ESS code.
-\\[backward-delete-char-untabify] converts tabs to spaces as it moves back.
-Comments are indented in a similar way to Emacs-lisp mode:
-       `###'     beginning of line
-       `##'      the same level of indentation as the code
-       `#'       the same column on the right, or to the right of such a
-                 column if that is not possible.(default value 40).
-                 \\[indent-for-comment] command automatically inserts such a
-                 `#' in the right place, or aligns such a comment if it is
-                 already inserted.
-\\[ess-indent-exp] command indents each line of the syntactic unit following point.
-
-Variables controlling indentation style:
- `ess-tab-always-indent'
-    Non-nil means TAB in ESS mode should always reindent the current line,
-    regardless of where in the line point is when the TAB command is used.
- `ess-auto-newline'
-    Non-nil means automatically newline before and after braces inserted in S
-    code.
- `ess-indent-offset'
-    Indentation of ESS statements within surrounding block.
-    The surrounding block's indentation is the indentation of the line on
-    which the open-brace appears.
- `ess-offset-block'
-    Indentation of blocks opened with curly braces or anonymous parentheses.
- `ess-offset-arguments'
-    Indentation of function arguments or bracket indices.
- `ess-offset-arguments-newline'
-    Indentation of function arguments or bracket indices when the opening
-    delimiter is immediately followed by a newline.
- `ess-offset-continued'
-    Indentation style for continued statements.
- `ess-align-nested-calls'
-    Functions whose nested calls should be aligned.
- `ess-align-arguments-in-calls'
-    Calls in which arguments should be aligned.
- `ess-align-continuations-in-calls'
-    Whether ignore indentation after an operator in calls
- `ess-align-blocks'
-    Blocks that should always be aligned vertically.
- `ess-indent-from-lhs'
-    Whether function calls given as argument should be indented from the
-    parameter name.
- `ess-indent-from-chain-start'
-    Whether to indent arguments from the first of several consecutive calls.
- `ess-indent-with-fancy-comments'
-    Non-nil means distinguish between #, ##, and ### for indentation.
-
-Furthermore, \\[ess-set-style] command enables you to set up predefined ess-mode
-indentation style. At present, predefined style are `BSD', `GNU', `K&R', `C++',
-`CLB' (quoted from C language style).
-
-\(fn &optional ALIST PROC-NAME IS-DERIVED)" nil nil)
-
-(autoload 'ess-parse-errors "ess-mode" "\
-Jump to error in last loaded ESS source file.
-With prefix argument, only shows the errors ESS reported.
-
-RESET is for compatibility with `next-error' and is ignored.
-
-\(fn &optional SHOWERR RESET)" t nil)
-
-(autoload 'ess-dump-object-into-edit-buffer "ess-mode" "\
-Edit an ESS OBJECT in its own buffer.
-Without a prefix argument, this simply finds the file pointed to by
-`ess-source-directory'.  If this file does not exist, or if a
-prefix argument is given, a dump() command is sent to the ESS process to
-generate the source buffer.
-
-\(fn OBJECT)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ess-mode" '("ess-")))
-
 ;;;***
 
 ;;;### (autoloads nil "ess-mouse" "ess-mouse.el" (0 0 0 0))
@@ -926,8 +926,7 @@ Popup a menu of functions to run on selected string or region.
 
 ;;;***
 
-;;;### (autoloads nil nil ("ess-julia.el" "ess-pkg.el" "ess.el")
+;;;### (autoloads nil nil ("ess-julia.el" "ess-pkg.el") (0 0 0 0))
-;;;;;;  (0 0 0 0))
 
 ;;;***
 

elpa/ess-20180717.825/ess-bugs-d.el

@@ -27,7 +27,7 @@
 (require 'ess-utils)
 (require 'ess-inf)
 (require 'ess-custom)
-(require 'ess-mode)
+(require 'ess)
 
 (setq auto-mode-alist
       (append '(("\\.[bB][uU][gG]\\'" . ess-bugs-mode)) auto-mode-alist))

elpa/ess-20180717.825/ess-custom.el

@@ -549,12 +549,6 @@ ess-smart-comma only, but will be enriched in the near future.")
 Used to avoid annoying jumping by ess-eval.*-and-step to end of
 buffer or end chunks etc.")
 
-(defcustom ess-S-assign " <- "
-  "String used for left assignment in all S dialects.
-Used by \\[ess-smart-S-assign]."
-  :group 'ess-S
-  :type 'string)
-
 (defcustom ess-smart-S-assign-key "_"
   "Key used by `ess-smart-S-assign'.
 Should be nil or a \"simple\" key, in other words no key
@@ -565,6 +559,19 @@ to another string, it must be set before ESS is loaded."
   :group 'ess-S
   :type '(choice (const :tag "Nothing" :value nil) string))
 
+(defcustom ess-assign-list (cons (if (boundp 'ess-S-assign) ess-S-assign " <- ")
+                                 '(" <<- " " = " " -> " " ->> "))
+  "List of assignment operators.
+`ess-cycle-assignment' uses this list.  These strings must
+contain spaces on either side."
+  ;; Note that spaces on either side is not strictly true (as in the
+  ;; function won't error), but matching <-/<<- is broken without
+  ;; them.
+  :type '(repeat string)
+  :group 'ess)
+(defvar ess-S-assign)
+(make-obsolete-variable 'ess-S-assign 'ess-assign-list "2018-07-01")
+
 (defcustom ess-r-prettify-symbols
   '(("<-" . (?\s (Br . Bl) ?\s (Bc . Bc) ?←))
     ("->" . (?\s (Br . Bl) ?\s (Bc . Bc) ?→))

elpa/ess-20180717.825/ess-help.el

@@ -44,7 +44,7 @@
   (require 'ess-inf)
   (require 'info))
 
-(require 'ess-mode)
+(require 'ess)
 
  ; ess-help-mode
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -989,7 +989,7 @@ option for other dialects)."
 (defun ess-submit-bug-report ()
   "Submit a bug report on the ess-mode package."
   (interactive)
-  (require 'ess-mode)
+  (require 'ess)
   (require 'reporter)
   (let ((reporter-prompt-for-summary-p 't))
     (reporter-submit-bug-report

elpa/ess-20180717.825/ess-inf.el

@@ -1303,7 +1303,7 @@ type of the region."
          (file (if ess-microsoft-p
                    (ess-replace-in-string file "[\\]" "/")
                  file)))
-    file))
+    (abbreviate-file-name file)))
 
 (defun ess-load-file--normalise-buffer (file)
   (when (ess-check-source file)
@@ -1952,12 +1952,12 @@ for `ess-eval-region'."
     (define-key map "\M-?"     'ess-list-object-completions)
     (define-key map "\C-c\C-k" 'ess-request-a-process)
     (define-key map ","        'ess-smart-comma)
-
+    (define-key map (kbd "C-c C-=") 'ess-cycle-assignment)
     (define-key map "\C-c\C-d"   'ess-doc-map)
     (define-key map "\C-c\C-e"   'ess-extra-map)
     (define-key map "\C-c\C-t"   'ess-dev-map)
     (when ess-smart-S-assign-key
-      (define-key map ess-smart-S-assign-key #'ess-smart-S-assign))
+      (define-key map ess-smart-S-assign-key 'ess-insert-assign))
     map)
   "Keymap for `inferior-ess' mode.")
 
@@ -1992,7 +1992,7 @@ for `ess-eval-region'."
      ["Jump to Error"           ess-parse-errors        t]
      ["Load source file"    ess-load-file           t]
      ["Resynch S completions"	ess-resynch		t]
-     ["Recreate R and S versions known to ESS" (ess-r-s-versions-creation+menu) t]
+     ;; ["Recreate R and S versions known to ESS" (ess-r-s-versions-creation+menu) t]
      )
     "------"
     ("start-dev" :visible nil); <-- ??
@@ -2200,14 +2200,11 @@ to continue it."
   "Sends the command on the current line to the ESS process."
   (interactive)
   (run-hooks 'ess-send-input-hook)
-  ;; (let ((proc (get-buffer-process (current-buffer))))
+  (unless (ess-process-get 'busy)
-  ;;   (if (not proc)
+    ;; avoid new line insertion
-  ;;       (user-error "Current buffer has no process")
+    (ess-process-put 'prev-prompt nil))
-  ;;     (let ((comint-process-echoes (or comint-process-echoes
-  ;;                                      (< (point) (marker-position (process-mark proc))))))
-  ;;       (comint-send-input))))
   (comint-send-input)
-  (setq ess-object-list nil)) ;; Will be reconstructed from cache if needs be
+  (setq ess-object-list nil))
 
 (defun inferior-ess--goto-input-start:field ()
   "Move point to the begining of input skiping all continuation lines.
@@ -2637,6 +2634,7 @@ command (%s) like this, or a version with explicit options(max.print=1e6):
 
 local({ out <- try({%s}); print(out, max=1e6) })\n
 "
+  (inferior-ess-force)
   (let* ((tbuffer (get-buffer-create
                    " *ess-get-words*")); initial space: disable-undo
          (word-RE
@@ -3034,12 +3032,12 @@ prefix argument NO-FORCE-CURRENT is non-nil."
   (let ((dir (if buffer-file-name
                  (file-name-directory buffer-file-name)
                default-directory)))
-    (ess-set-working-directory dir)))
+    (ess-set-working-directory (abbreviate-file-name dir))))
 
 (defun ess-get-working-directory (&optional no-error)
   "Retrive the current working directory from the current ess process."
   (if ess-getwd-command
-      (car (ess-get-words-from-vector ess-getwd-command))
+      (abbreviate-file-name (car (ess-get-words-from-vector ess-getwd-command)))
     (unless no-error
       (error "Not implemented for dialect %s" ess-dialect))))
 

elpa/ess-20180717.825/ess-pkg.el

@@ -0,0 +1,4 @@
+(define-package "ess" "20180717.825" "Emacs Speaks Statistics" 'nil)
+;; Local Variables:
+;; no-byte-compile: t
+;; End:

elpa/ess-20180717.825/ess-r-mode.el

@@ -38,7 +38,7 @@
 (require 'compile)
 (require 'easymenu)
 (require 'eldoc)
-(require 'ess-mode)
+(require 'ess)
 (require 'ess-help)
 (require 'ess-s-lang)
 (require 'ess-roxy)
@@ -434,90 +434,10 @@ Set this variable to nil to disable searching for other versions of R.
 If you set this variable, you need to restart Emacs (and set this variable
 before ess-site is loaded) for it to take effect.")
 
-;; Create functions for calling different (older or newer than default)
-;; versions of R and S(qpe).
-(defvar ess-versions-created nil
-  "List of strings of all S- and R-versions found on the system.")
-
 (defvar ess-r-created-runners nil
   "List of R-versions found from `ess-r-versions' on the system.")
 (define-obsolete-variable-alias 'ess-r-versions-created 'ess-r-created-runners "2018-05-05")
 
-(defun ess-r-s-define-runners ()
-  "(Re)Create ESS R-X.Y.Z and S-X.Y.Z commands.
-See `ess-r-versions' and `ess-s-versions' for which functions
-will be (re)created."
-  (interactive)
-  (let ((R-newest-list '("R-newest"))
-        (ess-s-created-runners
-         (if ess-microsoft-p
-             (nconc
-              (ess-sqpe-versions-create ess-SHOME-versions) ;; 32-bit
-              (ess-sqpe-versions-create ess-SHOME-versions-64 "-64-bit")) ;; 64-bit
-           (require 'ess-sp6-d)
-           (ess-s-define-runners))))
-    (when ess-microsoft-p
-      (setq ess-rterm-version-paths
-            (ess-flatten-list
-             (ess-uniq-list
-              (if (not ess-directory-containing-R)
-                  (if (getenv "ProgramW6432")
-                      (let ((P-1 (getenv "ProgramFiles(x86)"))
-                            (P-2 (getenv "ProgramW6432")))
-                        (nconc
-                         ;; Always 32 on 64 bit OS, nil on 32 bit OS
-                         (ess-find-rterm (concat P-1 "/R/") "bin/Rterm.exe")
-                         (ess-find-rterm (concat P-1 "/R/") "bin/i386/Rterm.exe")
-
-                         ;; Keep this both for symmetry and because it can happen:
-                         (ess-find-rterm (concat P-1 "/R/") "bin/x64/Rterm.exe")
-
-                         ;; Always 64 on 64 bit OS, nil on 32 bit OS
-                         (ess-find-rterm (concat P-2 "/R/") "bin/Rterm.exe")
-                         (ess-find-rterm (concat P-2 "/R/") "bin/i386/Rterm.exe")
-                         (ess-find-rterm (concat P-2 "/R/") "bin/x64/Rterm.exe")))
-                    (let ((PF (getenv "ProgramFiles")))
-                      (nconc
-                       ;; Always 32 on 32 bit OS, depends on 32 or 64 process on 64 bit OS
-                       (ess-find-rterm (concat PF "/R/") "bin/Rterm.exe")
-                       (ess-find-rterm (concat PF "/R/") "bin/i386/Rterm.exe")
-                       (ess-find-rterm (concat PF "/R/") "bin/x64/Rterm.exe"))))
-                (let ((PF ess-directory-containing-R))
-                  (nconc
-                   (ess-find-rterm (concat PF "/R/") "bin/Rterm.exe")
-                   (ess-find-rterm (concat PF "/R/") "bin/i386/Rterm.exe")
-                   (ess-find-rterm (concat PF "/R/") "bin/x64/Rterm.exe"))))))))
-    (ess-r-define-runners)
-    ;; Add the new defuns, if any, to the menu.
-    ;; Check that each variable exists, before adding.
-    ;; e.g. ess-sqpe-versions-created will not be created on Unix.
-    (setq ess-versions-created
-          (ess-flatten-list
-           (mapcar (lambda(x) (if (boundp x) (symbol-value x) nil))
-                   '(R-newest-list
-                     ess-r-created-runners
-                     ess-s-created-runners))))))
-(define-obsolete-function-alias
-  'ess-r-s-versions-creation 'ess-r-s-define-runners "2018-5-12")
-
-(defun ess-r-s-define-runners+menu ()
-  "Set up R-X.Y.Z and S-X.Y.Z functions and add them to the menu.
-Call `\\[ess-r-s-define-runners] creating `ess-versions-created' and
-update the \"Start Process\" menu."
-  (interactive)
-  (ess-r-s-define-runners)
-  (when ess-versions-created
-    ;; new-menu will be a list of 3-vectors, of the form:
-    ;; ["R-1.8.1" R-1.8.1 t]
-    (let ((new-menu (mapcar (lambda(x) (vector x (intern x) t))
-                            ess-versions-created)))
-      (easy-menu-add-item ess-mode-menu '("Start Process")
-                          (cons "Other" new-menu))))
-  ess-versions-created)
-(define-obsolete-function-alias
-  'ess-r-s-versions-creation+menu 'ess-r-s-define-runners+menu "2018-05-12")
-
-
 ;;;*;;; Mode init
 
 (defvar ess-r-post-run-hook nil
@@ -738,8 +658,18 @@ as `ess-r-created-runners' upon ESS initialization."
                              (mapcar #'ess-find-exec-completions
                                      ess-r-versions)))))))
       ;; Iterate over each string in VERSIONS, creating a new defun each time.
-      (setq ess-r-created-runners
+      (setq ess-r-created-runners versions)
-            (mapc (lambda (v) (ess-define-runner v "R")) versions)))))
+    (if ess-microsoft-p
+        (cl-mapcar (lambda (v p) (ess-define-runner v "R" p)) versions ess-rterm-version-paths)
+      (mapc (lambda (v) (ess-define-runner v "R")) versions))
+    ;; Add to menu
+    (when ess-r-created-runners
+      ;; new-menu will be a list of 3-vectors, of the form:
+      ;; ["R-1.8.1" R-1.8.1 t]
+      (let ((new-menu (mapcar (lambda(x) (vector x (intern x) t))
+                              ess-r-created-runners)))
+        (easy-menu-add-item ess-mode-menu '("Start Process")
+                            (cons "Other" new-menu)))))))
 (define-obsolete-function-alias
   'ess-r-versions-create 'ess-r-define-runners "2018-05-12")
 
@@ -2219,6 +2149,42 @@ otherwise nil."
       (undo-boundary))))
 
 
+
+;; Create functions that can be called for running different versions
+;; of R.
+;; FIXME: Should be set in ess-custom
+(setq ess-rterm-version-paths
+      (ess-flatten-list
+       (ess-uniq-list
+        (if (not ess-directory-containing-R)
+            (if (getenv "ProgramW6432")
+                (let ((P-1 (getenv "ProgramFiles(x86)"))
+                      (P-2 (getenv "ProgramW6432")))
+                  (nconc
+                   ;; Always 32 on 64 bit OS, nil on 32 bit OS
+                   (ess-find-rterm (concat P-1 "/R/") "bin/Rterm.exe")
+                   (ess-find-rterm (concat P-1 "/R/") "bin/i386/Rterm.exe")
+
+                   ;; Keep this both for symmetry and because it can happen:
+                   (ess-find-rterm (concat P-1 "/R/") "bin/x64/Rterm.exe")
+
+                   ;; Always 64 on 64 bit OS, nil on 32 bit OS
+                   (ess-find-rterm (concat P-2 "/R/") "bin/Rterm.exe")
+                   (ess-find-rterm (concat P-2 "/R/") "bin/i386/Rterm.exe")
+                   (ess-find-rterm (concat P-2 "/R/") "bin/x64/Rterm.exe")))
+              (let ((PF (getenv "ProgramFiles")))
+                (nconc
+                 ;; Always 32 on 32 bit OS, depends on 32 or 64 process on 64 bit OS
+                 (ess-find-rterm (concat PF "/R/") "bin/Rterm.exe")
+                 (ess-find-rterm (concat PF "/R/") "bin/i386/Rterm.exe")
+                 (ess-find-rterm (concat PF "/R/") "bin/x64/Rterm.exe"))))
+          (let ((PF ess-directory-containing-R))
+            (nconc
+             (ess-find-rterm (concat PF "/R/") "bin/Rterm.exe")
+             (ess-find-rterm (concat PF "/R/") "bin/i386/Rterm.exe")
+             (ess-find-rterm (concat PF "/R/") "bin/x64/Rterm.exe")))))))
+(ess-r-define-runners)
+
 ;;*;; Provide and auto-loads
 
 ;;;###autoload

elpa/ess-20180717.825/ess-r-package.el

@@ -189,7 +189,7 @@ Root is determined by locating `ess-r-package-root-file'."
   "Set process directory to current package directory."
   (interactive)
   (let ((dir (cdr (ess-r-package-project))))
-    (ess-set-working-directory dir)))
+    (ess-set-working-directory (abbreviate-file-name dir))))
 
 (defun ess-r-package-set-package ()
   "Set a package for ESS r-package commands."
@@ -245,7 +245,7 @@ arguments, or expressions which return R arguments."
   (let* ((pkg-info (or (ess-r-package-project)
                        (ess-r-package-set-package)))
          (pkg-name (ess-r-package-name))
-         (pkg-path (or pkg-path (concat "'" (cdr pkg-info) "'")))
+         (pkg-path (or pkg-path (concat "'" (abbreviate-file-name (cdr pkg-info)) "'")))
          (args (ess-r-command--build-args p actions)))
     (message msg pkg-name)
     (with-ess-process-buffer nil
@@ -472,6 +472,16 @@ disable the mode line entirely."
   :lighter ess-r-package-mode-line
   (if ess-r-package-mode
       (progn
+        ;; Forward relevant R settings for interacting with inferior
+        ;; processes from any mode
+        (let ((vars '(ess-dialect
+                      ess-setwd-command
+                      ess-getwd-command
+                      ess-quit-function
+                      inferior-ess-reload-function)))
+          (mapc (lambda (var) (set (make-local-variable var)
+                              (eval (cdr (assq var ess-r-customize-alist)))))
+                vars))
         (add-hook 'project-find-functions #'ess-r-package-project)
         (run-hooks 'ess-r-package-enter-hook))
     (remove-hook 'project-find-functions #'ess-r-package-project)

elpa/ess-20180717.825/ess-rutils.el

@@ -46,12 +46,15 @@
 ;; on a *lot* of ideas from ess-rdired.el.
 
 ;; TODO: Refactor and remove byte-compile-warnings file-local variable.
+;; TODO: This should be more tightly integrated with ess-r-mode and ESSR.
+;; TODO: Should be active in ess-r-mode not only ess-inf
+;; TODO: Both S level Utils and this package's Rutils are in the menu; confusing and inconvenient.
 (defvar pkg)
 
 ;;; Code:
 
 ;; Autoloads and requires
-(require 'ess-site)
+(require 'ess-r-mode)
 (require 'ess-rdired)
 
 (defvar ess-rutils-buf "*R temp*"
@@ -60,14 +63,7 @@
 (defvar ess-rutils-mode-map nil
   "Keymap for the *R temp* buffer.")
 
-(defvar ess-rutils-rhtml-fn
+(unless ess-rutils-mode-map
-  (expand-file-name "ess-rutils-help-start.R" ess-etc-directory)
-  "Path to the file defining the R function .rutils.help.start().
-This file is loaded into the inferior R process so that
-`ess-rutils-html-docs' can use .rutils.help.start().")
-
-(if ess-rutils-mode-map
-    ()
   (setq ess-rutils-mode-map (make-sparse-keymap))
   (define-key ess-rutils-mode-map "l" 'ess-rutils-loadpkg)
   (define-key ess-rutils-mode-map "i" 'ess-rutils-mark-install)
@@ -289,17 +285,16 @@ File extension not required."
 
 (defun ess-rutils-html-docs (&optional remote)
   "Use `browse-url' to navigate R html documentation.
-Documentation is produced by a modified help.start(), that returns the URL
+Documentation is produced by a modified help.start(), that
-produced by GNU R's http server.  This function is defined in a file given
+returns the URL produced by GNU R's http server. If called with a
-by the path in variable `ess-rutils-rhtml-fn'.  If called with a prefix,
+prefix, the modified help.start() is called with update=TRUE. The
-the modified help.start() is called with update=TRUE.  The optional REMOTE
+optional REMOTE argument should be a string with a valid URL for
-argument should be a string with a valid URL for the 'R_HOME' directory on
+the 'R_HOME' directory on a remote server (defaults to NULL)."
-a remote server (defaults to NULL)."
   (interactive)
   (let* ((update (if current-prefix-arg "update=TRUE" "update=FALSE"))
          (remote (if (or (and remote (not (string= "" remote))))
                      (concat "remote=" remote) "remote=NULL"))
-         (rhtml (format ".rutils.help.start(%s, %s)\n" update remote))
+         (rhtml (format ".ess_help_start(%s, %s)\n" update remote))
          (tmpbuf (get-buffer-create "**ess-rutils-mode**")))
     (ess-command rhtml tmpbuf)
     (set-buffer tmpbuf)
@@ -422,14 +417,10 @@ Options should be separated by value of `crm-default-separator'."
     ["Browse HTML"             ess-rutils-html-docs     t]
     ["Apropos"                 ess-rutils-apropos       t]))
 
-(easy-menu-add-item inferior-ess-mode-menu nil
+(easy-menu-add-item inferior-ess-mode-menu nil ess-rutils-mode-menu "Utils")
-                    ess-rutils-mode-menu)
+(add-hook 'inferior-ess-mode-hook 'ess-rutils-keys)
-
-(add-hook 'inferior-ess-mode-hook 'ess-rutils-keys t)
-(add-hook 'ess-r-post-run-hook
-          (lambda ()
-            (ess--inject-code-from-file ess-rutils-rhtml-fn)) t)
 
+(make-obsolete 'ess-rutils-rhtml-fn "overwrite .ess_help_start instead." "2018-06")
 
 (provide 'ess-rutils)
 

elpa/ess-20180717.825/ess-s-lang.el

@@ -575,81 +575,65 @@ and one that is well formatted in emacs ess-mode."
     (ess-if-verbose-write "ess-fix-misc __end__\n");___D___
     ))
 
-(defvar polymode-mode)
+(defun ess-cycle-assignment ()
-(defun ess-smart-S-assign (&optional N)
+  "Cycle between assignment symbols in `ess-assign-list'.
-  "Act as smart `ess-S-assign' key.
+On consecutive calls, replace the assignment symbol before point
-Insert `ess-S-assign', unless in string/comment.  If the
+with the next symbol from that list. This function sets the last
-underscore key is pressed a second time, the assignment operator
+keypress to repeat it, so if it is bound to \"C-c C-=\" pressing
-is removed and replaced by the underscore.  `ess-S-assign',
+\"=\" again cycles to the next assignment."
-typically \" <- \", can be customized.  In ESS modes other than
-R/S, the underscore is always inserted.
-
-If `ess-smart-S-assign-key' is nil, just call
-`self-insert-command'. You can pass N as usual."
   (interactive)
+  (if (eq last-command this-command)
+      (let ((slist ess-assign-list)
+            str)
+        (while (and (setq str (car slist)
+                          slist (cdr slist))
+                    (not (and (re-search-backward str
+                                                  (- (point) (length str)) t)
+                              (not (replace-match (car slist))))))))
+    (insert (car ess-assign-list)))
+  (set-transient-map
+   (let ((map (make-sparse-keymap))
+         (key (format "%c" (event-basic-type last-input-event))))
+     (define-key map (kbd key) #'ess-cycle-assignment)
+     map)))
+
+(defun ess-insert-assign (arg)
+  "Insert the first element of `ess-assign-list' unless in string or comment.
+If the character before point is the first element of
+`ess-assign-list', replace it with the last character typed. If
+`ess-smart-S-assign-key' is nil, do `self-insert-command' using
+ARG as the number of times to insert."
+  (interactive "p")
   (if ess-smart-S-assign-key
-      (save-restriction
+      (let* ((assign (car ess-assign-list))
-        (ignore-errors
+             (event (event-basic-type last-input-event))
-          (when (and (eq major-mode 'inferior-ess-mode)
+             (char (ignore-errors (format "%c" event))))
-                     (> (point) (process-mark (get-buffer-process (current-buffer)))))
+        (cond ((and char (ess-inside-string-or-comment-p))
-            (narrow-to-region (process-mark (ess-get-process)) (point-max)))
+               (insert char))
-          (and ess-noweb-mode
+              ((re-search-backward assign (- (point) (length assign)) t)
-               (ess-noweb-in-code-chunk)
+               (if (and char (numberp event))
-               (ess-noweb-narrow-to-chunk))
+                   (replace-match char t t)
-          (and (fboundp 'pm/narrow-to-span)
+                 (replace-match "")))
-               polymode-mode
+              (t (insert assign))))
-               (pm/narrow-to-span)))
+    (funcall #'self-insert-command arg)))
-        (if (or
-             (ess-inside-string-or-comment-p (point))
-             (not (equal ess-language "S")))
-            (insert ess-smart-S-assign-key)
-          (ess-insert-S-assign)))
-    (funcall #'self-insert-command (or N 1))))
 
-(defun ess-insert-S-assign ()
-  "Insert the assignment operator `ess-S-assign', unless it is already there.
-In that case, it is removed and replaced by `ess-smart-S-assign-key'.
-  `ess-S-assign', typically \" <- \", can be customized."
-  (interactive)
-  ;; one keypress produces ess-S-assign; a second keypress will delete
-  ;; ess-S-assign and instead insert _
-  ;; Rather than trying to count a second _ keypress, just check whether
-  ;; the current point is preceded by ess-S-assign.
-  (let ((assign-len (length ess-S-assign)))
-    (if (and
-         (>= (point) (+ assign-len (point-min))) ;check that we can move back
-         (save-excursion
-           (backward-char assign-len)
-           (looking-at ess-S-assign)))
-        ;; If we are currently looking at ess-S-assign, replace it with _
-        (progn
-          (delete-char (- assign-len))
-          (insert ess-smart-S-assign-key))
-      (if (string= ess-smart-S-assign-key "_")
-          (delete-horizontal-space))
-      (insert ess-S-assign))))
-
-(defalias 'ess--activate-smart-S-assign-key 'ignore "")
-(make-obsolete 'ess--activate-smart-S-assign-key
-               "it does nothing. Set `ess-smart-S-assign-key' instead." "2018-06-08")
 (defun ess-disable-smart-S-assign (&rest _ignore)
-  "Disable `ess-smart-S-assign'."
+  "Disable `ess-insert-assign'."
-  (declare (obsolete ess-smart-S-assign-key "2018-06-08"))
+  (declare (obsolete "Use ess-smart-S-assign-key instead." "2018-06-08"))
-  (warn "This function is obsolete, use `ess-smart-S-assign-key' instead.")
   (setq ess-smart-S-assign-key nil))
 
 (defun ess-add-MM-keys ()
   "Define MM's user keys, currently \\<ess-mode-map>\\[ess-insert-function-outline], and
  \\<inferior-ess-mode-map>\\[ess-execute-screen-options]."
   (interactive)
-  (require 'ess-mode); typically unnecessary
+  (require 'ess); typically unnecessary
   (require 'ess-inf); dito
   (define-key inferior-ess-mode-map "\C-cw" 'ess-execute-screen-options)
 
   ;; Make M-- : [Alt] + [-] (in addition to / instead of  "_" = (on US-keyboard) [Shift]+ [-]
   ;; Note this overwrites 'M--' as "negative argument" (still on 'C--'):
-  (define-key ess-mode-map          [?\M--] 'ess-insert-S-assign)
+  (define-key ess-mode-map          [?\M--] 'ess-insert-assign)
-  (define-key inferior-ess-mode-map [?\M--] 'ess-insert-S-assign)
+  (define-key inferior-ess-mode-map [?\M--] 'ess-insert-assign)
   )
 
 
@@ -802,11 +786,12 @@ return it.  Otherwise, return `ess-help-topics-list'."
 
 
 (define-obsolete-function-alias 'ess-toggle-S-assign-key #'ignore "2018-06-08")
-(define-obsolete-function-alias 'ess-smart-underscore 'ess-smart-S-assign "2018-06-08")
+(define-obsolete-function-alias 'ess-smart-underscore 'ess-insert-assign "2018-06-08")
+(define-obsolete-function-alias 'ess-smart-S-assign 'ess-insert-assign "2018-06-21")
+(define-obsolete-function-alias 'ess-insert-S-assign 'ess-insert-assign "2018-07-02")
 
 (define-obsolete-function-alias 'ess-toggle-underscore 'ess-disable-smart-S-assign "2018-06-08")
 (define-obsolete-function-alias 'ess-toggle-S-assign 'ess-disable-smart-S-assign "2018-06-08")
-(define-obsolete-function-alias 'ess--unset-smart-S-assign-key 'ess-disable-smart-S-assign "2018-06-08")
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist '("\\.[Ss]t\\'" . S-transcript-mode))

elpa/ess-20180717.825/ess-sas-a.el

@@ -25,7 +25,7 @@
 
 ;;; Code:
 
-(require 'ess-mode)
+(require 'ess)
 
 ;;; Table of Contents
 ;;; Section 1:  Variable Definitions
@@ -435,13 +435,27 @@ on the way."
                                                                  (file-name-directory ess-sas-file-path)) "\""))))
   (comint-send-input))
 
+(defun ess-sas--change-alist (item value alist)
+  "Modify ALIST to set VALUE to ITEM.
+If there is a pair whose car is ITEM, replace its cdr by VALUE.
+If there is not such pair, create new pair (ITEM . VALUE) and
+return new alist whose car is the new pair and cdr is ALIST.
+\[tomo's ELIS like function]"
+  (let ((pair (assoc item alist)))
+    (if pair
+        (progn
+          (setcdr pair value)
+          alist)
+      (cons (cons item value) alist))))
+
 (defun ess-sas-create-local-variables-alist (&optional file-or-buffer)
   "Create an alist of local variables from file-or-buffer, use the
 current buffer if nil."
-
   (if file-or-buffer (set-buffer (ess-get-file-or-buffer file-or-buffer)))
+  (ess-sas--change-alist 'ess-kermit-remote-directory ess-kermit-remote-directory nil))
 
-  (ess-change-alist 'ess-kermit-remote-directory ess-kermit-remote-directory nil))
+(define-obsolete-function-alias
+  'ess-change-alist 'ess-sas--change-alist "2018-07-06")
 
 (defun ess-sas-data-view-fsview (&optional ess-sas-data)
   "Open a dataset for viewing with PROC FSVIEW."

elpa/ess-20180717.825/ess-sas-l.el

@@ -50,7 +50,6 @@
 ;;; Code:
 
 (require 'ess)
-(require 'ess-mode)
 (require 'ess-custom)
 (require 'ess-sas-a)
 
@@ -137,22 +136,24 @@ A .lst file is a SAS listing file when:
              '(ess-SAS-listing-mode-p . SAS-listing-mode))
 
 (defun SAS-log-mode ()
-  "`ess-transcript-mode' for SAS."
+"`ess-transcript-mode' for SAS."
-  (interactive)
+(interactive)
-  (SAS-mode)
+(SAS-mode)
-  (setq mode-name "ESS[LOG]")
+(setq mode-name "ESS[LOG]")
-  (ess-transcript-minor-mode 1)
+(ess-transcript-minor-mode 1)
-  (setq buffer-read-only t)) ;; to protect the buffer.
+(setq buffer-read-only t) ;; to protect the buffer.
+(buffer-disable-undo))
 
 (defvar sas-mode-local-map nil "contains modified local keymap for SAS")
 (defun SAS-listing-mode()
-  "Fundamental mode with `ess-listing-minor-mode' and read-only."
+"Fundamental mode with `ess-listing-minor-mode' and read-only."
-  (interactive)
+(interactive)
-  (fundamental-mode)
+(fundamental-mode)
-  (setq mode-name "ESS[LST]")
+(setq mode-name "ESS[LST]")
-  (ess-listing-minor-mode 1)
+(ess-listing-minor-mode 1)
-  (use-local-map sas-mode-local-map)
+(use-local-map sas-mode-local-map)
-  (setq buffer-read-only t)) ;; to protect the buffer.
+(setq buffer-read-only t) ;; to protect the buffer.
+(buffer-disable-undo))
 
 (fset 'sas-log-mode        'SAS-log-mode)
 (fset 'SAS-transcript-mode 'SAS-log-mode)

elpa/ess-20180717.825/ess-site.el

@@ -42,9 +42,6 @@
 
 ;;; Code:
 
-;; Provide here; otherwise we'll get infinite loops of (require ..):
-(provide 'ess-site)
-
 ;;;; Load path, autoloads, and major modes
 ;;;; ========================================
 ;;
@@ -95,10 +92,6 @@ for ESS, such as icons.")
   (add-to-list 'Info-default-directory-list (expand-file-name "../doc/info/" ess-lisp-directory)))
 
 
-;; Loads ess-custom.el and more
-(require 'ess)
-
-
 ;;; Loading popular dialects (they should become optional in the future)
 
 ;; R and Julia
@@ -137,20 +130,9 @@ for ESS, such as icons.")
 ;;; Toolbar support
 (require 'ess-toolbar)
 
-;;;  Site Specific setup
-;;;; ===============================================
-
-(eval-after-load "ess-r-mode"
-  '(progn
-     (ess-write-to-dribble-buffer "[ess-site:] before creating ess-versions-* ...")
-     (ess-r-s-define-runners+menu)
-     (ess-write-to-dribble-buffer "[ess-site:] after ess-versions-created ...")))
-
-;; Check to see that inferior-ess-r-program points to a working version
-;; of R; if not, try to find the newest version:
-(ess-check-R-program) ;; -> (ess-find-newest-R) if needed, in ./ess-r-d.el
 (ess-write-to-dribble-buffer "[ess-site:] *very* end ...")
 
 
+(provide 'ess-site)
 
 ;;; ess-site.el ends here

elpa/ess-20180717.825/ess-sp4-d.el

@@ -34,7 +34,7 @@
 
 ;;; Requires and Autoloads:
 
-(require 'ess-mode)
+(require 'ess)
 (require 'ess-inf)
 (require 'ess-s-lang)
 (require 'ess-dde)

elpa/ess-20180717.825/ess-sp6-d.el

@@ -36,7 +36,7 @@
 
 ;;; Code:
 
-(require 'ess-mode)
+(require 'ess)
 (require 'ess-inf)
 (require 'ess-s-lang)
 (require 'ess-dde)
@@ -187,10 +187,26 @@ ESS initialization."
       ;; Iterate over each string in VERSIONS, creating a new defun
       ;; each time.
       (setq ess-s-created-runners
-            (mapc (lambda (v) (ess-define-runner v "S")) versions)))))
+            (mapc (lambda (v) (ess-define-runner v "S")) versions))
+      ;; Add to menu
+      (when ess-s-created-runners
+        ;; new-menu will be a list of 3-vectors, of the form:
+        ;; ["R-1.8.1" R-1.8.1 t]
+        (let ((new-menu (mapcar (lambda (x) (vector x (intern x) t))
+                                ess-s-created-runners)))
+          (easy-menu-add-item ess-mode-menu '("Start Process")
+                              (cons "Other" new-menu)))))))
+;; Define the runners
+(if ess-microsoft-p
+    (nconc
+     (ess-sqpe-versions-create ess-SHOME-versions) ;; 32-bit
+     (ess-sqpe-versions-create ess-SHOME-versions-64 "-64-bit")) ;; 64-bit
+  (ess-s-define-runners))
 (define-obsolete-function-alias
   'ess-s-versions-create 'ess-s-define-runners "2018-05-12")
 
+
+
  ; Provide package
 
 (provide 'ess-sp6-d)

elpa/ess-20180717.825/ess-stata-mode.el

@@ -32,7 +32,7 @@
 
 ;;; Code:
 
-(require 'ess-mode)
+(require 'ess)
 (require 'ess-stata-lang)
 
 (defvar STA-dialect-name "stata"

elpa/ess-20180717.825/ess-swv.el

@@ -81,8 +81,7 @@
 ;;; Autoloads and Requires
 
 (eval-when-compile
-  (require 'ess-custom)
+  (require 'ess-custom))
-  (require 'ess))
 
 (require 'ess-utils)
 (require 'ess-noweb-mode)

elpa/ess-20180717.825/ess-tracebug.el

@@ -80,7 +80,6 @@ Currently only R is supported."
 
 (defcustom ess-tracebug-prefix nil
   "*Key to be used as prefix for all ess-tracebug commands.
-
 Set this to a key cominbation you don't use often, like:
 
  (setq ess-tracebug-prefix \"\\M-t\")
@@ -118,15 +117,13 @@ paragraph, R will report an error."
 
 (defcustom ess-tracebug-enter-hook nil
   "List of functions to call on entry to ess-tracebug mode.
-Use `add-hook' to insert append your functions to this list.
+Use `add-hook' to insert append your functions to this list."
-"
   :group 'ess-tracebug
   :type 'hook)
 
 (defcustom ess-tracebug-exit-hook nil
   "List of functions to call on exit of ess-tracebug mode.
-Use `add-hook' to insert append your functions to this list.
+Use `add-hook' to insert append your functions to this list."
-"
   :group 'ess-tracebug
   :type 'hook)
 
@@ -153,7 +150,6 @@ the outer-most code block.")
 
 (defvar ess-tracebug-original-buffer-marker nil
   "Marker pointing to the beginning of original source code.
-
 If non-nil, tracebug will insert the source references based on
 this location instead of the current buffer. This is useful for
 applications, like org-babel,  that call ess evaluation functions
@@ -1265,14 +1261,9 @@ prompts."
                            (if do-clean
                                (ess--replace-long+-in-prompt prompt (eq pos2 (point-max)))
                              prompt)))
-            ;; insert prompt but avoid comint-output-filter
+            ;; Cannot bypass this call to comint-output-filter function as
-            (with-current-buffer pbuf
+            ;; external tools could rely on prompts (org-babel [#598])
-              (save-restriction
+            (comint-output-filter proc prompt)
-                (widen)
-                (goto-char (process-mark proc))
-                (with-silent-modifications
-                  (insert prompt)
-	              (set-marker (process-mark proc) (point)))))
             (setq prev-prompt (and do-clean prompt)
                   pos1 pos2))
           ;; insert last chunk if any

elpa/ess-20180717.825/ess-utils.el

@@ -1287,15 +1287,14 @@ symbols (like aaa$bbb and aaa@bbb in R)."
         (ess-symbol-start)))))
 
 (defun ess-inside-string-or-comment-p (&optional pos)
-  "Return non-nil if POSition [defaults to (point)] is inside string or comment
+  "Return non-nil if POS is inside a string or comment.
- (according to syntax)."
+POS defaults to `point.'"
-  ;;FIXME (defun ess-calculate-indent ..)  can do that ...
+  (save-excursion
-  (interactive)
+    (let* ((pos (or pos (point)))
-  (setq pos (or pos (point)))
+           (state (syntax-ppss pos)))
-  (let ((ppss (syntax-ppss pos)))
+      (or (nth 3 state) (nth 4 state)))))
-    (or (car (setq ppss (nthcdr 3 ppss)))
+
-        (car (setq ppss (cdr ppss)))
+
-        (nth 3 ppss))))
 
 (defun ess-inside-string-p (&optional pos)
   "Return non-nil if point is inside string (according to syntax)."

elpa/ess-20180717.825/ess.el

@@ -1,4 +1,4 @@
-;;; ess-mode.el --- Support for editing ESS source code
+;;; ess.el --- Emacs Speaks Statistics
 
 ;; Copyright (C) 1989-1994 Doug Bates, Ed Kademan, Frank Ritter, David Smith.
 ;; Copyright (C) 1997--2010 A.J. Rossini, Richard M. Heiberger, Martin
@@ -107,7 +107,8 @@
     (define-key map "\C-c\C-e"   'ess-extra-map)
     (define-key map "\C-c\C-t"   'ess-dev-map)
     (when ess-smart-S-assign-key
-      (define-key map ess-smart-S-assign-key #'ess-smart-S-assign))
+      (define-key map ess-smart-S-assign-key 'ess-insert-assign))
+    (define-key map (kbd "C-c C-=") 'ess-cycle-assignment)
     map)
   "Keymap for `ess-mode'.")
 
@@ -155,7 +156,7 @@
      ["Goto end of process buffer"  ess-switch-to-end-of-ESS        t]
      ["Switch to process buffer"    ess-switch-to-inferior-or-script-buffer t]
      ["Switch Process"   ess-switch-process              t]
-     ["Recreate R and S versions known to ESS" (ess-r-s-versions-creation+menu) t]
+     ;; ["Recreate R and S versions known to ESS" (ess-r-s-versions-creation+menu) t]
      ("Start Process"
       ["R"     R   :help "Start a new R process" :active t]
       ["S"     S   :help "Start a new S process" :active t]
@@ -947,25 +948,29 @@ generate the source buffer."
                   (down-list 1)
                 (error nil)))))))
 
-(defun ess-define-runner (name dialect)
+(defun ess-define-runner (name dialect &optional path)
   "Create a function NAME.
 This function starts the inferior process with the specified
-version.  DIALECT can be \"R,\" \"S,\", \"SAS.\""
+version. DIALECT can be \"R,\" \"S,\", \"SAS.\" If given, PATH
+should be the absolute path to the program. It defaults to NAME."
   (lexical-let ((name name)
-                (dialect dialect))
+                (dialect dialect)
+                (path path))
     (fset (intern name)
           (lambda (&optional start-args)
             "Start this process version in an inferior ESS buffer.
 Function defined using `ess-define-runner'."
             (interactive "P")
             (cond ((string= dialect "R")
-                   (let ((inferior-ess-r-program name))
+                   (let ((inferior-ess-r-program (or path name)))
                      (R start-args)))
                   ((string= dialect "S")
-                   (let ((inferior-S+-program name))
+                   (let ((inferior-S+-program (or path name)))
+                     (require 'ess-sp6-d)
                      (S+)))
                   ((string= dialect "SAS")
-                   (let ((inferior-SAS-program name))
+                   (let ((inferior-SAS-program (or path name)))
+                     (require 'ess-sas-d)
                      (SAS))))))))
 
 (defun ess-version ()
@@ -1009,6 +1014,6 @@ Function defined using `ess-define-runner'."
     (concat ess-version " [" ess-revision "]")))
 
 
-(provide 'ess-mode)
+(provide 'ess)
 
-;;; ess-mode.el ends here
+;;; ess.el ends here

elpa/ess-20180717.825/ess.info

@@ -242,6 +242,14 @@ File: ess.info,  Node: New features,  Next: Credits,  Prev: Features,  Up: Intro
 
 Changes and New Features in development version:
 
+   * ESS[R]: Interaction with inferior process in non-R files within
+     packages (for instance C or C++ files) has been improved.  This is
+     a work in progress.
+
+   * ESS[R]: 'ess-r-package-use-dir' (which sets the working directory
+     to the root of the current package) now works with any mode (e.g.
+     in C or C++ files within '/src').
+
    * This is the last release to support Emacs older than 25.1 Going
      forward, only GNU Emacs 25.1 and newer will be supported.  Soon
      after this release, support for older Emacs versions will be
@@ -343,15 +351,32 @@ Changes and New Features in development version:
      customization to 'inferior-ess-R-program'.  These variables are
      treated as risky variables.
 
-   * Customization of ess-smart-S-assign-key has been reworked.  Use
+   * 'ess-smart-S-assign' changed name to 'ess-insert-S-assign'.  By
-     '(setq ess-smart-S-assign-key nil)' to disable smart assignment at
+     default, it provides similar functionality.  Since many users
-     any time instead of '(ess-toggle-underscore nil)'.  To use another
+     dislike this functionality, it is easier to disable; set
-     key, you should set the value of 'ess-smart-S-assign-key' before
+     'ess-smart-S-assign-key' to nil.  The following functions have been
-     ESS is loaded.  The following functions have been made obsolete.
+     made obsolete and will be removed in the next release of ESS:
-     You should customize ess-smart-S-assign-key instead:
+     ess-smart-S-assign, ess-toggle-S-assign, ess-toggle-S-assign-key,
-     ess-toggle-S-assign, ess-toggle-S-assign-key,
+     ess-disable-smart-S-assign.
-     ess-unset-smart-S-assign-key, ess-activate-smart-S-assign-key,
+
-     ess-disable-smart-S-assign
+   * The option ess-S-assign has been removed.  Customize new option
+     'ess-assign-list' instead.
+
+   * 'C-c C-=' is now bound to 'ess-cycle-assignment' by default See the
+     docstring for details.  New user customization option
+     'ess-assign-list' controls what assignment operators are cycled
+     through.
+
+   * The ESS initialization process has been further streamlined.  If
+     you update the autoloads (which installation from 'package-install'
+     does), you should not need to '(require 'ess-site)' at all, as
+     autoloads should automatically load ESS when it is needed (e.g.
+     the first time an R buffer is opened).  In order to defer loading
+     your ESS config, you may want to do something like
+     '(with-require-after-load "ess" <ess-config-here>)' in your Emacs
+     init file.  Users of the popular 'use-package' Emacs package can
+     now do '(use-package ess :defer t)' to take advantage of this
+     behavior.
 
    Changes and New Features in 17.11:
 
@@ -4721,104 +4746,104 @@ Node: Introduction2347
 Node: Features5100
 Node: Current Features5936
 Node: New features9387
-Node: Credits20331
+Node: Credits21509
-Node: Manual23890
+Node: Manual25068
-Node: Installation26556
+Node: Installation27734
-Node: Latest version26992
+Node: Latest version28170
-Node: Installation instructions27753
+Node: Installation instructions28931
-Node: License30953
+Node: License32131
-Node: Stability31616
+Node: Stability32794
-Node: Requirements32113
+Node: Requirements33291
-Node: Interactive ESS32794
+Node: Interactive ESS33972
-Node: Starting up33608
+Node: Starting up34786
-Node: Multiple ESS processes34352
+Node: Multiple ESS processes35530
-Node: ESS processes on Remote Computers35433
+Node: ESS processes on Remote Computers36611
-Node: Customizing startup39535
+Node: Customizing startup40713
-Node: Entering commands42152
+Node: Entering commands43330
-Node: Command-line editing43310
+Node: Command-line editing44488
-Node: Transcript44543
+Node: Transcript45721
-Node: Last command46312
+Node: Last command47490
-Node: Process buffer motion47738
+Node: Process buffer motion48916
-Node: Transcript resubmit49241
+Node: Transcript resubmit50419
-Node: Saving transcripts51206
+Node: Saving transcripts52384
-Node: Command History52996
+Node: Command History54174
-Node: Saving History56405
+Node: Saving History57583
-Node: History expansion57166
+Node: History expansion58344
-Node: Hot keys60377
+Node: Hot keys61555
-Node: Statistical Process running in ESS?64447
+Node: Statistical Process running in ESS?65625
-Node: Emacsclient65726
+Node: Emacsclient66904
-Node: Other66518
+Node: Other67696
-Node: Evaluating code67537
+Node: Evaluating code68715
-Node: Transcript Mode71218
+Node: Transcript Mode72396
-Node: Resubmit72371
+Node: Resubmit73549
-Node: Clean73434
+Node: Clean74612
-Node: Editing objects74430
+Node: Editing objects75608
-Node: Edit buffer75548
+Node: Edit buffer76726
-Node: Loading77594
+Node: Loading78772
-Node: Error Checking78621
+Node: Error Checking79799
-Node: Indenting79670
+Node: Indenting80848
-Node: Styles82859
+Node: Styles84037
-Node: Other edit buffer commands85294
+Node: Other edit buffer commands86472
-Node: Source Files86950
+Node: Source Files88128
-Node: Source Directories91554
+Node: Source Directories92732
-Node: Help94707
+Node: Help95885
-Node: Completion98805
+Node: Completion99983
-Node: Object names99038
+Node: Object names100216
-Node: Function arguments101711
+Node: Function arguments102889
-Node: Minibuffer completion102250
+Node: Minibuffer completion103428
-Node: Auto-complete102730
+Node: Auto-complete103908
-Node: Company104277
+Node: Company105455
-Node: Icicles104656
+Node: Icicles105834
-Node: Developing with ESS105975
+Node: Developing with ESS107153
-Node: ESS tracebug106421
+Node: ESS tracebug107599
-Node: Editing documentation109579
+Node: Editing documentation110757
-Node: R documentation files110129
+Node: R documentation files111307
-Node: Roxygen114056
+Node: Roxygen115234
-Node: Namespaced Evaluation118391
+Node: Namespaced Evaluation119569
-Node: Extras120387
+Node: Extras121565
-Node: ESS ElDoc121411
+Node: ESS ElDoc122589
-Node: ESS Flymake122907
+Node: ESS Flymake124085
-Node: Handy commands123848
+Node: Handy commands125026
-Node: Highlighting125045
+Node: Highlighting126223
-Node: Parens126374
+Node: Parens127552
-Node: Graphics126850
+Node: Graphics128028
-Node: printer127521
+Node: printer128699
-Node: X11128277
+Node: X11129455
-Node: winjava128616
+Node: winjava129794
-Node: Imenu129028
+Node: Imenu130206
-Node: Toolbar129875
+Node: Toolbar131053
-Node: Xref130283
+Node: Xref131461
-Node: Rdired130606
+Node: Rdired131784
-Node: Rutils131660
+Node: Rutils132838
-Node: Org134054
+Node: Org135232
-Node: Sweave and AUCTeX134996
+Node: Sweave and AUCTeX136174
-Node: ESS for R137120
+Node: ESS for R138298
-Node: ESS(R)--Editing files137420
+Node: ESS(R)--Editing files138598
-Node: iESS(R)--Inferior ESS processes137939
+Node: iESS(R)--Inferior ESS processes139117
-Node: Philosophies for using ESS(R)142688
+Node: Philosophies for using ESS(R)143866
-Node: Example ESS usage143615
+Node: Example ESS usage144793
-Node: ESS for SAS145836
+Node: ESS for SAS147014
-Node: ESS(SAS)--Design philosophy146559
+Node: ESS(SAS)--Design philosophy147737
-Node: ESS(SAS)--Editing files147512
+Node: ESS(SAS)--Editing files148690
-Node: ESS(SAS)--TAB key149366
+Node: ESS(SAS)--TAB key150544
-Node: ESS(SAS)--Batch SAS processes150732
+Node: ESS(SAS)--Batch SAS processes151910
-Node: ESS(SAS)--Function keys for batch processing155758
+Node: ESS(SAS)--Function keys for batch processing156936
-Node: iESS(SAS)--Interactive SAS processes165244
+Node: iESS(SAS)--Interactive SAS processes166422
-Node: iESS(SAS)--Common problems168998
+Node: iESS(SAS)--Common problems170176
-Node: ESS(SAS)--Graphics170521
+Node: ESS(SAS)--Graphics171699
-Node: ESS(SAS)--Windows171304
+Node: ESS(SAS)--Windows172482
-Node: ESS for BUGS171882
+Node: ESS for BUGS173060
-Node: ESS for JAGS173638
+Node: ESS for JAGS174816
-Node: Mailing lists/bug reports176990
+Node: Mailing lists/bug reports178168
-Node: Bugs177254
+Node: Bugs178432
-Node: Reporting Bugs178879
+Node: Reporting Bugs180057
-Node: Mailing Lists179772
+Node: Mailing Lists180950
-Node: Help with Emacs180519
+Node: Help with Emacs181697
-Node: Customization181050
+Node: Customization182228
-Node: Indices181824
+Node: Indices183002
-Node: Key index181999
+Node: Key index183177
-Node: Function and program index187277
+Node: Function and program index188455
-Node: Variable index196771
+Node: Variable index197949
-Node: Concept index200259
+Node: Concept index201437
 
 End Tag Table

elpa/ess-20180717.825/essd-els.el

@@ -103,20 +103,6 @@ The default value is nil."
 ;; This REALLY shouldn't need an editing mode.  Just a transcript and
 ;; an inferior process handler.
 
-(defun ess-change-alist (item value alist)
-  "Modify ALIST to set VALUE to ITEM.
-If there is a pair whose car is ITEM, replace its cdr by VALUE.
-If there is not such pair, create new pair (ITEM . VALUE) and
-return new alist whose car is the new pair and cdr is ALIST.
-\[tomo's ELIS like function]"
-  (let ((pair (assoc item alist)))
-    (if pair
-        (progn
-          (setcdr pair value)
-          alist)
-      (cons (cons item value) alist))))
-
-
 (defun ess-select-alist-dialect (&optional dialect)
   "Query user for an ESS dialect and return the matching customize-alist."
   (interactive)