cgit.sxemacs.org Git - packages/blob - xemacs-packages/sml-mode/sml-move.el

   1 ;;; sml-move.el --- Buffer navigation functions for sml-mode
   2
   3 ;; Copyright (C) 1999-2000  Stefan Monnier <monnier@cs.yale.edu>
   4 ;;
   5 ;; This program is free software; you can redistribute it and/or modify
   6 ;; it under the terms of the GNU General Public License as published by
   7 ;; the Free Software Foundation; either version 2 of the License, or
   8 ;; (at your option) any later version.
   9 ;;
  10 ;; This program is distributed in the hope that it will be useful,
  11 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 ;; GNU General Public License for more details.
  14 ;;
  15 ;; You should have received a copy of the GNU General Public License
  16 ;; along with this program; if not, write to the Free Software
  17 ;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19
  20 ;;; Commentary:
  21
  22
  23 ;;; Code:
  24
  25 (eval-when-compile (require 'cl))
  26 (require 'sml-util)
  27 (require 'sml-defs)
  28
  29 (defsyntax sml-internal-syntax-table
  30   '((?_  . "w")
  31     (?'  . "w")
  32     (?.  . "w")
  33     ;; treating `~' as a word constituent is not quite right, but
  34     ;; close enough.  Think about 12.3E~2 for example.  Also `~' on its
  35     ;; own *is* a nonfix symbol.
  36     (?~  . "w"))
  37   "Syntax table used for internal sml-mode operation."
  38   :copy sml-mode-syntax-table)
  39
  40 ;;;
  41 ;;; various macros
  42 ;;;
  43
  44 (defmacro sml-with-ist (&rest r)
  45   (let ((ost-sym (make-symbol "oldtable")))
  46     `(let ((,ost-sym (syntax-table))
  47            (case-fold-search nil)
  48            (parse-sexp-lookup-properties t)
  49            (parse-sexp-ignore-comments t))
  50        (unwind-protect
  51            (progn (set-syntax-table sml-internal-syntax-table) . ,r)
  52          (set-syntax-table ,ost-sym)))))
  53 (def-edebug-spec sml-with-ist t)
  54
  55 (defmacro sml-move-if (&rest body)
  56   (let ((pt-sym (make-symbol "point"))
  57         (res-sym (make-symbol "result")))
  58     `(let ((,pt-sym (point))
  59            (,res-sym ,(cons 'progn body)))
  60        (unless ,res-sym (goto-char ,pt-sym))
  61        ,res-sym)))
  62 (def-edebug-spec sml-move-if t)
  63
  64 (defmacro sml-point-after (&rest body)
  65   `(save-excursion
  66      ,@body
  67      (point)))
  68 (def-edebug-spec sml-point-after t)
  69
  70 ;;
  71
  72 (defvar sml-op-prec
  73   (sml-preproc-alist
  74    '(("before" . 0)
  75      ((":=" "o") . 3)
  76      ((">" ">=" "<>" "<" "<=" "=") . 4)
  77      (("::" "@") . 5)
  78      (("+" "-" "^") . 6)
  79      (("/" "*" "quot" "rem" "div" "mod") . 7)))
  80   "Alist of SML infix operators and their precedence.")
  81
  82 (defconst sml-syntax-prec
  83   (sml-preproc-alist
  84    `((("in" "with") . 10)
  85      ((";" ",") . 20)
  86      (("=>" "d=" "=of") . (65 . 40))
  87      ("|" . (47 . 30))
  88      (("case" "of" "fn") . 45)
  89      (("if" "then" "else" "while" "do" "raise") . 50)
  90      ("handle" . 60)
  91      ("orelse" . 70)
  92      ("andalso" . 80)
  93      ((":" ":>") . 90)
  94      ("->" . 95)
  95      (,(cons "end" sml-begin-syms) . 10000)))
  96   "Alist of pseudo-precedence of syntactic elements.")
  97
  98 (defun sml-op-prec (op dir)
  99   "Return the precedence of OP or nil if it's not an infix.
 100 DIR should be set to BACK if you want to precedence w.r.t the left side
 101     and to FORW for the precedence w.r.t the right side.
 102 This assumes that we are `looking-at' the OP."
 103   (when op
 104     (let ((sprec (cdr (assoc op sml-syntax-prec))))
 105       (cond
 106        ((consp sprec) (if (eq dir 'back) (car sprec) (cdr sprec)))
 107        (sprec sprec)
 108        (t
 109         (let ((prec (cdr (assoc op sml-op-prec))))
 110           (when prec (+ prec 100))))))))
 111
 112 ;;
 113
 114 (defun sml-forward-spaces () (forward-comment 100000))
 115 (defun sml-backward-spaces () (forward-comment -100000))
 116
 117
 118 ;;
 119 ;; moving forward around matching symbols
 120 ;;
 121
 122 (defun sml-looking-back-at (re)
 123   (save-excursion
 124     (when (= 0 (skip-syntax-backward "w_")) (backward-char))
 125     (looking-at re)))
 126
 127 (defun sml-find-match-forward (this match)
 128   "Only works for word matches."
 129   (let ((level 1)
 130         (forward-sexp-function nil)
 131         (either (concat this "\\|" match)))
 132     (while (> level 0)
 133       (forward-sexp 1)
 134       (while (not (or (eobp) (sml-looking-back-at either)))
 135         (condition-case () (forward-sexp 1) (error (forward-char 1))))
 136       (setq level
 137             (cond
 138              ((sml-looking-back-at this) (1+ level))
 139              ((sml-looking-back-at match) (1- level))
 140              (t (error "Unbalanced")))))
 141     t))
 142
 143 (defun sml-find-match-backward (this match)
 144   (let ((level 1)
 145         (forward-sexp-function nil)
 146         (either (concat this "\\|" match)))
 147     (while (> level 0)
 148       (backward-sexp 1)
 149       (while (not (or (bobp) (looking-at either)))
 150         (condition-case () (backward-sexp 1) (error (backward-char 1))))
 151       (setq level
 152             (cond
 153              ((looking-at this) (1+ level))
 154              ((looking-at match) (1- level))
 155              (t (error "Unbalanced")))))
 156     t))
 157
 158 ;;;
 159 ;;; read a symbol, including the special "op <sym>" case
 160 ;;;
 161
 162 (defmacro sml-move-read (&rest body)
 163   (let ((pt-sym (make-symbol "point")))
 164     `(let ((,pt-sym (point)))
 165        ,@body
 166        (when (/= (point) ,pt-sym)
 167          (buffer-substring-no-properties (point) ,pt-sym)))))
 168 (def-edebug-spec sml-move-read t)
 169
 170 (defun sml-poly-equal-p ()
 171   (< (sml-point-after (re-search-backward sml-=-starter-re nil 'move))
 172      (sml-point-after (re-search-backward "=" nil 'move))))
 173
 174 (defun sml-nested-of-p ()
 175   (< (sml-point-after
 176       (re-search-backward sml-non-nested-of-starter-re nil 'move))
 177      (sml-point-after (re-search-backward "\\<case\\>" nil 'move))))
 178
 179 (defun sml-forward-sym-1 ()
 180   (or (/= 0 (skip-syntax-forward "'w_"))
 181       (/= 0 (skip-syntax-forward ".'"))))
 182 (defun sml-forward-sym ()
 183   (let ((sym (sml-move-read (sml-forward-sym-1))))
 184     (cond
 185      ((equal "op" sym)
 186       (sml-forward-spaces)
 187       (concat "op " (or (sml-move-read (sml-forward-sym-1)) "")))
 188      ((equal sym "=")
 189       (save-excursion
 190         (sml-backward-sym-1)
 191         (if (sml-poly-equal-p) "=" "d=")))
 192      ((equal sym "of")
 193       (save-excursion
 194         (sml-backward-sym-1)
 195         (if (sml-nested-of-p) "of" "=of")))
 196      ;; ((equal sym "datatype")
 197      ;;  (save-excursion
 198      ;;         (sml-backward-sym-1)
 199      ;;         (sml-backward-spaces)
 200      ;;         (if (eq (preceding-char) ?=) "=datatype" sym)))
 201      (t sym))))
 202
 203 (defun sml-backward-sym-1 ()
 204   (or (/= 0 (skip-syntax-backward ".'"))
 205       (/= 0 (skip-syntax-backward "'w_"))))
 206 (defun sml-backward-sym ()
 207   (let ((sym (sml-move-read (sml-backward-sym-1))))
 208     (when sym
 209       ;; FIXME: what should we do if `sym' = "op" ?
 210       (let ((point (point)))
 211         (sml-backward-spaces)
 212         (if (equal "op" (sml-move-read (sml-backward-sym-1)))
 213             (concat "op " sym)
 214           (goto-char point)
 215           (cond
 216            ((string= sym "=") (if (sml-poly-equal-p) "=" "d="))
 217            ((string= sym "of") (if (sml-nested-of-p) "of" "=of"))
 218            ;; ((string= sym "datatype")
 219            ;;  (save-excursion (sml-backward-spaces)
 220            ;;               (if (eq (preceding-char) ?=) "=datatype" sym)))
 221            (t sym)))))))
 222
 223
 224 (defun sml-backward-sexp (prec)
 225   "Move one sexp backward if possible, or one char else.
 226 Returns t if the move indeed moved through one sexp and nil if not.
 227 PREC is the precedence currently looked for."
 228   (let ((parse-sexp-lookup-properties t)
 229         (parse-sexp-ignore-comments t))
 230     (sml-backward-spaces)
 231     (let* ((point (point))
 232            (op (sml-backward-sym))
 233            (op-prec (sml-op-prec op 'back))
 234            match)
 235       (cond
 236        ((not op)
 237         (let ((point (point)))
 238           (ignore-errors (let ((forward-sexp-function nil)) (backward-sexp 1)))
 239           (if (/= point (point)) t (ignore-errors (backward-char 1)) nil)))
 240        ;; stop as soon as precedence is smaller than `prec'
 241        ((and prec op-prec (>= prec op-prec)) nil)
 242        ;; special rules for nested constructs like if..then..else
 243        ((and (or (not prec) (and prec op-prec))
 244              (setq match (second (assoc op sml-close-paren))))
 245         (sml-find-match-backward (concat "\\<" op "\\>") match))
 246        ;; don't back over open-parens
 247        ((assoc op sml-open-paren) nil)
 248        ;; infix ops precedence
 249        ((and prec op-prec) (< prec op-prec))
 250        ;; [ prec = nil ]  a new operator, let's skip the sexps until the next
 251        (op-prec (while (sml-move-if (sml-backward-sexp op-prec))) t)
 252        ;; special symbols indicating we're getting out of a nesting level
 253        ((string-match sml-sexp-head-symbols-re op) nil)
 254        ;; if the op was not alphanum, then we still have to do the backward-sexp
 255        ;; this reproduces the usual backward-sexp, but it might be bogus
 256        ;; in this case since !@$% is a perfectly fine symbol
 257        (t t))))) ;(or (string-match "\\sw" op) (sml-backward-sexp prec))
 258
 259 (defun sml-forward-sexp (prec)
 260   "Moves one sexp forward if possible, or one char else.
 261 Returns T if the move indeed moved through one sexp and NIL if not."
 262   (let ((parse-sexp-lookup-properties t)
 263         (parse-sexp-ignore-comments t))
 264     (sml-forward-spaces)
 265     (let* ((point (point))
 266            (op (sml-forward-sym))
 267            (op-prec (sml-op-prec op 'forw))
 268            match)
 269       (cond
 270        ((not op)
 271         (let ((point (point)))
 272           (ignore-errors (let ((forward-sexp-function nil)) (forward-sexp 1)))
 273           (if (/= point (point)) t (forward-char 1) nil)))
 274        ;; stop as soon as precedence is smaller than `prec'
 275        ((and prec op-prec (>= prec op-prec)) nil)
 276        ;; special rules for nested constructs like if..then..else
 277        ((and (or (not prec) (and prec op-prec))
 278              (setq match (cdr (assoc op sml-open-paren))))
 279         (sml-find-match-forward (first match) (second match)))
 280        ;; don't forw over close-parens
 281        ((assoc op sml-close-paren) nil)
 282        ;; infix ops precedence
 283        ((and prec op-prec) (< prec op-prec))
 284        ;; [ prec = nil ]  a new operator, let's skip the sexps until the next
 285        (op-prec (while (sml-move-if (sml-forward-sexp op-prec))) t)
 286        ;; special symbols indicating we're getting out of a nesting level
 287        ((string-match sml-sexp-head-symbols-re op) nil)
 288        ;; if the op was not alphanum, then we still have to do the backward-sexp
 289        ;; this reproduces the usual backward-sexp, but it might be bogus
 290        ;; in this case since !@$% is a perfectly fine symbol
 291        (t t))))) ;(or (string-match "\\sw" op) (sml-backward-sexp prec))
 292
 293 (defun sml-in-word-p ()
 294   (and (eq ?w (char-syntax (or (char-before) ? )))
 295        (eq ?w (char-syntax (or (char-after) ? )))))
 296
 297 (defun sml-user-backward-sexp (&optional count)
 298   "Like `backward-sexp' but tailored to the SML syntax."
 299   (interactive "p")
 300   (unless count (setq count 1))
 301   (sml-with-ist
 302    (let ((point (point)))
 303      (if (< count 0) (sml-user-forward-sexp (- count))
 304        (when (sml-in-word-p) (forward-word 1))
 305        (dotimes (i count)
 306          (unless (sml-backward-sexp nil)
 307            (goto-char point)
 308            (error "Containing expression ends prematurely")))))))
 309
 310 (defun sml-user-forward-sexp (&optional count)
 311   "Like `forward-sexp' but tailored to the SML syntax."
 312   (interactive "p")
 313   (unless count (setq count 1))
 314   (sml-with-ist
 315    (let ((point (point)))
 316      (if (< count 0) (sml-user-backward-sexp (- count))
 317        (when (sml-in-word-p) (backward-word 1))
 318        (dotimes (i count)
 319          (unless (sml-forward-sexp nil)
 320            (goto-char point)
 321            (error "Containing expression ends prematurely")))))))
 322
 323 ;;(defun sml-forward-thing ()
 324 ;;  (if (= ?w (char-syntax (char-after))) (forward-word 1) (forward-char 1)))
 325
 326 (defun sml-backward-arg () (sml-backward-sexp 1000))
 327 (defun sml-forward-arg () (sml-forward-sexp 1000))
 328
 329
 330 (provide 'sml-move)
 331
 332 ;;; sml-move.el ends here