cgit.sxemacs.org Git - gnus/blob - lisp/nnoo.el

   1 ;;; nnoo.el --- OO Gnus Backends
   2 ;; Copyright (C) 1996 Free Software Foundation, Inc.
   3
   4 ;; Author: Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
   5 ;; Keywords: news
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22 ;; Boston, MA 02111-1307, USA.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 (require 'nnheader)
  29 (require 'cl)
  30
  31 (defvar nnoo-definition-alist nil)
  32 (defvar nnoo-state-alist nil)
  33
  34 (defmacro defvoo (var init &optional doc &rest map)
  35   "The same as `defvar', only takes list of variables to MAP to."
  36   `(prog1
  37        ,(if doc
  38             `(defvar ,var ,init ,doc)
  39           `(defvar ,var ,init))
  40      (nnoo-define ',var ',map)))
  41 (put 'defvoo 'lisp-indent-function 2)
  42 (put 'defvoo 'lisp-indent-hook 2)
  43 (put 'defvoo 'edebug-form-spec '(var init &optional doc &rest map))
  44
  45 (defmacro deffoo (func args &rest forms)
  46   "The same as `defun', only register FUNC."
  47   `(prog1
  48        (defun ,func ,args ,@forms)
  49      (nnoo-register-function ',func)))
  50 (put 'deffoo 'lisp-indent-function 2)
  51 (put 'deffoo 'lisp-indent-hook 2)
  52 (put 'deffoo 'edebug-form-spec '(&define name lambda-list def-body))
  53
  54 (defun nnoo-register-function (func)
  55   (let ((funcs (nthcdr 3 (assoc (nnoo-backend func)
  56                                 nnoo-definition-alist))))
  57     (unless funcs
  58       (error "%s belongs to a backend that hasn't been declared" func))
  59     (setcar funcs (cons func (car funcs)))))
  60
  61 (defmacro nnoo-declare (backend &rest parents)
  62   `(eval-and-compile
  63      (push (list ',backend
  64                  (mapcar (lambda (p) (list p)) ',parents)
  65                  nil nil)
  66            nnoo-definition-alist)))
  67 (put 'nnoo-declare 'lisp-indent-function 1)
  68 (put 'nnoo-declare 'lisp-indent-hook 1)
  69
  70 (defun nnoo-parents (backend)
  71   (nth 1 (assoc backend nnoo-definition-alist)))
  72
  73 (defun nnoo-variables (backend)
  74   (nth 2 (assoc backend nnoo-definition-alist)))
  75
  76 (defun nnoo-functions (backend)
  77   (nth 3 (assoc backend nnoo-definition-alist)))
  78
  79 (defmacro nnoo-import (backend &rest imports)
  80   `(nnoo-import-1 ',backend ',imports))
  81 (put 'nnoo-import 'lisp-indent-function 1)
  82 (put 'nnoo-import 'lisp-indent-hook 1)
  83
  84 (defun nnoo-import-1 (backend imports)
  85   (let ((call-function
  86          (if (symbolp (car imports)) (pop imports) 'nnoo-parent-function))
  87         imp functions function)
  88     (while (setq imp (pop imports))
  89       (setq functions
  90             (or (cdr imp)
  91                 (nnoo-functions (car imp))))
  92       (while functions
  93         (unless (fboundp (setq function
  94                                (nnoo-symbol backend (nnoo-rest-symbol
  95                                                          (car functions)))))
  96           (eval `(deffoo ,function (&rest args)
  97                    (,call-function ',backend ',(car functions) args))))
  98         (pop functions)))))
  99
 100 (defun nnoo-parent-function (backend function args)
 101   (let* ((pbackend (nnoo-backend function)))
 102     (nnoo-change-server pbackend (nnoo-current-server backend)
 103                         (cdr (assq pbackend (nnoo-parents backend))))
 104     (apply function args)))
 105
 106 (defun nnoo-execute (backend function &rest args)
 107   "Execute FUNCTION on behalf of BACKEND."
 108   (let* ((pbackend (nnoo-backend function)))
 109     (nnoo-change-server pbackend (nnoo-current-server backend)
 110                         (cdr (assq pbackend (nnoo-parents backend))))
 111     (apply function args)))
 112
 113 (defmacro nnoo-map-functions (backend &rest maps)
 114   `(nnoo-map-functions-1 ',backend ',maps))
 115 (put 'nnoo-map-functions 'lisp-indent-function 1)
 116 (put 'nnoo-map-functions 'lisp-indent-hook 1)
 117
 118 (defun nnoo-map-functions-1 (backend maps)
 119   (let (m margs i)
 120     (while (setq m (pop maps))
 121       (setq i 0
 122             margs nil)
 123       (while (< i (length (cdr m)))
 124         (if (numberp (nth i (cdr m)))
 125             (push `(nth ,i args) margs)
 126           (push (nth i (cdr m)) margs))
 127         (incf i))
 128       (eval `(deffoo ,(nnoo-symbol backend (nnoo-rest-symbol (car m)))
 129                  (&rest args)
 130                (nnoo-parent-function ',backend ',(car m)
 131                                      ,(cons 'list (nreverse margs))))))))
 132
 133 (defun nnoo-backend (symbol)
 134   (string-match "^[^-]+-" (symbol-name symbol))
 135   (intern (substring (symbol-name symbol) 0 (1- (match-end 0)))))
 136
 137 (defun nnoo-rest-symbol (symbol)
 138   (string-match "^[^-]+-" (symbol-name symbol))
 139   (intern (substring (symbol-name symbol) (match-end 0))))
 140
 141 (defun nnoo-symbol (backend symbol)
 142   (intern (format "%s-%s" backend symbol)))
 143
 144 (defun nnoo-define (var map)
 145   (let* ((backend (nnoo-backend var))
 146          (def (assq backend nnoo-definition-alist))
 147          (parents (nth 1 def)))
 148     (unless def
 149       (error "%s belongs to a backend that hasn't been declared." var))
 150     (setcar (nthcdr 2 def)
 151             (delq (assq var (nth 2 def)) (nth 2 def)))
 152     (setcar (nthcdr 2 def)
 153             (cons (cons var (symbol-value var))
 154                   (nth 2 def)))
 155     (while map
 156       (nconc (assq (nnoo-backend (car map)) parents)
 157              (list (list (pop map) var))))))
 158
 159 (defun nnoo-change-server (backend server defs)
 160   (let* ((bstate (cdr (assq backend nnoo-state-alist)))
 161          (current (car bstate))
 162          (parents (nnoo-parents backend))
 163          state)
 164     (unless bstate
 165       (push (setq bstate (list backend nil))
 166             nnoo-state-alist)
 167       (pop bstate))
 168     (if (equal server current)
 169         t
 170       (nnoo-push-server backend current)
 171       (setq state (or (cdr (assoc server (cddr bstate)))
 172                       (nnoo-variables backend)))
 173       (while state
 174         (set (caar state) (cdar state))
 175         (pop state))
 176       (setcar bstate server)
 177       (unless (cdr (assoc server (cddr bstate)))
 178         (while defs
 179           (set (caar defs) (cadar defs))
 180           (pop defs)))
 181       (while parents
 182         (nnoo-change-server
 183          (caar parents) server
 184          (mapcar (lambda (def) (list (car def) (symbol-value (cadr def))))
 185                  (cdar parents)))
 186         (pop parents))))
 187   t)
 188
 189 (defun nnoo-push-server (backend current)
 190   (let ((bstate (assq backend nnoo-state-alist))
 191         (defs (nnoo-variables backend)))
 192     ;; Remove the old definition.
 193     (setcdr (cdr bstate) (delq (assoc current (cddr bstate)) (cddr bstate)))
 194     (let (state)
 195       (while defs
 196         (push (cons (caar defs) (symbol-value (caar defs)))
 197               state)
 198         (pop defs))
 199       (nconc bstate (list (cons current state))))))
 200
 201 (defun nnoo-current-server-p (backend server)
 202   (equal (nnoo-current-server backend) server))
 203
 204 (defun nnoo-current-server (backend)
 205   (nth 1 (assq backend nnoo-state-alist)))
 206
 207 (defun nnoo-close-server (backend &optional server)
 208   (unless server
 209     (setq server (nnoo-current-server backend)))
 210   (when server
 211     (let* ((bstate (cdr (assq backend nnoo-state-alist)))
 212            (defs (assoc server (cdr bstate))))
 213       (when bstate
 214         (setcar bstate nil)
 215         (setcdr bstate (delq defs (cdr bstate)))
 216         (pop defs)
 217         (while defs
 218           (set (car (pop defs)) nil)))))
 219   t)
 220
 221 (defun nnoo-close (backend)
 222   (setq nnoo-state-alist
 223         (delq (assq backend nnoo-state-alist)
 224               nnoo-state-alist))
 225   t)
 226
 227 (defun nnoo-status-message (backend server)
 228   (nnheader-get-report backend))
 229
 230 (defun nnoo-server-opened (backend server)
 231   (and (nnoo-current-server-p backend server)
 232        nntp-server-buffer
 233        (buffer-name nntp-server-buffer)))
 234
 235 (defmacro nnoo-define-basics (backend)
 236   "Define `close-server', `server-opened' and `status-message'."
 237   `(eval-and-compile
 238      (nnoo-define-basics-1 ',backend)))
 239
 240 (defun nnoo-define-basics-1 (backend)
 241   (let ((functions '(close-server server-opened status-message)))
 242     (while functions
 243       (eval `(deffoo ,(nnoo-symbol backend (car functions))
 244                  (&optional server)
 245                (,(nnoo-symbol 'nnoo (pop functions)) ',backend server)))))
 246   (eval `(deffoo ,(nnoo-symbol backend 'open-server)
 247              (server &optional defs)
 248            (nnoo-change-server ',backend server defs))))
 249
 250 (defmacro nnoo-define-skeleton (backend)
 251   "Define all required backend functions for BACKEND.
 252 All functions will return nil and report an error."
 253   `(eval-and-compile
 254      (nnoo-define-skeleton-1 ',backend)))
 255
 256 (defun nnoo-define-skeleton-1 (backend)
 257   (let ((functions '(retrieve-headers
 258                      request-close request-article
 259                      open-group request-group close-group
 260                      request-list request-post))
 261         function fun)
 262     (while (setq function (pop functions))
 263       (when (not (fboundp (setq fun (nnoo-symbol backend function))))
 264         (eval `(deffoo ,fun
 265                    (&rest args)
 266                  (nnheader-report ',backend ,(format "%s-%s not implemented"
 267                                                      backend function))))))))
 268 (provide 'nnoo)
 269
 270 ;;; nnoo.el ends here.