(defun quiet-replace-regexp (regexp to-string)
  (save-excursion
    (goto-char (point-min))
    (while (re-search-forward regexp nil t)
      (replace-match to-string nil nil))))

(defun qrep-car-cdr (base)
  (quiet-replace-regexp (concat "XCONS ?(\\(" base "\\))->car") "XCAR (\\1)")
  (quiet-replace-regexp (concat "XCONS ?(\\(" base "\\))->cdr") "XCDR (\\1)")
  )

(defun qrep-float (base)
  (quiet-replace-regexp (concat "XFLOAT ?(\\(" base "\\))->data")
			"XFLOAT_DATA (\\1)")
  )

;; All of these must accept only paren-balanced C expressions.  No
;; wildcard matching here...
(defvar c-exprs nil "")
(setq c-exprs
      '(
	;; no leading whitespace!
	"[-*a-z_A-Z0-9.][-*a-z_A-Z0-9.]*"
	"[-*a-z_A-Z0-9.][-*a-z_A-Z0-9.]*-> *[*a-z_A-Z0-9.]+"
	;; a(b), zero or more trailing ->s
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*([-a-z_A-Z0-9> .]*)[-a-z_>]*"
	;; a(b(c)), trailing ->s at end and after b(c)
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*([a-z_A-Z0-9 ]+([a-z_A-Z0-9 ]*)[-a-z_>]*)[-a-z_>]*"
	;; a(b(c(d)))
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*([a-z_A-Z0-9 ]+([a-z_A-Z0-9 ]+([a-z_A-Z0-9 ]*)))"
	;; something subscripted - a[b]
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*\\[[a-z_A-Z0-9 ]+\\]"
	;; a(b[c])
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*([a-z_A-Z0-9 ]+\\[[a-z_A-Z0-9 ]+\\])"
	;; GET_TRANSLATION_TABLE macro defn - subscript in the arg
	;; a(b)->c[(d)]
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*([a-z_A-Z0-9 ]*)->[a-z_A-Z0-9]+\\[([a-z_A-Z0-9 ]+)\\]"
	;; xfaces uses a->b[c]
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*->[a-z_A-Z0-9]+\\[[a-z_A-Z0-9 ]+\\]"
	;; (x)
	"([-*a-z_A-Z0-9.][-*a-z_A-Z0-9.]*)"
	;; f(a->b[c])
	"[a-z_A-Z0-9][a-z_A-Z0-9 ]*([a-z_A-Z0-9 ]*->[a-z_A-Z0-9]+\\[[a-z_A-Z0-9 ]+\\])"
	;; ( ! f(a) \n ? b \n : c ), where a b c can contain ->
	"(!?[a-z_A-Z0-9][a-z_A-Z0-9 ]*([->a-z_A-Z0-9 ]*)[ \n\t]*\\? [->a-z_A-Z0-9 ]*[ \n\t]*: [->a-z_A-Z0-9 ]*)"
	;; pure numbers (as extra macro args, of course, not variables)
	"-?[0-9][0-9]*"
	))
(defvar c-all-exprs nil "")
(setq c-all-exprs
      (apply 'concat
	     (car c-exprs)
	     (mapcar (lambda (x) (concat "\\|" x)) (cdr c-exprs))))

(defun scmcvt-car-and-cdr ()
  (interactive)
  (mapcar 'qrep-car-cdr c-exprs)

  ;; be careful -- this can change the definition of XFLOAT_DATA itself
  (qrep-float "[-*a-z_A-Z0-9>]+")
  (qrep-float "[-*a-z_A-Z0-9>]+\\[[a-z]+\\]")
  )

(defun map-over-files (fun)
  (let ((names (directory-files "." nil "\\.[ch]$")))
    (mapcar fun names)))

(defun get-fn-value (f)
  (if (symbolp f)
      (get-fn-value (symbol-function f))
    f))

(defun apply-and-save-wrapper (fun)
  (let ((x (get-fn-value fun)))
    (eval `(lambda (fn) (apply-and-save ,x fn)))))

(defun apply-and-save (fun fn)
  (if (file-regular-p fn)
      (progn
	(message "Working on %s..." fn)
	(find-file fn)
	(goto-char (point-min))
	(funcall fun)
	(if (buffer-modified-p nil)
	    (save-buffer))
	(kill-buffer nil)
	(message "Working on %s...done" fn)
	)))

(defun map-edit-files (fun)
  (let ((enable-local-variables nil))
    (map-over-files (apply-and-save-wrapper fun)))
  nil
  )

(defun qrep-string (base)
  (quiet-replace-regexp (concat "SMBP ?(\\(" base "\\))")
			"STRING_MULTIBYTE (\\1)")
  ;; do size_byte before size, since the latter is a substring of the
  ;; former and would match
  (quiet-replace-regexp (concat "XSTRING ?(\\(" base "\\))->size_byte")
			"STRING_SIZE_BYTE (\\1)")
  (quiet-replace-regexp (concat "XSTRING ?(\\(" base "\\))->size")
			"SCHARS (\\1)")
  (quiet-replace-regexp (concat "STRING_SIZE_BYTE ?(\\(" base "\\))")
			"XSTRING (\\1)->size_byte")
  ;; other fields
  (quiet-replace-regexp (concat "XSTRING ?(\\(" base "\\))->intervals")
			"STRING_INTERVALS (\\1)")
  (quiet-replace-regexp (concat "XSTRING ?(\\(" base "\\))-> *data")
			"SDATA (\\1)")
  (quiet-replace-regexp (concat "STRING_BYTES (XSTRING ?(\\(" base "\\)))")
			"SBYTES (\\1)")
  (quiet-replace-regexp (concat "XSETSTRING (\\(" base "\\),[\n\t ]*XSTRING (\\(" base "\\)))")
			"\\1 = \\2")
  (quiet-replace-regexp (concat "SET_STRING_BYTES (XSTRING ?(\\(" base "\\)), -1)")
			"STRING_SET_UNIBYTE (\\1)")
  (quiet-replace-regexp (concat "SDATA (\\(" base "\\)) *\\[\\(" base "\\)\\]")
			"SREF (\\1, \\2)")
  )

(defun qrep-string-2 (base)
  (quiet-replace-regexp (concat "SET_STRING_BYTES (XSTRING ?(\\(" base "\\)), *\\((" base ")\\))")
			"STRING_SET_BYTES (\\1, \\2)")
  (quiet-replace-regexp (concat "STRING_SET_BYTES (\\(" base "\\), -1)")
			"STRING_SET_UNIBYTE (\\1)")

  )

(defun scmcvt-string ()
  (interactive)
  (mapcar 'qrep-string c-exprs))

(defun scmcvt-string-2 ()
  (interactive)
  (mapcar 'qrep-string-2 c-exprs))

(defun scmcvt-all ()
  (scmcvt-car-and-cdr)
  (scmcvt-string)
  )

(if nil
    (progn

      ;; run these forms one at a time
      (map-edit-files 'scmcvt-car-and-cdr)

      (map-edit-files 'scmcvt-string)
      (map-edit-files 'scmcvt-string-2)
      (map-edit-files 'scmcvt-all)

))