 		    (or (er--point-is-in-comment-p)
 			(er--point-is-in-string-p)))
 	  (setq last-point found-point)
-	  (setq found-point (re-search-forward regexp limit errorp)))
+	  (setq found-point (re-search-forward regexp (min (point-max) limit) errorp)))
 	found-point))
-  (re-search-forward regexp limit errorp))
+  (re-search-forward regexp (min (point-max) limit) errorp))
 
 (defun start-of-function ()
   ;; get the start of the function

  (if *use-real-search*
      (let ((last-point (point))
	    ;; do a first search
	    (found-point (re-search-backward regexp limit errorp)))
	;; checks that we are moving to avoid loops
	(while (and found-point
		    (< (point) last-point)
		    (or (er--point-is-in-comment-p)
			(er--point-is-in-string-p)))
	  (setq last-point found-point)
	  (setq found-point (re-search-backward regexp limit errorp)))
	found-point))
  (re-search-backward regexp limit errorp))


  (save-excursion
    ;; we ignore errors because the forward-list can fail if parenthesis are not balanced
    ;; in that case, we do nothing.
    (let ((start-function (start-of-function)))
      (when start-function
	(goto-char start-function)
	(let* ((begin-args (progn (while (and (not (looking-at "("))
					      (< (point) (point-max)))
				    (forward-char))
				  (if (eq (point) (point-max))
				      nil				   
				    (point))))
	       (end-args (progn (while (and (not (looking-at ")"))
					    (< (point) (point-max)))
				  (forward-char))
				(if (eq (point) (point-max))
				    nil
				  (point))))
	       (begin-function (progn (while (and (not (looking-at "{"))
						  (< (point) (point-max)))
					(forward-char))
				      (if (eq (point) (point-max))
					  nil
					(point))))
	       (end-function (end-of-function))
	       (function-line (when end-args (buffer-substring-no-properties start-function (1+ end-args) )))
	       vars)
	  ;; arguments
	  (when (and function-line begin-args end-args)
	    (dolist (arg (split-string (buffer-substring-no-properties (1+ begin-args) end-args) "[ \t,]+" t))
	      (if list-of-cons
		  (push (cons arg function-line) vars)
		(push arg vars))))
	  ;; vars inside of the function
	  (when (and begin-function end-function)
	    (goto-char begin-function)
	    (while (re-search-forward *ojs-vars-regexp* (min (point-max) end-function) t)	      
	      (if list-of-cons
		  (push (cons (match-string-no-properties 1) (match-string-no-properties 0)) vars)
		(push (match-string-no-properties 1) vars)))
	    vars))))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
