comparison lisp/textmodes/bibtex.el @ 55730:b4eeb441c089

Use assoc-string, not assoc-ignore-case.

55729:0c0b514a4952

            (beg (copy-marker (match-beginning 0)))
            (end (copy-marker (save-excursion (bibtex-end-of-entry)))))
        (save-excursion
          (if (or (and (not bibtex-sort-ignore-string-entries)
                       (string-equal "string" (downcase entry-type)))
                  (assoc-ignore-case entry-type bibtex-entry-field-alist))
              (funcall fun key beg end)))
        (goto-char end)))))

(defun bibtex-progress-message (&optional flag interval)
  "Echo a message about progress of current buffer.

        ;; identify entry type
        (goto-char (point-min))
        (re-search-forward bibtex-entry-type)
        (let ((beg-type (1+ (match-beginning 0)))
              (end-type (match-end 0)))
          (setq entry-list (assoc-ignore-case (buffer-substring-no-properties
                                               beg-type end-type)
                                              bibtex-entry-field-alist))

          ;; unify case of entry name
          (when (memq 'unify-case format)
            (delete-region beg-type end-type)
            (insert (car entry-list)))

            ;; anyway. So for speed-up we avoid using them.

            (if (memq 'opts-or-alts format)
                (cond ((and empty-field
                            (or opt-alt
                                (let ((field (assoc-ignore-case
                                              field-name req-field-list)))
                                  (or (not field)       ; OPT field
                                      (nth 3 field))))) ; ALT field
                       ;; Either it is an empty ALT field. Then we have checked
                       ;; already that we have one non-empty alternative. Or it
                       ;; is an empty OPT field that we do not miss anyway.

		      (insert booktitle))))

              ;; if empty field, complain
              (if (and empty-field
                       (memq 'required-fields format)
                       (assoc-ignore-case field-name req-field-list))
                  (error "Mandatory field `%s' is empty" field-name))

              ;; unify case of field name
              (if (memq 'unify-case format)
                  (let ((fname (car (assoc-ignore-case
                                     field-name (append (nth 0 (nth 1 entry-list))
                                                        (nth 1 (nth 1 entry-list))
                                                        bibtex-user-optional-fields)))))
                    (if fname
                        (progn
                          (delete-region beg-name end-name)
                          (goto-char beg-name)
                          (insert fname))

                      (throw 'userkey 'aborted))
                  (let ((key (cond ((match-end 3)
                                    ;; This is a crossref.
                                    (buffer-substring-no-properties
                                     (1+ (match-beginning 3)) (1- (match-end 3))))
                                   ((assoc-ignore-case (bibtex-type-in-head)
                                                       bibtex-entry-field-alist)
                                    ;; This is an entry.
                                    (match-string-no-properties bibtex-key-in-head)))))
                    (if (and (stringp key)
                             (not (assoc key reference-keys)))
                      (push (list key) reference-keys)))))

            (if (and abortable
                     (input-pending-p))
                ;; user has aborted by typing a key --> return `aborted'
                (throw 'userkey 'aborted))
            (setq key (bibtex-reference-key-in-string bounds))
            (if (not (assoc-ignore-case key strings))
                (push (cons key (bibtex-text-in-string bounds t))
                      strings))
            (goto-char (bibtex-end-of-text-in-string bounds)))
          ;; successful operation --> return `bibtex-strings'
          (setq bibtex-strings strings))))))

(defun bibtex-field-list (entry-type)
  "Return list of allowed fields for entry ENTRY-TYPE.
More specifically, the return value is a cons pair (REQUIRED . OPTIONAL),
where REQUIRED and OPTIONAL are lists of the required and optional field
names for ENTRY-TYPE according to `bibtex-entry-field-alist'."
  (let ((e (assoc-ignore-case entry-type bibtex-entry-field-alist))
        required optional)
    (unless e
      (error "Bibtex entry type %s not defined" entry-type))
    (if (and (member-ignore-case entry-type bibtex-include-OPTcrossref)
             (nth 2 e))

    (let* ((fields-alist (bibtex-parse-entry))
           (field-list (bibtex-field-list
                        (substring (cdr (assoc "=type=" fields-alist))
                                   1)))) ; don't want @
      (dolist (field (car field-list))
        (unless (assoc-ignore-case (car field) fields-alist)
          (bibtex-make-field field)))
      (dolist (field (cdr field-list))
        (unless (assoc-ignore-case (car field) fields-alist)
          (bibtex-make-optional-field field))))))

(defun bibtex-parse-entry ()
  "Parse entry at point, return an alist.
The alist elements have the form (FIELD . TEXT), where FIELD can also be

	(while (setq bounds (bibtex-parse-field bibtex-field-name))
	  (goto-char (bibtex-start-of-name-in-field bounds))
	  (let* ((name (buffer-substring
			(if (looking-at "ALT\\|OPT") (match-end 0) (point))
			(bibtex-end-of-name-in-field bounds)))
		 (text (assoc-ignore-case name other)))
	    (goto-char (bibtex-start-of-text-in-field bounds))
	    (if (not (and (looking-at bibtex-empty-field-re) text))
		(goto-char (bibtex-end-of-field bounds))
	      (delete-region (point) (bibtex-end-of-text-in-field bounds))
	      (insert (cdr text)))))

                            (match-end 0) mb)
                        (bibtex-end-of-name-in-field bounds)))
           (field-list (bibtex-field-list (progn (re-search-backward
                                                  bibtex-entry-maybe-empty-head nil t)
                                                 (bibtex-type-in-head))))
           (comment (assoc-ignore-case field-name
                                       (append (car field-list)
                                               (cdr field-list)))))
      (if comment
          (message (nth 1 comment))
        (message "No comment available")))))

(defun bibtex-make-field (field &optional called-by-yank)

               (lambda (key beg end)
                 (bibtex-progress-message)
                 (let* ((entry-list (progn
                                      (goto-char beg)
                                      (bibtex-search-entry nil end)
                                      (assoc-ignore-case (bibtex-type-in-head)
                                                         bibtex-entry-field-alist)))
                        (req (copy-sequence (elt (elt entry-list 1) 0)))
                        (creq (copy-sequence (elt (elt entry-list 2) 0)))
                        crossref-there bounds)
                   (goto-char beg)
                   (while (setq bounds (bibtex-search-forward-field

                                (not (string-match questionable-month
                                                   (bibtex-text-in-field-bounds bounds))))
                           (push (list (bibtex-current-line)
                                       "Questionable month field")
                                 error-list))
                       (setq req (delete (assoc-ignore-case field-name req) req)
                             creq (delete (assoc-ignore-case field-name creq) creq))
                       (if (equal field-name "crossref")
                           (setq crossref-there t))))
                   (if crossref-there
                       (setq req creq))
                   (if (or (> (length req) 1)

55730:b4eeb441c089

            (beg (copy-marker (match-beginning 0)))
            (end (copy-marker (save-excursion (bibtex-end-of-entry)))))
        (save-excursion
          (if (or (and (not bibtex-sort-ignore-string-entries)
                       (string-equal "string" (downcase entry-type)))
                  (assoc-string entry-type bibtex-entry-field-alist t))
              (funcall fun key beg end)))
        (goto-char end)))))

(defun bibtex-progress-message (&optional flag interval)
  "Echo a message about progress of current buffer.

        ;; identify entry type
        (goto-char (point-min))
        (re-search-forward bibtex-entry-type)
        (let ((beg-type (1+ (match-beginning 0)))
              (end-type (match-end 0)))
          (setq entry-list (assoc-string (buffer-substring-no-properties
					  beg-type end-type)
					 bibtex-entry-field-alist
					 t))

          ;; unify case of entry name
          (when (memq 'unify-case format)
            (delete-region beg-type end-type)
            (insert (car entry-list)))

            ;; anyway. So for speed-up we avoid using them.

            (if (memq 'opts-or-alts format)
                (cond ((and empty-field
                            (or opt-alt
                                (let ((field (assoc-string
                                              field-name req-field-list t)))
                                  (or (not field)       ; OPT field
                                      (nth 3 field))))) ; ALT field
                       ;; Either it is an empty ALT field. Then we have checked
                       ;; already that we have one non-empty alternative. Or it
                       ;; is an empty OPT field that we do not miss anyway.

		      (insert booktitle))))

              ;; if empty field, complain
              (if (and empty-field
                       (memq 'required-fields format)
                       (assoc-string field-name req-field-list t))
                  (error "Mandatory field `%s' is empty" field-name))

              ;; unify case of field name
              (if (memq 'unify-case format)
                  (let ((fname (car (assoc-string
                                     field-name
				     (append (nth 0 (nth 1 entry-list))
					     (nth 1 (nth 1 entry-list))
					     bibtex-user-optional-fields)
				     t))))
                    (if fname
                        (progn
                          (delete-region beg-name end-name)
                          (goto-char beg-name)
                          (insert fname))

                      (throw 'userkey 'aborted))
                  (let ((key (cond ((match-end 3)
                                    ;; This is a crossref.
                                    (buffer-substring-no-properties
                                     (1+ (match-beginning 3)) (1- (match-end 3))))
                                   ((assoc-string (bibtex-type-in-head)
						  bibtex-entry-field-alist t)
                                    ;; This is an entry.
                                    (match-string-no-properties bibtex-key-in-head)))))
                    (if (and (stringp key)
                             (not (assoc key reference-keys)))
                      (push (list key) reference-keys)))))

            (if (and abortable
                     (input-pending-p))
                ;; user has aborted by typing a key --> return `aborted'
                (throw 'userkey 'aborted))
            (setq key (bibtex-reference-key-in-string bounds))
            (if (not (assoc-string key strings t))
                (push (cons key (bibtex-text-in-string bounds t))
                      strings))
            (goto-char (bibtex-end-of-text-in-string bounds)))
          ;; successful operation --> return `bibtex-strings'
          (setq bibtex-strings strings))))))

(defun bibtex-field-list (entry-type)
  "Return list of allowed fields for entry ENTRY-TYPE.
More specifically, the return value is a cons pair (REQUIRED . OPTIONAL),
where REQUIRED and OPTIONAL are lists of the required and optional field
names for ENTRY-TYPE according to `bibtex-entry-field-alist'."
  (let ((e (assoc-string entry-type bibtex-entry-field-alist t))
        required optional)
    (unless e
      (error "Bibtex entry type %s not defined" entry-type))
    (if (and (member-ignore-case entry-type bibtex-include-OPTcrossref)
             (nth 2 e))

    (let* ((fields-alist (bibtex-parse-entry))
           (field-list (bibtex-field-list
                        (substring (cdr (assoc "=type=" fields-alist))
                                   1)))) ; don't want @
      (dolist (field (car field-list))
        (unless (assoc-string (car field) fields-alist t)
          (bibtex-make-field field)))
      (dolist (field (cdr field-list))
        (unless (assoc-string (car field) fields-alist t)
          (bibtex-make-optional-field field))))))

(defun bibtex-parse-entry ()
  "Parse entry at point, return an alist.
The alist elements have the form (FIELD . TEXT), where FIELD can also be

	(while (setq bounds (bibtex-parse-field bibtex-field-name))
	  (goto-char (bibtex-start-of-name-in-field bounds))
	  (let* ((name (buffer-substring
			(if (looking-at "ALT\\|OPT") (match-end 0) (point))
			(bibtex-end-of-name-in-field bounds)))
		 (text (assoc-string name other t)))
	    (goto-char (bibtex-start-of-text-in-field bounds))
	    (if (not (and (looking-at bibtex-empty-field-re) text))
		(goto-char (bibtex-end-of-field bounds))
	      (delete-region (point) (bibtex-end-of-text-in-field bounds))
	      (insert (cdr text)))))

                            (match-end 0) mb)
                        (bibtex-end-of-name-in-field bounds)))
           (field-list (bibtex-field-list (progn (re-search-backward
                                                  bibtex-entry-maybe-empty-head nil t)
                                                 (bibtex-type-in-head))))
           (comment (assoc-string field-name
				  (append (car field-list)
					  (cdr field-list))
				  t)))
      (if comment
          (message (nth 1 comment))
        (message "No comment available")))))

(defun bibtex-make-field (field &optional called-by-yank)

               (lambda (key beg end)
                 (bibtex-progress-message)
                 (let* ((entry-list (progn
                                      (goto-char beg)
                                      (bibtex-search-entry nil end)
                                      (assoc-string (bibtex-type-in-head)
						    bibtex-entry-field-alist t)))
                        (req (copy-sequence (elt (elt entry-list 1) 0)))
                        (creq (copy-sequence (elt (elt entry-list 2) 0)))
                        crossref-there bounds)
                   (goto-char beg)
                   (while (setq bounds (bibtex-search-forward-field

                                (not (string-match questionable-month
                                                   (bibtex-text-in-field-bounds bounds))))
                           (push (list (bibtex-current-line)
                                       "Questionable month field")
                                 error-list))
                       (setq req (delete (assoc-string field-name req t) req)
                             creq (delete (assoc-string field-name creq t) creq))
                       (if (equal field-name "crossref")
                           (setq crossref-there t))))
                   (if crossref-there
                       (setq req creq))
                   (if (or (> (length req) 1)