; Problem with this RE: a) If the line before the function declaration
; is a preprocessor directive (like a #define) ending in one or more
; c++ type keywords they will get included into the type spec.  b) if
; you define a symbol like #define _const const the expression won't
; work at all

; Another possible regexp for c++-simple-type-regexp is "^.+". This
; will make any text before the name of the function but in the same
; line be the type of the function. Problem: Type cannot span multiple
; lines.

(defvar c++-prefixes '("__inline__" "static"))

(defconst c++-simple-type-regexp "\\(\\([ \t\n\r]+\\(inline\\|explicit\\|unsigned\\|signed\\|short\\|long\\|const\\|static\\|friend\\)\\)*[ \t\n\r]+[a-zA-Z0-9_]+\\(<[a-zA-Z0-9_, \t\n\t]*>\\)?\\([ \t\n\r]+\\(const[ \t\n\r]+\\)\\)?\\([*&]\\|\\[[ \t\n\r]*[0-9]+[ \t\n\r]*\\]\\)*\\([ \t\n\r]+const\\)?\\)[ \t\n\r]*"
  "*The RE for a simple type in C++ that is types that neither involve
  blocks nor functions")

(defconst c++-function-regexp "[^a-zA-Z0-9_:]\\(\\([a-zA-Z0-9_]+\\(<[a-zA-Z0-9_, \t\n\r]*>\\)?::\\)*\\(\\(operator[ \t\n\r]*\\([-+*/.&^|=]\\|++\\|--\\|&&\\|||\\|new\\|delete\\|()\\|\\[\\]\\|->\\|[^();{}]+\\)=?\\)\\|~?[a-zA-Z0-e9_]+\\)\\)[ \t\n\r]*"
  "The RE for a function definition or declaration")

(defconst c++-class-regexp "\\(class\\|namespace\\)[ \t\n\r]+\\([a-zA-Z0-9_:]+\\)\\([ \t\n\r]*:\\([ \t\n\r]*\\(public\\|protected\\|private\\)?[ \t\n\r]*\\([a-zA-Z0-9_]+\\(<[^>]*>\\)?\\(::\\)?\\)*[ \t\n\r]*,?\\)*\\)?[ \t\n\r]*"
  "The RE for a class declaration")

(defconst c++-template-regexp "template[ \t\n\r]*<\\([^>]*\\)>[ \t\n\r]*"
  "The RE for matching template clauses.")

(defconst c++-function-keywords 
  '( "if" "while" "for" "repeat" "class" "struct" "union" "switch" )
  "C++ Keywords which may introduce a block")

(defconst c++-keywords 
  '( "if" "while" "for" "repeat" "class" "struct" "union" "typedef"
     "char" "int" "float" "double" "signed" "unsigned" "long" "const"
     "switch" "case" "repeat" "until" "do" "class" "public"
     "protected" "private" "friend" "operator" "void" "static" "explicit" )
  "C++ keywords")

(defvar c++-smart-wrap-column 80)

(require 'cc-cmds)
(require 'cc-engine)

(defun c++-scan-type-backward ()
  "Scans backward to find the longest valid simple type ending at POINT.
Assumes POINT is at the end of a C++ simple type expression. 
Leaves POINT at the beginning of the type expression and returns 
 ( TYPE-START . TYPE-END )"
  (save-excursion
    (let ((end (point))
	  start)
      (re-search-backward c++-simple-type-regexp 'nil 't)
      (catch 'exit
	(while (and (re-search-forward c++-simple-type-regexp end 't)
		    (< (abs (- end (match-end 0))) 2))
	  (goto-char (match-beginning 0))
	  (setq start (point))
	  (if (not (re-search-backward c++-simple-type-regexp 'nil 't)) 
	      (throw 'exit))))
      (if start
          (progn
	    (goto-char start)
            (skip-chars-forward " \t\n\r")
	    (setq start (point))
            (goto-char end)
            (skip-chars-backward " \t\n\r" start)
	    (cons start (point)))
	'nil ))))

(defun c++-get-function ()
  "Get the last function declared or called at or after POINT.
Returns a list 
        ( ( DECL-START . DECL-END ) 
          ( TYPE-START . TYPE-END ) 
	  ( NAME-START . NAME_END ) 
	  ( ARGLIST-START . ARGLIST-END )
          ( FLAGS-START . FLAGS-END ) )"
  (save-excursion
    (if (re-search-backward (concat c++-function-regexp "(") 'nil 'true)
	(goto-char (match-end 0)))
    (if (re-search-forward (concat c++-function-regexp "(") 'nil 't)
	(let (type name arglist flags)
	  (setq name (cons (match-beginning 1) (match-end 1)))
	  (goto-char (1- (match-end 0)))
	  (setq arglist (cons (point) 'nil))
	  (if (condition-case nil
		  (progn (forward-list 1) t)
		(scan-error nil))
	      (progn
		(setcdr arglist (point))
		(if (looking-at "\\([ \t\n\r]*\\(const\\|throw[ \t\n\r]*([^();{}]*)\\|__throw__[ \t\n\t]*(([^();{}]*))\\)\\)*")
		    (progn
		      (setq flags (cons (match-beginning 0) (match-end 0)))
		      (goto-char (match-end 0)))
		  (setq flags (cons (cdr arglist) (cdr arglist))))
		(if (looking-at "[ \t\n\r]*:[^;{]*")
		    (goto-char (match-end 0)))
		(if (looking-at "[ \t\n\r]*[{;]")
		    (progn
		      (goto-char (car name))
		      (setq type (c++-scan-type-backward))
		      (if (not type) (setq type (cons (car name) (car name))))
		      (list (cons (car type) (cdr flags)) type name arglist flags)))))))))

(defun c++-get-function-defn ()
  "Get the function defined at POINT.
Returns a list 
	( ( DECL-START . DECL-END ) 
	  ( TYPE-START . TYPE-END ) 
	  ( NAME-START . NAME_END ) 
	  ( ARGLIST-START . ARGLIST-END ) 
          ( FLAGS-START . FLAGS-END )
	  ( BODY-START . BODY-END) )"
  (save-excursion
    (let (body fn end)
      (while (not fn)
	(if (condition-case nil 
		(progn (up-list -1) t) 
	      (error (setq fn t) nil))
	    (save-excursion
	      (setq body (cons (point) (save-excursion 
					 (forward-list 1) 
					 (point))))
	      (save-excursion
		(while (condition-case nil
			   (progn 
			     (up-list -1) 
			     (setq end (point))
			     t)
			 (scan-error nil))))
	      (while (re-search-backward (concat c++-function-regexp "(") end t)
		(let ((tryfn (c++-get-function)))
		  (if tryfn
		      (save-excursion
			(goto-char (cdar tryfn))
			(if (and (looking-at "[ \t\n\r]*\\(:[^;{]*\\)?{")
				 (eq (1- (match-end 0)) (car body)))
			    (progn
			      (if (match-beginning 1)
				  (setcar body (match-beginning 1)))
			      (setq fn tryfn))))))))))
      (if (eq fn t)
	  nil
	(nconc fn (list body))))))

(defun c++-get-classname ()
  "Get classname which is active at POINT"
  (let (class
	(re 't))
    (save-excursion
      (while re
	(if (and (condition-case nil 
		     (progn (up-list -1) 't) 
		   (error (setq re 'nil)))
		 (re-search-backward  (concat c++-class-regexp "\\=") 'nil 't))
	    (setq class (concat (match-string 2)
				(if class "::" "")
				class )))))
    class))

(defun c++-get-current-class-prefix ()
  "Get the class prefix currently active at POINT.
If within a class decl, returns that class name (nested classes
are supported). If within a function definition at global level,
returns the class prefix of this function. Returns 'nil if no
class prefix can be found"
  (let ((x (c++-get-classname)))
    (if x
	x
      (let ((x (or (c++-get-function-defn)
		   (c++-get-function))))
	(if x
	    (save-excursion
	      (goto-char (car (nth 2 x)))
	      (if (re-search-forward "\\=\\([a-zA-Z_0-9]+::\\)+")
		  (buffer-substring (match-beginning 0) (- (match-end 0) 2))
		'nil))
	  'nil)))))
	    
(defun c++-split-template-arg (arg)
  "Split ARG, a template argument list, and return list of arg names."
  (let ((raw-args (split-string arg "[ \t\n\r]*,[ \t\n\r]")))
    (loop for raw-arg in raw-args
	  if (string-match "[a-zA-Z0-9_-]+$" raw-arg)
	    collect (match-string 0 raw-arg)
	  else
	    collect raw-arg)))

(defun c++-get-classname-with-templates ()
  (let (classname template-args
	(re 't))
    (save-excursion
      (while re
	(if (and (condition-case nil 
		     (progn (up-list -1) 't) 
		   (error (setq re 'nil)))
		 (re-search-backward  (concat c++-class-regexp "\\=") nil t))
	    (let ((template-suffix "")
		  (class (match-string 2)))
	      (if (re-search-backward (concat c++-template-regexp "\\=") nil t)
		  (let* ((s (match-string 1))
			 (args (c++-split-template-arg s))
			 (raw-args (split-string s "[ \t\n\r]*,[ \t\n\r]")))
		    (setq template-suffix
			  (concat "<" (mapconcat 'identity args ",") ">"))
		    (loop for arg in raw-args
			  if (not (member arg template-args))
			    do (setq template-args
				     (nconc template-args (list arg))))))
	      (setq classname (concat class
				      template-suffix
				      (if classname "::" "")
				      classname))))))
    (and classname
	 (cons classname
	       (and template-args
		    (mapconcat 'identity template-args ", "))))))

(defun c++-get-current-class-prefix-with-templates ()
  "Get the class prefix currently active at POINT.
If within a class decl, returns that class name (nested classes
are supported). If within a function definition at global level,
returns the class prefix of this function. Returns 'nil if no
class prefix can be found"
  (let ((x (c++-get-classname-with-templates)))
    (if x
	(car x)
      (let ((x (or (c++-get-function-defn)
		   (c++-get-function))))
	(if x
	    (save-excursion
	      (goto-char (car (nth 2 x)))
	      (if (re-search-forward "\\=\\([a-zA-Z_0-9]+\\(<[a-zA-Z0-9_, \t\n\r]*>\\)?::\\)+")
		  (buffer-substring (match-beginning 0) (- (match-end 0) 2))
		'nil))
	  'nil)))))

(defun c++-grab-inline-decl ()
  "Grab the inline declaration at POINT and change it into a standard
declaration.  This function deletes the declaration found at POINT and
places the new declaration into the top of the kill ring"
  (interactive)
  (let ((fn (c++-get-function-defn))
	(class (c++-get-classname-with-templates)))
    (if (and fn class)
	(progn
	  (kill-new (concat (if (cdr class)
				(concat "template <" (cdr class) ">\n")
			      "")
			    "inline "
			    (buffer-substring (car (nth 0 fn)) (car (nth 2 fn)))
			    (car class) "::"
			    (buffer-substring (car (nth 2 fn)) (cdr (nth 5 fn)))
			    "\n"))
	  (delete-region (cdr (nth 4 fn)) (cdr (nth 5 fn)))
	  (goto-char (cdr (nth 4 fn)))
	  (insert ";")
	  (delete-blank-lines))
      (if (interactive-p) 
	  (message "Not inside inline function definition body")))))

(defun c++-insert-class-prefix ()
  "Insert the current class prefix at POINT.
See also c++-get-current-class-prefix"
  (interactive)
  (let ((x (c++-get-current-class-prefix-with-templates)))
    (if x
	(insert x "::")
      (message "Not in scope of any class"))))

(defun c++-next-user-symbol ()
  "Move POINT to next non-keyword symbol."
  (interactive)
  (let (pos)
    (if (looking-at "[a-zA-Z_:]+")
	(setq pos (re-search-forward "[a-zA-Z_:]+" 'nil 't)))
    (while (and (setq pos (re-search-forward "[a-zA-Z_:]*[a-zA-Z_]" 'nil 't))
		(or (member (match-string 0) c++-keywords)
		    (c-in-literal))))
    (goto-char pos)))

(defun c++-previous-user-symbol ()
  "Move POINT to previous non-keyword symbol."
  (interactive)  
  (while (and (re-search-backward "[a-zA-Z_]" 'nil 't)
	      (progn (skip-chars-backward "a-zA-Z_:") 
		     (or (member (buffer-substring (point) (match-end 0)) 
				 c++-keywords)
			 (c-in-literal))))))

(defun c++-next-function-call ()
  "Move POINT to next function call"
  (interactive)
  (let ((start (point))
	fn)
    (while (and (setq fn (c++-get-function))
		(or (>= start (car (nth 0 fn)))
		    (member (buffer-substring (car (nth 2 fn)) (cdr (nth 2 fn)))
			    c++-function-keywords)
		    (/= (car (nth 1 fn)) (car (nth 2 fn)))))		    
      (goto-char (cdr (nth 0 fn)))
      (re-search-forward "{;" 'nil 't))
    (goto-char (if fn (car (nth 0 fn)) start))))
    
(defun c++-next-function-definition ()
  "Move POINT to the next function definition or declaration"
  (interactive)
  (let ((start (point))
	fn)
    (while (and (setq fn (c++-get-function))
		(or (>= start (car (nth 0 fn)))
		    (member (buffer-substring (car (nth 2 fn)) (cdr (nth 2 fn)))
			    c++-function-keywords)
		    (= (car (nth 1 fn)) (car (nth 2 fn)))))		    
      (goto-char (cdr (nth 0 fn)))
      (re-search-forward "[{;]" 'nil 't))
    (goto-char (if fn (car (nth 0 fn)) start))))
  
(defun c++-smart-yank ()
  "Yank-pop top of kill ring and reformat the yanked object."
  (interactive)
  (push-mark)
  (let ((text (current-kill 0))
	end-mark line-start)
    (save-excursion
      (insert text)
      (setq end-mark (point-marker)))
    (while (< (point) (marker-position end-mark))
      (beginning-of-line)
      (c-indent-command)
      (setq line-start (point))
      (end-of-line)
      (if (> (current-column) c++-smart-wrap-column)
	  (progn
	    (move-to-column c++-smart-wrap-column)
	    (if (search-backward ",")
		(progn
		  (forward-char 1)
		  (open-line 1)))))
      (forward-line 1))))

(provide 'c++)