Return to pari-translator.el CVS log

Up to [local] / OpenXM_contrib / pari-2.2 / emacs

Annotation of OpenXM_contrib/pari-2.2/emacs/pari-translator.el, Revision 1.1

1.1     ! noro        1: ;; This file is to be used with pari.el where further explanations
        !             2: ;; may be found. See also the file pariemacs.txt.
        !             3: ;; Should be accompanied by the file with-syntax.el. This latter
        !             4: ;; contains an example as to how to write a "translating" file.
        !             5:
        !             6: ;; Created November 22 1998 by Olivier Ramare (ramare@gat.univ-lille1.fr)
        !             7:
        !             8: ;; It contains functions used for writing translating eLisp-modules
        !             9: ;; that translate a program given in a langage into something comprehensible
        !            10: ;; by the gp calculator.
        !            11:
        !            12: ;; Add
        !            13: ;; /*@ (load-file "Name-of-the-translating-file")
        !            14: ;;     (setq gp-input-filter-hook (list 'translate)) */
        !            15: ;; to the file to translate. 'translate is the translation function.
        !            16: ;; The file has to be currently edited for this command to be taken
        !            17: ;; into account.
        !            18: ;;
        !            19: ;; The first command of 'translate is either
        !            20: ;;    (gp-translate-on-other-file) and the file to be translated
        !            21: ;;                                 will not be changed.
        !            22: ;;    (gp-translate-on-same-file) and the file to be translated
        !            23: ;;                                will be actually changed.
        !            24:
        !            25: (provide 'pari-translator)
        !            26:
        !            27: (defun gp-translate-on-other-file nil
        !            28:   "This function contains the command that should be executed
        !            29: to translate a file onto another one. The file to translate is in the
        !            30: currently editted (and set) buffer. The translated file is editted in
        !            31: another buffer which is the selected one at the end of this command."
        !            32:
        !            33:   (goto-char (point-min))
        !            34:   (get-buffer-create "*translation*")
        !            35:   (save-excursion (set-buffer "*translation*") (erase-buffer))
        !            36:   (copy-to-buffer "*translation*" (point-min) (point-max))
        !            37:   (set-buffer "*translation*")
        !            38:   ;; 'gp-temp-file is a variable of pari.el:
        !            39:   (set-visited-file-name gp-temp-file t)
        !            40:   ;; The preceding function has changed the buffer-name!
        !            41:   (rename-buffer "*translation*")
        !            42:
        !            43:   ;; To limit the translation to this file:
        !            44:   (setq gp-input-filter-hook nil))
        !            45:
        !            46: (defun gp-translate-on-same-file nil
        !            47:   "This function contains the command that should be executed
        !            48: to translate a file onto another one. The file to translate is in the
        !            49: currently editted (and set) buffer."
        !            50:
        !            51:   (goto-char (point-min))
        !            52:
        !            53:   ;; To limit the translation to this file:
        !            54:   (setq gp-input-filter-hook nil))
        !            55:
        !            56:
        !            57: ;;--------------------
        !            58: ;; Expression finders
        !            59: ;;--------------------
        !            60:
        !            61: ;; An inner full expression in gp is one of these two:
        !            62: ;; fn-call :: identifier(...matching-)
        !            63: ;; identifier
        !            64: ;; preceded and followed by any number of comments, spaces, newline
        !            65: ;; or tabulation-character.
        !            66: ;; Its end delimitation is "," or ";" or "}"
        !            67: ;; Thus, we do not detect full expression located at the end of
        !            68: ;; a one line function definition, not surrounded by "{}",
        !            69: ;; not followed by ";"
        !            70:
        !            71: ;; pari.el already contains 'gp-find-comment, 'gp-find-global-var
        !            72: ;; and 'gp-search-forward-string-delimiter.
        !            73:
        !            74: (defconst gp-regexp-identifier  "[a-zA-Z_][a-zA-Z_0-9]*"
        !            75: "Regexp to match identifiers in gp.")
        !            76:
        !            77: (defconst gp-regexp-comment "\\\\\\\\$\\|/\\*\\([^\\*]\\|\\*[^/]\\)*\\*/"
        !            78: "Regexp to match comments in gp")
        !            79:
        !            80: (defun gp-looking-at-identifierp nil
        !            81: "T if point is located at the beginning of a gp-identifier."
        !            82:   (if (looking-at gp-regexp-identifier)
        !            83:       (if (bobp)
        !            84:           t
        !            85:           (save-excursion
        !            86:             (forward-char -1)
        !            87:             (looking-at "[^a-zA-Z_0-9]")))
        !            88:       nil))
        !            89:
        !            90: (defun gp-looking-at-identifier nil
        !            91: "Return end of identifier if gp-looking-at-identifier is T,
        !            92: nil otherwise."
        !            93:   (if (gp-looking-at-identifierp)
        !            94:       (save-excursion (skip-chars-forward "a-zA-Z_0-9") (point))
        !            95:       nil))
        !            96:
        !            97: (defun gp-looking-at-fn-call nil
        !            98: "Return end of fn-call if point is located at the beginning of a
        !            99: fn-call, and nil otherwise."
        !           100:   (if (gp-looking-at-identifierp)
        !           101:       (save-excursion
        !           102:         (goto-char (gp-looking-at-identifier))
        !           103:         (if (not (looking-at "[ \t\n\\\\]*("))
        !           104:             nil
        !           105:             (goto-char (- (match-end 0) 1))
        !           106:             (forward-sexp)  ;; Error if expression is unbalanced.
        !           107:             (point)))
        !           108:       nil))
        !           109:
        !           110: (defun gp-skip-comments nil
        !           111:   (while (looking-at gp-regexp-comment)
        !           112:          (goto-char (match-end 0))))
        !           113:
        !           114: (defun gp-looking-at-term nil
        !           115: "Return end of term if point is located at the beginning of a
        !           116: fn-call, and nil otherwise.
        !           117:   A `term' is either an identifier, either a fn-call, surrounded by
        !           118: any number of parenthesis/space/newline/tab-char/backslash. It may
        !           119: also start by a comment."
        !           120:   (gp-skip-comments)
        !           121:   (if (looking-at "[ \t\n\\\\]*(")
        !           122:       (let ((p-end (save-excursion
        !           123:                      (forward-sexp)
        !           124:                      (gp-skip-comments)
        !           125:                      (point))))
        !           126:            (forward-char 1)
        !           127:            (if (gp-looking-at-term) p-end nil))
        !           128:       (let ((p-end (gp-looking-at-fn-call)))
        !           129:            (if p-end p-end
        !           130:                (if (gp-looking-at-identifierp)
        !           131:                    (gp-looking-at-identifier)
        !           132:                    nil)))))
        !           133:
        !           134: (defun gp-looking-at-rat-exp nil
        !           135: "Return end of rational expression if point is located at the beginning
        !           136: of one, nil otherwise.
        !           137:   A rational expression for gp is a succession of terms separated by one
        !           138: of the operators +-*%/."
        !           139:   (save-excursion
        !           140:     (let ((first-term (gp-looking-at-term)))
        !           141:          (if (not first-term)
        !           142:              nil
        !           143:              (goto-char first-term)
        !           144:              (if (looking-at "[ \t\n\\\\]*[+-*%/]")
        !           145:                  (progn (goto-char (match-end 0))
        !           146:                         (gp-looking-at-rat-exp))
        !           147:                  first-term)))))
        !           148:
        !           149: ;; pari-translator.el ends here.