Fix unintended renaming

1 files changed, 237 insertions, 237 deletions

diff --git a/scripts/kde-emacs/kde-emacs-core.el b/scripts/kde-emacs/kde-emacs-core.el
index eaa63a0c..030ffd39 100644
--- a/scripts/kde-emacs/kde-emacs-core.el
+++ b/scripts/kde-emacs/kde-emacs-core.el
@@ -67,7 +67,7 @@ Try to finish the symbol, or indent the line."
          (let ((count 0)
                (bmp (buffer-modified-p)))
            (while (re-search-forward "[ \t]+$" nil t)
-             (setq count (1+ count))
+             (set count (1+ count))
              (replace-match "" t t))
            (set-buffer-modified-p bmp)
 	   nil
@@ -98,13 +98,13 @@ With arg, do it arg times."
       "XEmacs doesn't have font-lock-add-keywords so we provide it."
       (font-lock-set-defaults)
       (if (eq append 'set)
-	  (setq font-lock-keywords keywords)
+	  (set font-lock-keywords keywords)
 	; NOTE: write this function for XEmacs - Zack
 	;(font-lock-remove-keywords nil keywords) ;to avoid duplicates
 	(let ((old (if (eq (car-safe font-lock-keywords) t)
 		       (cdr font-lock-keywords)
 		     font-lock-keywords)))
-	  (setq font-lock-keywords (if append
+	  (set font-lock-keywords (if append
 				       (append old keywords)
 				     (append keywords old))))))
   )
@@ -138,7 +138,7 @@ With arg, do it arg times."
 			 ))
 		    
 ;; KDE C++ mode
-;; Not a "(setq c++-mode-hook ..." because this way we would
+;; Not a "(set c++-mode-hook ..." because this way we would
 ;; prune all other hooks!
 (defun kde-c++-mode-hook ()
   (font-lock-mode)
@@ -156,7 +156,7 @@ With arg, do it arg times."
   ;; access specifiers
   (font-lock-add-keywords nil '(("\\<\\(\\(public\\|protected\\|private\\) Q_SLOTS\\)\\>" 
 				 . font-lock-reference-face)))
-  ;; Add (setq magic-keys-mode nil) to your .emacs (before loading this file)
+  ;; Add (set magic-keys-mode nil) to your .emacs (before loading this file)
   ;; to disable the magic keys in C++ mode.
   (and (boundp 'magic-keys-mode) magic-keys-mode
        (progn
@@ -219,11 +219,11 @@ This function does not do any hidden buffer changes."
 		       (progn
 			 (goto-char (aref inclass-p 0))
 			 (looking-at c-other-decl-block-key)))
-	      (setq inenclosing-p (match-string 1))
+	      (set inenclosing-p (match-string 1))
 	      (if (string-equal inenclosing-p "extern")
 		  ;; Compatibility with legacy choice of name for the
 		  ;; extern-lang syntactic symbols.
-		  (setq inenclosing-p "extern-lang")))))
+		  (set inenclosing-p "extern-lang")))))
 
 	;; Init some position variables:
 	;;
@@ -246,22 +246,22 @@ This function does not do any hidden buffer changes."
 	;; opposed to c-state-cache.
 	(if c-state-cache
 	    (progn
-	      (setq containing-sexp (car paren-state)
+	      (set containing-sexp (car paren-state)
 		    paren-state (cdr paren-state))
 	      (if (consp containing-sexp)
 		  (progn
-		    (setq lim (cdr containing-sexp))
+		    (set lim (cdr containing-sexp))
 		    (if (cdr c-state-cache)
 			;; Ignore balanced paren.  The next entry
 			;; can't be another one.
-			(setq containing-sexp (car (cdr c-state-cache))
+			(set containing-sexp (car (cdr c-state-cache))
 			      paren-state (cdr paren-state))
 		      ;; If there is no surrounding open paren then
 		      ;; put the last balanced pair back on paren-state.
-		      (setq paren-state (cons containing-sexp paren-state)
+		      (set paren-state (cons containing-sexp paren-state)
 			    containing-sexp nil)))
-		(setq lim (1+ containing-sexp))))
-	  (setq lim (point-min)))
+		(set lim (1+ containing-sexp))))
+	  (set lim (point-min)))
 
 	;; If we're in a parenthesis list then ',' delimits the
 	;; "statements" rather than being an operator (with the
@@ -270,19 +270,19 @@ This function does not do any hidden buffer changes."
 	;; arglists.
 	(when (and containing-sexp
 		   (eq (char-after containing-sexp) ?\())
-	  (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
+	  (set c-stmt-delim-chars c-stmt-delim-chars-with-comma))
 
 	;; cache char before and after indent point, and move point to
 	;; the most likely position to perform the majority of tests
 	(goto-char indent-point)
 	(c-backward-syntactic-ws lim)
-	(setq char-before-ip (char-before))
+	(set char-before-ip (char-before))
 	(goto-char indent-point)
 	(skip-chars-forward " \t")
-	(setq char-after-ip (char-after))
+	(set char-after-ip (char-after))
 
 	;; are we in a literal?
-	(setq literal (c-in-literal lim))
+	(set literal (c-in-literal lim))
 
 	;; now figure out syntactic qualities of the current line
 	(cond
@@ -299,15 +299,15 @@ This function does not do any hidden buffer changes."
 	       ;; versions, which results in that we get nil from
 	       ;; `c-literal-limits' even when `c-in-literal' claims
 	       ;; we're inside a comment.
-	       (setq placeholder (c-literal-limits lim)))
+	       (set placeholder (c-literal-limits lim)))
 	  (c-add-syntax literal (car placeholder)))
 	 ;; CASE 3: in a cpp preprocessor macro continuation.
 	 ((and (save-excursion
 		 (when (c-beginning-of-macro)
-		   (setq macro-start (point))))
+		   (set macro-start (point))))
 	       (/= macro-start (c-point 'boi))
 	       (progn
-		 (setq tmpsymbol 'cpp-macro-cont)
+		 (set tmpsymbol 'cpp-macro-cont)
 		 (or (not c-syntactic-indentation-in-macros)
 		     (save-excursion
 		       (goto-char macro-start)
@@ -319,13 +319,13 @@ This function does not do any hidden buffer changes."
 		       ;; or anywhere in a non-#define directive.
 		       (if (c-forward-to-cpp-define-body)
 			   (let ((indent-boi (c-point 'boi indent-point)))
-			     (setq in-macro-expr (> (point) indent-boi)
+			     (set in-macro-expr (> (point) indent-boi)
 				   tmpsymbol 'cpp-define-intro)
 			     (= (point) indent-boi))
-			 (setq in-macro-expr t)
+			 (set in-macro-expr t)
 			 nil)))))
 	  (c-add-syntax tmpsymbol macro-start)
-	  (setq macro-start nil))
+	  (set macro-start nil))
 	 ;; CASE 11: an else clause?
 	 ((looking-at "else\\>[^_]")
 	  (c-beginning-of-statement-1 containing-sexp)
@@ -336,7 +336,7 @@ This function does not do any hidden buffer changes."
 	       (save-excursion
 		 (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
 			    'beginning)
-		   (setq placeholder (point)))))
+		   (set placeholder (point)))))
 	  (goto-char placeholder)
 	  (c-add-stmt-syntax 'do-while-closure nil t nil
 			     containing-sexp paren-state))
@@ -359,7 +359,7 @@ This function does not do any hidden buffer changes."
 			  (c-safe (c-backward-sexp) t)
 			t))
 		 (looking-at "\\(try\\|catch\\)\\>[^_]")
-		 (setq placeholder (point))))
+		 (set placeholder (point))))
 	  (goto-char placeholder)
 	  (c-add-stmt-syntax 'catch-clause nil t nil
 			     containing-sexp paren-state))
@@ -376,24 +376,24 @@ This function does not do any hidden buffer changes."
 		    (progn
 		      ;; Ought to cache the result from the
 		      ;; c-beginning-of-statement-1 calls here.
-		      (setq placeholder (point))
-		      (while (eq (setq step-type
+		      (set placeholder (point))
+		      (while (eq (set step-type
 				       (c-beginning-of-statement-1 lim))
 				 'label))
 		      (if (eq step-type 'previous)
 			  (goto-char placeholder)
-			(setq placeholder (point))
+			(set placeholder (point))
 			(if (and (eq step-type 'same)
 				 (not (looking-at c-opt-block-stmt-key)))
 			    ;; Step up to the containing statement if we
 			    ;; stayed in the same one.
 			    (let (step)
 			      (while (eq
-				      (setq step
+				      (set step
 					    (c-beginning-of-statement-1 lim))
 				      'label))
 			      (if (eq step 'up)
-				  (setq placeholder (point))
+				  (set placeholder (point))
 				;; There was no containing statement afterall.
 				(goto-char placeholder)))))
 		      placeholder))
@@ -434,19 +434,19 @@ This function does not do any hidden buffer changes."
 	 ((and (or c-opt-inexpr-class-key
 		   c-opt-inexpr-block-key
 		   c-opt-lambda-key)
-	       (setq placeholder (c-looking-at-inexpr-block
+	       (set placeholder (c-looking-at-inexpr-block
 				  (c-safe-position containing-sexp paren-state)
 				  containing-sexp)))
-	  (setq tmpsymbol (assq (car placeholder)
+	  (set tmpsymbol (assq (car placeholder)
 				'((inexpr-class . class-open)
 				  (inexpr-statement . block-open))))
 	  (if tmpsymbol
 	      ;; It's a statement block or an anonymous class.
-	      (setq tmpsymbol (cdr tmpsymbol))
+	      (set tmpsymbol (cdr tmpsymbol))
 	    ;; It's a Pike lambda.  Check whether we are between the
 	    ;; lambda keyword and the argument list or at the defun
 	    ;; opener.
-	    (setq tmpsymbol (if (eq char-after-ip ?{)
+	    (set tmpsymbol (if (eq char-after-ip ?{)
 				'inline-open
 			      'lambda-intro-cont)))
 	  (goto-char (cdr placeholder))
@@ -461,7 +461,7 @@ This function does not do any hidden buffer changes."
 	  (cond
 	   ;; CASE 5A: we are looking at a defun, brace list, class,
 	   ;; or inline-inclass method opening brace
-	   ((setq special-brace-list
+	   ((set special-brace-list
 		  (or (and c-special-brace-lists
 			   (c-looking-at-special-brace-list))
 		      (eq char-after-ip ?{)))
@@ -472,7 +472,7 @@ This function does not do any hidden buffer changes."
 		(skip-chars-forward " \t")
 		(and (c-safe (c-backward-sexp 2) t)
 		     (looking-at c-other-decl-block-key)
-		     (setq keyword (match-string 1)
+		     (set keyword (match-string 1)
 			   placeholder (point))
 		     (if (string-equal keyword "extern")
 			 ;; Special case for extern-lang-open.  The
@@ -482,8 +482,8 @@ This function does not do any hidden buffer changes."
 			      ;;  (c-forward-sexp 1)
 			      ;;  (c-forward-syntactic-ws)
 			      ;;  (eq (char-after) ?\"))
-			      (setq tmpsymbol 'extern-lang-open))
-		       (setq tmpsymbol (intern (concat keyword "-open"))))
+			      (set tmpsymbol 'extern-lang-open))
+		       (set tmpsymbol (intern (concat keyword "-open"))))
 		     ))
 	      (goto-char placeholder)
 	      (c-add-syntax tmpsymbol (c-point 'boi)))
@@ -493,7 +493,7 @@ This function does not do any hidden buffer changes."
 		(skip-chars-forward " \t{")
 		(let ((decl (c-search-uplist-for-classkey (c-parse-state))))
 		  (and decl
-		       (setq placeholder (aref decl 0)))
+		       (set placeholder (aref decl 0)))
 		  ))
 	      (c-add-syntax 'class-open placeholder))
 	     ;; CASE 5A.3: brace list open
@@ -502,18 +502,18 @@ This function does not do any hidden buffer changes."
 		(while (looking-at c-specifier-key)
 		  (goto-char (match-end 1))
 		  (c-forward-syntactic-ws indent-point))
-		(setq placeholder (c-point 'boi))
+		(set placeholder (c-point 'boi))
 		(or (consp special-brace-list)
 		    (and (or (save-excursion
 			       (goto-char indent-point)
-			       (setq tmpsymbol nil)
+			       (set tmpsymbol nil)
 			       (while (and (> (point) placeholder)
 					   (zerop (c-backward-token-2 1 t))
 					   (/= (char-after) ?=))
 				 (and c-opt-inexpr-brace-list-key
 				      (not tmpsymbol)
 				      (looking-at c-opt-inexpr-brace-list-key)
-				      (setq tmpsymbol 'topmost-intro-cont)))
+				      (set tmpsymbol 'topmost-intro-cont)))
 			       (eq (char-after) ?=))
 			     (looking-at c-brace-list-key))
 			 (save-excursion
@@ -568,12 +568,12 @@ This function does not do any hidden buffer changes."
 			 (c-backward-syntactic-ws lim)))
 	      (if (eq (char-before) ?\))
 		  (c-backward-sexp 1))
-	      (setq placeholder (point))
+	      (set placeholder (point))
 	      (save-excursion
 		(and (c-safe (c-backward-sexp 1) t)
 		     (looking-at "throw[^_]")
 		     (c-safe (c-backward-sexp 1) t)
-		     (setq placeholder (point))))
+		     (set placeholder (point))))
 	      (goto-char placeholder)
 	      (c-add-syntax 'member-init-intro (c-point 'boi))
 	      ;; we don't need to add any class offset since this
@@ -627,13 +627,13 @@ This function does not do any hidden buffer changes."
 		       (save-excursion
 			 (while (not done)
 			   (cond ((looking-at c-opt-postfix-decl-spec-key)
-				  (setq injava-inher (cons cont (point))
+				  (set injava-inher (cons cont (point))
 					done t))
 				 ((or (not (c-safe (c-forward-sexp -1) t))
 				      (<= (point) fence))
-				  (setq done t))
+				  (set done t))
 				 )
-			   (setq cont t)))
+			   (set cont t)))
 		       injava-inher)
 		     (not (c-crosses-statement-barrier-p (cdr injava-inher)
 							 (point)))
@@ -697,14 +697,14 @@ This function does not do any hidden buffer changes."
 			 (zerop (c-backward-token-2 1 nil lim))
 			 (eq (char-after) ?<)))))
 	    (goto-char indent-point)
-	    (setq placeholder
+	    (set placeholder
 		  (c-beginning-of-member-init-list lim))
 	    (cond
 	     ;; CASE 5D.1: hanging member init colon, but watch out
 	     ;; for bogus matches on access specifiers inside classes.
 	     ((and placeholder
 		   (save-excursion
-		     (setq placeholder (point))
+		     (set placeholder (point))
 		     (c-backward-token-2 1 t lim)
 		     (and (eq (char-after) ?:)
 			  (not (eq (char-before) ?:))))
@@ -740,7 +740,7 @@ This function does not do any hidden buffer changes."
 		     (save-restriction
 		       (c-with-syntax-table c++-template-syntax-table
 			 (goto-char indent-point)
-			 (setq placeholder (c-up-list-backward (point)))
+			 (set placeholder (c-up-list-backward (point)))
 			 (and placeholder
 			      (eq (char-after placeholder) ?<))))))
 	      ;; we can probably indent it just like an arglist-cont
@@ -751,7 +751,7 @@ This function does not do any hidden buffer changes."
 	     ((and (c-major-mode-is 'c++-mode)
 		   (save-excursion
 		     (c-beginning-of-statement-1 lim)
-		     (setq placeholder (point))
+		     (set placeholder (point))
 		     (if (looking-at "static\\>[^_]")
 			 (c-forward-token-2 1 nil indent-point))
 		     (and (looking-at c-class-key)
@@ -785,7 +785,7 @@ This function does not do any hidden buffer changes."
 	   ((and inclass-p
 		 c-opt-access-key
 		 (looking-at c-opt-access-key))
-	    (setq placeholder (c-add-class-syntax 'inclass inclass-p
+	    (set placeholder (c-add-class-syntax 'inclass inclass-p
 						  paren-state))
 	    ;; Append access-label with the same anchor point as inclass gets.
 	    (c-append-syntax 'access-label placeholder))
@@ -810,7 +810,7 @@ This function does not do any hidden buffer changes."
 	   ((and c-recognize-knr-p
 		 (not (eq char-before-ip ?}))
 		 (save-excursion
-		   (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
+		   (set placeholder (cdr (c-beginning-of-decl-1 lim)))
 		   (and placeholder
 			;; Do an extra check to avoid tripping up on
 			;; statements that occur in invalid contexts
@@ -829,7 +829,7 @@ This function does not do any hidden buffer changes."
            ;; CASE 5P: AWK pattern or function or continuation
            ;; thereof.
            ((c-mode-is-new-awk-p)
-            (setq placeholder (point))
+            (set placeholder (point))
             (c-add-stmt-syntax
              (if (and (eq (c-beginning-of-statement-1) 'same)
                       (/= (point) placeholder))
@@ -849,7 +849,7 @@ This function does not do any hidden buffer changes."
 			   ;; Speed up the backward search a bit.
 			   (goto-char (car (car paren-state))))
 		       (c-beginning-of-decl-1 containing-sexp)
-		       (setq placeholder (point))
+		       (set placeholder (point))
 		       (if (= start (point))
 			   ;; The '}' is unbalanced.
 			   nil
@@ -900,7 +900,7 @@ This function does not do any hidden buffer changes."
 			 macro-start
 			 (/= macro-start (c-point 'boi indent-point)))
 		(c-add-syntax 'cpp-define-intro)
-		(setq macro-start nil))
+		(set macro-start nil))
 	      ))
 	   ;; CASE 5K: we are at an ObjC method definition
 	   ;; continuation line.
@@ -934,7 +934,7 @@ This function does not do any hidden buffer changes."
 	   ;; C.f. case 7F.
 	   ((memq char-after-ip '(?\) ?\]))
 	    (goto-char containing-sexp)
-	    (setq placeholder (c-point 'boi))
+	    (set placeholder (c-point 'boi))
 	    (if (and (c-safe (backward-up-list 1) t)
 		     (> (point) placeholder))
 		(progn
@@ -949,11 +949,11 @@ This function does not do any hidden buffer changes."
 	   ;; and 17E.
 	   ((and (eq char-after-ip ?{)
 		 (progn
-		   (setq placeholder (c-inside-bracelist-p (point)
+		   (set placeholder (c-inside-bracelist-p (point)
 							   c-state-cache))
 		   (if placeholder
-		       (setq tmpsymbol '(brace-list-open . inexpr-class))
-		     (setq tmpsymbol '(block-open . inexpr-statement)
+		       (set tmpsymbol '(brace-list-open . inexpr-class))
+		     (set tmpsymbol '(block-open . inexpr-statement)
 			   placeholder
 			   (cdr-safe (c-looking-at-inexpr-block
 				      (c-safe-position containing-sexp
@@ -975,12 +975,12 @@ This function does not do any hidden buffer changes."
 	   ;; looking at a close paren or bracket.
 	   ((memq char-before-ip '(?\( ?\[))
 	    (goto-char containing-sexp)
-	    (setq placeholder (c-point 'boi))
+	    (set placeholder (c-point 'boi))
 	    (when (and (c-safe (backward-up-list 1) t)
 		       (> (point) placeholder))
 	      (forward-char)
 	      (skip-chars-forward " \t")
-	      (setq placeholder (point)))
+	      (set placeholder (point)))
 	    (c-add-syntax 'arglist-intro placeholder))
 	   ;; CASE 7D: we are inside a conditional test clause. treat
 	   ;; these things as statements
@@ -1016,7 +1016,7 @@ This function does not do any hidden buffer changes."
 	      (and (not (eolp))
 		   (not (looking-at "\\\\$"))))
 	    (goto-char containing-sexp)
-	    (setq placeholder (c-point 'boi))
+	    (set placeholder (c-point 'boi))
 	    (if (and (c-safe (backward-up-list 1) t)
 		     (> (point) placeholder))
 		(progn
@@ -1055,7 +1055,7 @@ This function does not do any hidden buffer changes."
 	    )))
 	 ;; CASE 9: we are inside a brace-list
 	 ((and (not (c-mode-is-new-awk-p))  ; Maybe this isn't needed (ACM, 2002/3/29)
-               (setq special-brace-list
+               (set special-brace-list
                      (or (and c-special-brace-lists
                               (save-excursion
                                 (goto-char containing-sexp)
@@ -1072,8 +1072,8 @@ This function does not do any hidden buffer changes."
 	    (skip-chars-backward " \t")
 	    (if (and (bolp)
 		     (assoc 'statement-cont
-			    (setq placeholder (c-guess-basic-syntax))))
-		(setq c-syntactic-context placeholder)
+			    (set placeholder (c-guess-basic-syntax))))
+		(set c-syntactic-context placeholder)
 	      (c-beginning-of-statement-1
 	       (c-safe-position (1- containing-sexp) paren-state))
 	      (c-forward-token-2 0)
@@ -1103,7 +1103,7 @@ This function does not do any hidden buffer changes."
 		   (= (point) containing-sexp)))
 	    (if (eq (point) (c-point 'boi))
 		(c-add-syntax 'brace-list-close (point))
-	      (setq lim (c-most-enclosing-brace c-state-cache (point)))
+	      (set lim (c-most-enclosing-brace c-state-cache (point)))
 	      (c-beginning-of-statement-1 lim)
 	      (c-add-stmt-syntax 'brace-list-close nil t t lim
 				 (c-whack-state-after (point) paren-state))))
@@ -1128,7 +1128,7 @@ This function does not do any hidden buffer changes."
 		(goto-char containing-sexp))
 	      (if (eq (point) (c-point 'boi))
 		  (c-add-syntax 'brace-list-intro (point))
-		(setq lim (c-most-enclosing-brace c-state-cache (point)))
+		(set lim (c-most-enclosing-brace c-state-cache (point)))
 		(c-beginning-of-statement-1 lim)
 		(c-add-stmt-syntax 'brace-list-intro nil t t lim
 				   (c-whack-state-after (point) paren-state))))
@@ -1153,7 +1153,7 @@ This function does not do any hidden buffer changes."
 	       (> (point)
 		  (save-excursion
 		    (c-beginning-of-statement-1 containing-sexp)
-		    (setq placeholder (point))))
+		    (set placeholder (point))))
 	       (/= placeholder containing-sexp))
 	  ;; This is shared with case 18.
 	  (c-guess-continued-construct indent-point
@@ -1164,16 +1164,16 @@ This function does not do any hidden buffer changes."
 	 ;; CASE 14: A case or default label
 	 ((looking-at c-label-kwds-regexp)
 	  (goto-char containing-sexp)
-	  (setq lim (c-most-enclosing-brace c-state-cache containing-sexp))
+	  (set lim (c-most-enclosing-brace c-state-cache containing-sexp))
 	  (c-backward-to-block-anchor lim)
 	  (c-add-stmt-syntax 'case-label nil t nil
 			     lim paren-state))
 	 ;; CASE 15: any other label
 	 ((looking-at c-label-key)
 	  (goto-char containing-sexp)
-	  (setq lim (c-most-enclosing-brace c-state-cache containing-sexp))
+	  (set lim (c-most-enclosing-brace c-state-cache containing-sexp))
 	  (save-excursion
-	    (setq tmpsymbol
+	    (set tmpsymbol
 		  (if (and (eq (c-beginning-of-statement-1 lim) 'up)
 			   (looking-at "switch\\>[^_]"))
 		      ;; If the surrounding statement is a switch then
@@ -1188,7 +1188,7 @@ This function does not do any hidden buffer changes."
 	 ;; the class
 	 ((eq char-after-ip ?})
 	  ;; From here on we have the next containing sexp in lim.
-	  (setq lim (c-most-enclosing-brace paren-state))
+	  (set lim (c-most-enclosing-brace paren-state))
 	  (goto-char containing-sexp)
 	    (cond
 	     ;; CASE 16E: Closing a statement block?  This catches
@@ -1201,10 +1201,10 @@ This function does not do any hidden buffer changes."
 				 lim paren-state))
 	     ;; CASE 16A: closing a lambda defun or an in-expression
 	     ;; block?  C.f. cases 4, 7B and 17E.
-	     ((setq placeholder (c-looking-at-inexpr-block
+	     ((set placeholder (c-looking-at-inexpr-block
 				 (c-safe-position containing-sexp paren-state)
 				 nil))
-	      (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+	      (set tmpsymbol (if (eq (car placeholder) 'inlambda)
 				  'inline-close
 				'block-close))
 	      (goto-char containing-sexp)
@@ -1220,7 +1220,7 @@ This function does not do any hidden buffer changes."
 		    (c-add-syntax (car placeholder)))))
 	     ;; CASE 16B: does this close an inline or a function in
 	     ;; a non-class declaration level block?
-	     ((setq placeholder (c-search-uplist-for-classkey paren-state))
+	     ((set placeholder (c-search-uplist-for-classkey paren-state))
 	      (c-backward-to-decl-anchor lim)
 	      (back-to-indentation)
 	      (if (save-excursion
@@ -1239,7 +1239,7 @@ This function does not do any hidden buffer changes."
 		   (save-excursion
 		     (and (not (c-looking-at-bos))
 			  (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-			  (setq placeholder (point)))))
+			  (set placeholder (point)))))
 	      (back-to-indentation)
 	      (if (/= (point) containing-sexp)
 		  (goto-char placeholder))
@@ -1255,7 +1255,7 @@ This function does not do any hidden buffer changes."
 	      ;; really fixes it better, but we do like this to keep
 	      ;; the indentation compatible with version 5.28 and
 	      ;; earlier.
-	      (while (and (/= (setq placeholder (point)) (c-point 'boi))
+	      (while (and (/= (set placeholder (point)) (c-point 'boi))
 			  (eq (c-beginning-of-statement-1 lim) 'label)))
 	      (goto-char placeholder)
 	      (if (looking-at c-label-kwds-regexp)
@@ -1287,9 +1287,9 @@ This function does not do any hidden buffer changes."
 					 containing-sexp)))
 		   (if (= (point) prev-point)
 		       (progn
-			 (setq step-type (or step-type last-step-type))
+			 (set step-type (or step-type last-step-type))
 			 nil)
-		     (setq step-type last-step-type)
+		     (set step-type last-step-type)
 		     (/= (point) (c-point 'boi)))))
 	  (cond
 	   ;; CASE 17B: continued statement
@@ -1301,7 +1301,7 @@ This function does not do any hidden buffer changes."
 	   ((progn
 	      (while (and (eq step-type 'label)
 			  (not (looking-at c-label-kwds-regexp)))
-		(setq step-type
+		(set step-type
 		      (c-beginning-of-statement-1 containing-sexp)))
 	      (eq step-type 'label))
 	    (c-add-stmt-syntax (if (eq char-after-ip ?{)
@@ -1311,7 +1311,7 @@ This function does not do any hidden buffer changes."
 	   ;; CASE 17D: any old statement
 	   ((progn
 	      (while (eq step-type 'label)
-		(setq step-type
+		(set step-type
 		      (c-beginning-of-statement-1 containing-sexp)))
 	      (eq step-type 'previous))
 	    (c-add-stmt-syntax 'statement nil t nil
@@ -1323,7 +1323,7 @@ This function does not do any hidden buffer changes."
 	      ;; The following tests are all based on containing-sexp.
 	      (goto-char containing-sexp)
 	      ;; From here on we have the next containing sexp in lim.
-	      (setq lim (c-most-enclosing-brace paren-state containing-sexp))
+	      (set lim (c-most-enclosing-brace paren-state containing-sexp))
 	      (c-after-conditional))
 	    (c-backward-to-block-anchor lim)
 	    (c-add-stmt-syntax 'statement-block-intro nil t nil
@@ -1332,10 +1332,10 @@ This function does not do any hidden buffer changes."
 		(c-add-syntax 'block-open)))
 	   ;; CASE 17E: first statement in an in-expression block.
 	   ;; C.f. cases 4, 7B and 16A.
-	   ((setq placeholder (c-looking-at-inexpr-block
+	   ((set placeholder (c-looking-at-inexpr-block
 			       (c-safe-position containing-sexp paren-state)
 			       nil))
-	    (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+	    (set tmpsymbol (if (eq (car placeholder) 'inlambda)
 				'defun-block-intro
 			      'statement-block-intro))
 	    (back-to-indentation)
@@ -1370,7 +1370,7 @@ This function does not do any hidden buffer changes."
 	   ((save-excursion
 	      (and (not (c-looking-at-bos))
 		   (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-		   (setq placeholder (point))))
+		   (set placeholder (point))))
 	    (back-to-indentation)
 	    (if (/= (point) containing-sexp)
 		(goto-char placeholder))
@@ -1383,7 +1383,7 @@ This function does not do any hidden buffer changes."
 	    ;; boi.  The default handling in c-add-stmt-syntax is
 	    ;; really fixes it better, but we do like this to keep the
 	    ;; indentation compatible with version 5.28 and earlier.
-	    (while (and (/= (setq placeholder (point)) (c-point 'boi))
+	    (while (and (/= (set placeholder (point)) (c-point 'boi))
 			(eq (c-beginning-of-statement-1 lim) 'label)))
 	    (goto-char placeholder)
 	    (if (looking-at c-label-kwds-regexp)
@@ -1414,10 +1414,10 @@ This function does not do any hidden buffer changes."
 	  (while (and p
 		      (if (integerp (car-safe (cdr-safe (car p))))
 			  (progn
-			    (setq syntactic-relpos (car (cdr (car p))))
+			    (set syntactic-relpos (car (cdr (car p))))
 			    nil)
 			t))
-	    (setq p (cdr p))))
+	    (set p (cdr p))))
 
 	;; Start of or a continuation of a preprocessor directive?
 	(if (and macro-start
@@ -1440,7 +1440,7 @@ This function does not do any hidden buffer changes."
 		  ;; in the expression.  That means the arglist
 		  ;; elements, if they are anchored inside the cpp
 		  ;; expression.
-		  (setq c-syntactic-context nil)
+		  (set c-syntactic-context nil)
 		  (c-add-syntax 'cpp-macro-cont macro-start))
 	      (when (and (eq macro-start syntactic-relpos)
 			 (not (assq 'cpp-define-intro c-syntactic-context))
@@ -1497,9 +1497,9 @@ This function does not do any hidden buffer changes."
 		    (let ((enclosing (match-string 1)))
 		      (cond
 		       ((string-equal enclosing "extern")
-			(setq inenclosing-p 'extern))
+			(set inenclosing-p 'extern))
 		       ((string-equal enclosing "namespace")
-			(setq inenclosing-p 'namespace))
+			(set inenclosing-p 'namespace))
 		       )))))
 
 	    ;; Init some position variables:
@@ -1523,22 +1523,22 @@ This function does not do any hidden buffer changes."
 	    ;; opposed to c-state-cache.
 	    (if c-state-cache
 		(progn
-		  (setq containing-sexp (car paren-state)
+		  (set containing-sexp (car paren-state)
 			paren-state (cdr paren-state))
 		  (if (consp containing-sexp)
 		      (progn
-			(setq lim (cdr containing-sexp))
+			(set lim (cdr containing-sexp))
 			(if (cdr c-state-cache)
 			    ;; Ignore balanced paren.  The next entry
 			    ;; can't be another one.
-			    (setq containing-sexp (car (cdr c-state-cache))
+			    (set containing-sexp (car (cdr c-state-cache))
 				  paren-state (cdr paren-state))
 			  ;; If there is no surrounding open paren then
 			  ;; put the last balanced pair back on paren-state.
-			  (setq paren-state (cons containing-sexp paren-state)
+			  (set paren-state (cons containing-sexp paren-state)
 				containing-sexp nil)))
-		    (setq lim (1+ containing-sexp))))
-	      (setq lim (point-min)))
+		    (set lim (1+ containing-sexp))))
+	      (set lim (point-min)))
 
 	    ;; If we're in a parenthesis list then ',' delimits the
 	    ;; "statements" rather than being an operator (with the
@@ -1547,19 +1547,19 @@ This function does not do any hidden buffer changes."
 	    ;; arglists.
 	    (when (and containing-sexp
 		       (eq (char-after containing-sexp) ?\())
-	      (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
+	      (set c-stmt-delim-chars c-stmt-delim-chars-with-comma))
 
 	    ;; cache char before and after indent point, and move point to
 	    ;; the most likely position to perform the majority of tests
 	    (goto-char indent-point)
 	    (c-backward-syntactic-ws lim)
-	    (setq char-before-ip (char-before))
+	    (set char-before-ip (char-before))
 	    (goto-char indent-point)
 	    (skip-chars-forward " \t")
-	    (setq char-after-ip (char-after))
+	    (set char-after-ip (char-after))
 
 	    ;; are we in a literal?
-	    (setq literal (c-in-literal lim))
+	    (set literal (c-in-literal lim))
 
 	    ;; now figure out syntactic qualities of the current line
 	    (cond
@@ -1572,10 +1572,10 @@ This function does not do any hidden buffer changes."
 	     ;; CASE 3: in a cpp preprocessor macro continuation.
 	     ((and (save-excursion
 		     (when (c-beginning-of-macro)
-		       (setq macro-start (point))))
+		       (set macro-start (point))))
 		   (/= macro-start (c-point 'boi))
 		   (progn
-		     (setq tmpsymbol 'cpp-macro-cont)
+		     (set tmpsymbol 'cpp-macro-cont)
 		     (or (not c-syntactic-indentation-in-macros)
 			 (save-excursion
 			   (goto-char macro-start)
@@ -1587,13 +1587,13 @@ This function does not do any hidden buffer changes."
 			   ;; or anywhere in a non-#define directive.
 			   (if (c-forward-to-cpp-define-body)
 			       (let ((indent-boi (c-point 'boi indent-point)))
-				 (setq in-macro-expr (> (point) indent-boi)
+				 (set in-macro-expr (> (point) indent-boi)
 				       tmpsymbol 'cpp-define-intro)
 				 (= (point) indent-boi))
-			     (setq in-macro-expr t)
+			     (set in-macro-expr t)
 			     nil)))))
 	      (c-add-syntax tmpsymbol macro-start)
-	      (setq macro-start nil))
+	      (set macro-start nil))
 	     ;; CASE 11: an else clause?
 	     ((looking-at "else\\>[^_]")
 	      (c-beginning-of-statement-1 containing-sexp)
@@ -1603,7 +1603,7 @@ This function does not do any hidden buffer changes."
 		   (save-excursion
 		     (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
 				'beginning)
-		       (setq placeholder (point)))))
+		       (set placeholder (point)))))
 	      (goto-char placeholder)
 	      (c-add-stmt-syntax 'do-while-closure t containing-sexp paren-state))
 	     ;; CASE 13: A catch or finally clause?  This case is simpler
@@ -1625,7 +1625,7 @@ This function does not do any hidden buffer changes."
 			      (c-safe (c-backward-sexp) t)
 			    t))
 		     (looking-at "\\(try\\|catch\\)\\>[^_]")
-		     (setq placeholder (point))))
+		     (set placeholder (point))))
 	      (goto-char placeholder)
 	      (c-add-stmt-syntax 'catch-clause t containing-sexp paren-state))
 	     ;; CASE 18: A substatement we can recognize by keyword.
@@ -1639,24 +1639,24 @@ This function does not do any hidden buffer changes."
 			(progn
 			  ;; Ought to cache the result from the
 			  ;; c-beginning-of-statement-1 calls here.
-			  (setq placeholder (point))
-			  (while (eq (setq step-type
+			  (set placeholder (point))
+			  (while (eq (set step-type
 					   (c-beginning-of-statement-1 lim))
 				     'label))
 			  (if (eq step-type 'previous)
 			      (goto-char placeholder)
-			    (setq placeholder (point))
+			    (set placeholder (point))
 			    (if (and (eq step-type 'same)
 				     (not (looking-at c-opt-block-stmt-key)))
 				;; Step up to the containing statement if we
 				;; stayed in the same one.
 				(let (step)
 				  (while (eq
-					  (setq step
+					  (set step
 						(c-beginning-of-statement-1 lim))
 					  'label))
 				  (if (eq step 'up)
-				      (setq placeholder (point))
+				      (set placeholder (point))
 				    ;; There was no containing statement afterall.
 				    (goto-char placeholder)))))
 			  placeholder))
@@ -1697,19 +1697,19 @@ This function does not do any hidden buffer changes."
 	     ((and (or c-opt-inexpr-class-key
 		       c-opt-inexpr-block-key
 		       c-opt-lambda-key)
-		   (setq placeholder (c-looking-at-inexpr-block
+		   (set placeholder (c-looking-at-inexpr-block
 				      (c-safe-position containing-sexp paren-state)
 				      containing-sexp)))
-	      (setq tmpsymbol (assq (car placeholder)
+	      (set tmpsymbol (assq (car placeholder)
 				    '((inexpr-class . class-open)
 				      (inexpr-statement . block-open))))
 	      (if tmpsymbol
 		  ;; It's a statement block or an anonymous class.
-		  (setq tmpsymbol (cdr tmpsymbol))
+		  (set tmpsymbol (cdr tmpsymbol))
 		;; It's a Pike lambda.  Check whether we are between the
 		;; lambda keyword and the argument list or at the defun
 		;; opener.
-		(setq tmpsymbol (if (eq char-after-ip ?{)
+		(set tmpsymbol (if (eq char-after-ip ?{)
 				    'inline-open
 				  'lambda-intro-cont)))
 	      (goto-char (cdr placeholder))
@@ -1724,7 +1724,7 @@ This function does not do any hidden buffer changes."
 	      (cond
 	       ;; CASE 5A: we are looking at a defun, brace list, class,
 	       ;; or inline-inclass method opening brace
-	       ((setq special-brace-list
+	       ((set special-brace-list
 		      (or (and c-special-brace-lists
 			       (c-looking-at-special-brace-list))
 			  (eq char-after-ip ?{)))
@@ -1735,16 +1735,16 @@ This function does not do any hidden buffer changes."
 		    (skip-chars-forward " \t")
 		    (and (c-safe (progn (c-backward-sexp 2) t))
 			 (looking-at c-other-decl-block-key)
-			 (setq keyword (match-string 1)
+			 (set keyword (match-string 1)
 			       placeholder (point))
 			 (or (and (string-equal keyword "namespace")
-				  (setq tmpsymbol 'namespace-open))
+				  (set tmpsymbol 'namespace-open))
 			     (and (string-equal keyword "extern")
 				  (progn
 				    (c-forward-sexp 1)
 				    (c-forward-syntactic-ws)
 				    (eq (char-after) ?\"))
-				  (setq tmpsymbol 'extern-lang-open)))
+				  (set tmpsymbol 'extern-lang-open)))
 			 ))
 		  (goto-char placeholder)
 		  (c-add-syntax tmpsymbol (c-point 'boi)))
@@ -1754,7 +1754,7 @@ This function does not do any hidden buffer changes."
 		    (skip-chars-forward " \t{")
 		    (let ((decl (c-search-uplist-for-classkey (c-parse-state))))
 		      (and decl
-			   (setq placeholder (aref decl 0)))
+			   (set placeholder (aref decl 0)))
 		      ))
 		  (c-add-syntax 'class-open placeholder))
 		 ;; CASE 5A.3: brace list open
@@ -1763,17 +1763,17 @@ This function does not do any hidden buffer changes."
 		    (if (looking-at "typedef\\>[^_]")
 			(progn (c-forward-sexp 1)
 			       (c-forward-syntactic-ws indent-point)))
-		    (setq placeholder (c-point 'boi))
+		    (set placeholder (c-point 'boi))
 		    (or (consp special-brace-list)
 			(and (or (save-excursion
 				   (goto-char indent-point)
-				   (setq tmpsymbol nil)
+				   (set tmpsymbol nil)
 				   (while (and (> (point) placeholder)
 					       (= (c-backward-token-1 1 t) 0)
 					       (/= (char-after) ?=))
 				     (if (and (not tmpsymbol)
 					      (looking-at "new\\>[^_]"))
-					 (setq tmpsymbol 'topmost-intro-cont)))
+					 (set tmpsymbol 'topmost-intro-cont)))
 				   (eq (char-after) ?=))
 				 (looking-at "enum\\>[^_]"))
 			     (save-excursion
@@ -1827,12 +1827,12 @@ This function does not do any hidden buffer changes."
 			     (c-backward-syntactic-ws lim)))
 		  (if (eq (char-before) ?\))
 		      (c-backward-sexp 1))
-		  (setq placeholder (point))
+		  (set placeholder (point))
 		  (save-excursion
 		    (and (c-safe (c-backward-sexp 1) t)
 			 (looking-at "throw[^_]")
 			 (c-safe (c-backward-sexp 1) t)
-			 (setq placeholder (point))))
+			 (set placeholder (point))))
 		  (goto-char placeholder)
 		  (c-add-syntax 'member-init-intro (c-point 'boi))
 		  ;; we don't need to add any class offset since this
@@ -1886,13 +1886,13 @@ This function does not do any hidden buffer changes."
 			   (save-excursion
 			     (while (not done)
 			       (cond ((looking-at c-opt-decl-spec-key)
-				      (setq injava-inher (cons cont (point))
+				      (set injava-inher (cons cont (point))
 					    done t))
 				     ((or (not (c-safe (c-forward-sexp -1) t))
 					  (<= (point) fence))
-				      (setq done t))
+				      (set done t))
 				     )
-			       (setq cont t)))
+			       (set cont t)))
 			   injava-inher)
 			 (not (c-crosses-statement-barrier-p (cdr injava-inher)
 							     (point)))
@@ -1916,7 +1916,7 @@ This function does not do any hidden buffer changes."
 		       c-access-key
 		       (looking-at c-access-key))
 		  (c-add-syntax 'access-label (c-point 'bonl))
-		  (setq placeholder (c-add-class-syntax 'inclass inclass-p
+		  (set placeholder (c-add-class-syntax 'inclass inclass-p
 							paren-state)))
 		 ;;(nconc syntax (list (cons 'access-label placeholder))))
 		 ;; KDE Hack End.
@@ -1963,7 +1963,7 @@ This function does not do any hidden buffer changes."
 		 ;; CASE 5D.1: hanging member init colon, but watch out
 		 ;; for bogus matches on access specifiers inside classes.
 		 ((and (save-excursion
-			 (setq placeholder (point))
+			 (set placeholder (point))
 			 (c-backward-token-1 1 t lim)
 			 (and (eq (char-after) ?:)
 			      (not (eq (char-before) ?:))))
@@ -1999,7 +1999,7 @@ This function does not do any hidden buffer changes."
 			 (save-restriction
 			   (c-with-syntax-table c++-template-syntax-table
 			     (goto-char indent-point)
-			     (setq placeholder (c-up-list-backward (point)))
+			     (set placeholder (c-up-list-backward (point)))
 			     (and placeholder
 				  (eq (char-after placeholder) ?<))))))
 		  ;; we can probably indent it just like an arglist-cont
@@ -2010,7 +2010,7 @@ This function does not do any hidden buffer changes."
 		 ((and (c-major-mode-is 'c++-mode)
 		       (save-excursion
 			 (c-beginning-of-statement-1 lim)
-			 (setq placeholder (point))
+			 (set placeholder (point))
 			 (if (looking-at "static\\>[^_]")
 			     (c-forward-token-1 1 nil indent-point))
 			 (and (looking-at c-class-key)
@@ -2044,14 +2044,14 @@ This function does not do any hidden buffer changes."
 	       ((and inclass-p
 		     c-opt-access-key
 		     (looking-at c-opt-access-key))
-		(setq placeholder (c-add-class-syntax 'inclass inclass-p
+		(set placeholder (c-add-class-syntax 'inclass inclass-p
 						      paren-state))
 		;; Append access-label with the same anchor point as inclass gets.
 		(nconc syntax (list (cons 'access-label placeholder))))
 	       ;; CASE 5F: extern-lang-close or namespace-close?
 	       ((and inenclosing-p
 		     (eq char-after-ip ?}))
-		(setq tmpsymbol (if (eq inenclosing-p 'extern)
+		(set tmpsymbol (if (eq inenclosing-p 'extern)
 				    'extern-lang-close
 				  'namespace-close))
 		(c-add-syntax tmpsymbol (aref inclass-p 0)))
@@ -2071,7 +2071,7 @@ This function does not do any hidden buffer changes."
 	       ((and c-recognize-knr-p
 		     (not (eq char-before-ip ?}))
 		     (save-excursion
-		       (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
+		       (set placeholder (cdr (c-beginning-of-decl-1 lim)))
 		       (and placeholder
 			    ;; Do an extra check to avoid tripping up on
 			    ;; statements that occur in invalid contexts
@@ -2099,7 +2099,7 @@ This function does not do any hidden buffer changes."
 			       ;; Speed up the backward search a bit.
 			       (goto-char (car (car paren-state))))
 			   (c-beginning-of-decl-1 containing-sexp)
-			   (setq placeholder (point))
+			   (set placeholder (point))
 			   (if (= start (point))
 			       ;; The '}' is unbalanced.
 			       nil
@@ -2150,7 +2150,7 @@ This function does not do any hidden buffer changes."
 			     macro-start
 			     (/= macro-start (c-point 'boi indent-point)))
 		    (c-add-syntax 'cpp-define-intro)
-		    (setq macro-start nil))
+		    (set macro-start nil))
 		  ))
 	       ;; CASE 5K: we are at an ObjC method definition
 	       ;; continuation line.
@@ -2193,23 +2193,23 @@ This function does not do any hidden buffer changes."
 	       ;; CASE 7A: we are looking at the arglist closing paren
 	       ((memq char-after-ip '(?\) ?\]))
 		(goto-char containing-sexp)
-		(setq placeholder (c-point 'boi))
+		(set placeholder (c-point 'boi))
 		(when (and (c-safe (backward-up-list 1) t)
 			   (> (point) placeholder))
 		  (forward-char)
 		  (skip-chars-forward " \t")
-		  (setq placeholder (point)))
+		  (set placeholder (point)))
 		(c-add-syntax 'arglist-close placeholder))
 	       ;; CASE 7B: Looking at the opening brace of an
 	       ;; in-expression block or brace list.  C.f. cases 4, 16A
 	       ;; and 17E.
 	       ((and (eq char-after-ip ?{)
 		     (progn
-		       (setq placeholder (c-inside-bracelist-p (point)
+		       (set placeholder (c-inside-bracelist-p (point)
 							       c-state-cache))
 		       (if placeholder
-			   (setq tmpsymbol '(brace-list-open . inexpr-class))
-			 (setq tmpsymbol '(block-open . inexpr-statement)
+			   (set tmpsymbol '(brace-list-open . inexpr-class))
+			 (set tmpsymbol '(block-open . inexpr-statement)
 			       placeholder
 			       (cdr-safe (c-looking-at-inexpr-block
 					  (c-safe-position containing-sexp
@@ -2231,12 +2231,12 @@ This function does not do any hidden buffer changes."
 	       ;; looking at a close paren or bracket.
 	       ((memq char-before-ip '(?\( ?\[))
 		(goto-char containing-sexp)
-		(setq placeholder (c-point 'boi))
+		(set placeholder (c-point 'boi))
 		(when (and (c-safe (backward-up-list 1) t)
 			   (> (point) placeholder))
 		  (forward-char)
 		  (skip-chars-forward " \t")
-		  (setq placeholder (point)))
+		  (set placeholder (point)))
 		(c-add-syntax 'arglist-intro placeholder))
 	       ;; CASE 7D: we are inside a conditional test clause. treat
 	       ;; these things as statements
@@ -2272,12 +2272,12 @@ This function does not do any hidden buffer changes."
 		  (and (not (eolp))
 		       (not (looking-at "\\\\$"))))
 		(goto-char containing-sexp)
-		(setq placeholder (c-point 'boi))
+		(set placeholder (c-point 'boi))
 		(when (and (c-safe (backward-up-list 1) t)
 			   (> (point) placeholder))
 		  (forward-char)
 		  (skip-chars-forward " \t")
-		  (setq placeholder (point)))
+		  (set placeholder (point)))
 		(c-add-syntax 'arglist-cont-nonempty placeholder))
 	       ;; CASE 7G: we are looking at just a normal arglist
 	       ;; continuation line
@@ -2306,7 +2306,7 @@ This function does not do any hidden buffer changes."
 		(c-add-syntax 'inher-cont (point))
 		)))
 	     ;; CASE 9: we are inside a brace-list
-	     ((setq special-brace-list
+	     ((set special-brace-list
 		    (or (and c-special-brace-lists
 			     (save-excursion
 			       (goto-char containing-sexp)
@@ -2323,8 +2323,8 @@ This function does not do any hidden buffer changes."
 		(skip-chars-backward " \t")
 		(if (and (bolp)
 			 (assoc 'statement-cont
-				(setq placeholder (c-guess-basic-syntax))))
-		    (setq syntax placeholder)
+				(set placeholder (c-guess-basic-syntax))))
+		    (set syntax placeholder)
 		  (c-beginning-of-statement-1
 		   (c-safe-position (1- containing-sexp) paren-state))
 		  (c-forward-token-1 0)
@@ -2353,7 +2353,7 @@ This function does not do any hidden buffer changes."
 		       (= (point) containing-sexp)))
 		(if (eq (point) (c-point 'boi))
 		    (c-add-syntax 'brace-list-close (point))
-		  (setq lim (c-most-enclosing-brace c-state-cache (point)))
+		  (set lim (c-most-enclosing-brace c-state-cache (point)))
 		  (c-beginning-of-statement-1 lim)
 		  (c-add-stmt-syntax 'brace-list-close t lim
 				     (c-whack-state-after (point) paren-state)
@@ -2379,7 +2379,7 @@ This function does not do any hidden buffer changes."
 		    (goto-char containing-sexp))
 		  (if (eq (point) (c-point 'boi))
 		      (c-add-syntax 'brace-list-intro (point))
-		    (setq lim (c-most-enclosing-brace c-state-cache (point)))
+		    (set lim (c-most-enclosing-brace c-state-cache (point)))
 		    (c-beginning-of-statement-1 lim)
 		    (c-add-stmt-syntax 'brace-list-intro t lim
 				       (c-whack-state-after (point) paren-state)
@@ -2403,7 +2403,7 @@ This function does not do any hidden buffer changes."
 		   (> (point)
 		      (save-excursion
 			(c-beginning-of-statement-1 containing-sexp)
-			(setq placeholder (point))))
+			(set placeholder (point))))
 		   (/= placeholder containing-sexp))
 	      ;; This is shared with case 18.
 	      (c-guess-continued-construct indent-point
@@ -2414,15 +2414,15 @@ This function does not do any hidden buffer changes."
 	     ;; CASE 14: A case or default label
 	     ((looking-at c-label-kwds-regexp)
 	      (goto-char containing-sexp)
-	      (setq lim (c-most-enclosing-brace c-state-cache containing-sexp))
+	      (set lim (c-most-enclosing-brace c-state-cache containing-sexp))
 	      (c-backward-to-block-anchor lim)
 	      (c-add-stmt-syntax 'case-label t lim paren-state))
 	     ;; CASE 15: any other label
 	     ((looking-at c-label-key)
 	      (goto-char containing-sexp)
-	      (setq lim (c-most-enclosing-brace c-state-cache containing-sexp))
+	      (set lim (c-most-enclosing-brace c-state-cache containing-sexp))
 	      (save-excursion
-		(setq tmpsymbol
+		(set tmpsymbol
 		      (if (and (eq (c-beginning-of-statement-1 lim) 'up)
 			       (looking-at "switch\\>[^_]"))
 			  ;; If the surrounding statement is a switch then
@@ -2436,7 +2436,7 @@ This function does not do any hidden buffer changes."
 	     ;; the class
 	     ((eq char-after-ip ?})
 	      ;; From here on we have the next containing sexp in lim.
-	      (setq lim (c-most-enclosing-brace paren-state))
+	      (set lim (c-most-enclosing-brace paren-state))
 	      (goto-char containing-sexp)
 	      (cond
 	       ;; CASE 16E: Closing a statement block?  This catches
@@ -2448,10 +2448,10 @@ This function does not do any hidden buffer changes."
 		(c-add-stmt-syntax 'block-close t lim paren-state))
 	       ;; CASE 16A: closing a lambda defun or an in-expression
 	       ;; block?  C.f. cases 4, 7B and 17E.
-	       ((setq placeholder (c-looking-at-inexpr-block
+	       ((set placeholder (c-looking-at-inexpr-block
 				   (c-safe-position containing-sexp paren-state)
 				   nil))
-		(setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+		(set tmpsymbol (if (eq (car placeholder) 'inlambda)
 				    'inline-close
 				  'block-close))
 		(goto-char containing-sexp)
@@ -2467,7 +2467,7 @@ This function does not do any hidden buffer changes."
 		      (c-add-syntax (car placeholder)))))
 	       ;; CASE 16B: does this close an inline or a function in
 	       ;; an extern block or namespace?
-	       ((setq placeholder (c-search-uplist-for-classkey paren-state))
+	       ((set placeholder (c-search-uplist-for-classkey paren-state))
 		(c-backward-to-decl-anchor lim)
 		(back-to-indentation)
 		(if (save-excursion
@@ -2486,7 +2486,7 @@ This function does not do any hidden buffer changes."
 		     (save-excursion
 		       (and (not (c-looking-at-bos))
 			    (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-			    (setq placeholder (point)))))
+			    (set placeholder (point)))))
 		(back-to-indentation)
 		(if (/= (point) containing-sexp)
 		    (goto-char placeholder))
@@ -2501,7 +2501,7 @@ This function does not do any hidden buffer changes."
 		;; really fixes it better, but we do like this to keep
 		;; the indentation compatible with version 5.28 and
 		;; earlier.
-		(while (and (/= (setq placeholder (point)) (c-point 'boi))
+		(while (and (/= (set placeholder (point)) (c-point 'boi))
 			    (eq (c-beginning-of-statement-1 lim) 'label)))
 		(goto-char placeholder)
 		(if (looking-at c-label-kwds-regexp)
@@ -2532,9 +2532,9 @@ This function does not do any hidden buffer changes."
 					     containing-sexp)))
 		       (if (= (point) prev-point)
 			   (progn
-			     (setq step-type (or step-type last-step-type))
+			     (set step-type (or step-type last-step-type))
 			     nil)
-			 (setq step-type last-step-type)
+			 (set step-type last-step-type)
 			 (/= (point) (c-point 'boi)))))
 	      (cond
 	       ;; CASE 17B: continued statement
@@ -2546,7 +2546,7 @@ This function does not do any hidden buffer changes."
 	       ((progn
 		  (while (and (eq step-type 'label)
 			      (not (looking-at c-label-kwds-regexp)))
-		    (setq step-type
+		    (set step-type
 			  (c-beginning-of-statement-1 containing-sexp)))
 		  (eq step-type 'label))
 		(c-add-stmt-syntax (if (eq char-after-ip ?{)
@@ -2556,7 +2556,7 @@ This function does not do any hidden buffer changes."
 	       ;; CASE 17D: any old statement
 	       ((progn
 		  (while (eq step-type 'label)
-		    (setq step-type
+		    (set step-type
 			  (c-beginning-of-statement-1 containing-sexp)))
 		  (eq step-type 'previous))
 		(c-add-stmt-syntax 'statement t containing-sexp paren-state)
@@ -2567,7 +2567,7 @@ This function does not do any hidden buffer changes."
 		  ;; The following tests are all based on containing-sexp.
 		  (goto-char containing-sexp)
 		  ;; From here on we have the next containing sexp in lim.
-		  (setq lim (c-most-enclosing-brace paren-state containing-sexp))
+		  (set lim (c-most-enclosing-brace paren-state containing-sexp))
 		  (c-after-conditional))
 		(c-backward-to-block-anchor lim)
 		(c-add-stmt-syntax 'statement-block-intro t lim paren-state)
@@ -2575,10 +2575,10 @@ This function does not do any hidden buffer changes."
 		    (c-add-syntax 'block-open)))
 	       ;; CASE 17E: first statement in an in-expression block.
 	       ;; C.f. cases 4, 7B and 16A.
-	       ((setq placeholder (c-looking-at-inexpr-block
+	       ((set placeholder (c-looking-at-inexpr-block
 				   (c-safe-position containing-sexp paren-state)
 				   nil))
-		(setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+		(set tmpsymbol (if (eq (car placeholder) 'inlambda)
 				    'defun-block-intro
 				  'statement-block-intro))
 		(back-to-indentation)
@@ -2617,7 +2617,7 @@ This function does not do any hidden buffer changes."
 	       ((save-excursion
 		  (and (not (c-looking-at-bos))
 		       (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-		       (setq placeholder (point))))
+		       (set placeholder (point))))
 		(back-to-indentation)
 		(if (/= (point) containing-sexp)
 		    (goto-char placeholder))
@@ -2629,7 +2629,7 @@ This function does not do any hidden buffer changes."
 		;; boi.  The default handling in c-add-stmt-syntax is
 		;; really fixes it better, but we do like this to keep the
 		;; indentation compatible with version 5.28 and earlier.
-		(while (and (/= (setq placeholder (point)) (c-point 'boi))
+		(while (and (/= (set placeholder (point)) (c-point 'boi))
 			    (eq (c-beginning-of-statement-1 lim) 'label)))
 		(goto-char placeholder)
 		(if (looking-at c-label-kwds-regexp)
@@ -2672,7 +2672,7 @@ This function does not do any hidden buffer changes."
 		      ;; in the expression.  That means the arglist
 		      ;; elements, if they are anchored inside the cpp
 		      ;; expression.
-		      (setq syntax `((cpp-macro-cont . ,macro-start))))
+		      (set syntax `((cpp-macro-cont . ,macro-start))))
 		  (when (and (eq macro-start syntactic-relpos)
 			     (not (assq 'cpp-define-intro syntax))
 			     (save-excursion
@@ -2713,9 +2713,9 @@ This function does not do any hidden buffer changes."
 		  (let ((enclosing (match-string 1)))
 		    (cond
 		     ((string-equal enclosing "extern")
-		      (setq inenclosing-p 'extern))
+		      (set inenclosing-p 'extern))
 		     ((string-equal enclosing "namespace")
-		      (setq inenclosing-p 'namespace))
+		      (set inenclosing-p 'namespace))
 		     )))))
 	  ;; get the buffer position of the most nested opening brace,
 	  ;; if there is one, and it hasn't been narrowed out
@@ -2725,23 +2725,23 @@ This function does not do any hidden buffer changes."
 	    (skip-chars-backward " \t")
 	    (while (and state
 			(not containing-sexp))
-	      (setq containing-sexp (car state)
+	      (set containing-sexp (car state)
 		    state (cdr state))
 	      (if (consp containing-sexp)
 		  ;; if cdr == point, then containing sexp is the brace
 		  ;; that opens the sexp we close
 		  (if (= (cdr containing-sexp) (point))
-		      (setq containing-sexp (car containing-sexp))
+		      (set containing-sexp (car containing-sexp))
 		    ;; otherwise, ignore this element
-		    (setq containing-sexp nil))
+		    (set containing-sexp nil))
 		;; ignore the bufpos if its been narrowed out by the
 		;; containing class or does not contain the indent point
 		(if (or (<= containing-sexp (point-min))
 			(>= containing-sexp indent-point))
-		    (setq containing-sexp nil)))))
+		    (set containing-sexp nil)))))
 	  ;; (imenu "agulbra-c++-tab")
 	  ;; set the limit on the farthest back we need to search
-	  (setq lim (or containing-sexp
+	  (set lim (or containing-sexp
 			(if (consp (car fullstate))
 			    (cdr (car fullstate))
 			  nil)
@@ -2751,14 +2751,14 @@ This function does not do any hidden buffer changes."
 	  ;; the most likely position to perform the majority of tests
 	  (goto-char indent-point)
 	  (skip-chars-forward " \t")
-	  (setq char-after-ip (char-after))
+	  (set char-after-ip (char-after))
 	  (c-backward-syntactic-ws lim)
-	  (setq char-before-ip (char-before))
+	  (set char-before-ip (char-before))
 	  (goto-char indent-point)
 	  (skip-chars-forward " \t")
 
 	  ;; are we in a literal?
-	  (setq literal (c-in-literal lim))
+	  (set literal (c-in-literal lim))
 
 	  ;; now figure out syntactic qualities of the current line
 	  (cond
@@ -2772,22 +2772,22 @@ This function does not do any hidden buffer changes."
 	   ((and (eq literal 'pound)
 		 (/= (save-excursion
 		       (c-beginning-of-macro lim)
-		       (setq placeholder (point)))
+		       (set placeholder (point)))
 		     (c-point 'boi)))
 	    (c-add-syntax 'cpp-macro-cont placeholder))
 	   ;; CASE 4: In-expression statement.
 	   ((and (or c-inexpr-class-key c-inexpr-block-key c-lambda-key)
-		 (setq placeholder (c-looking-at-inexpr-block)))
-	    (setq tmpsymbol (assq (car placeholder)
+		 (set placeholder (c-looking-at-inexpr-block)))
+	    (set tmpsymbol (assq (car placeholder)
 				  '((inexpr-class . class-open)
 				    (inexpr-statement . block-open))))
 	    (if tmpsymbol
 		;; It's a statement block or an anonymous class.
-		(setq tmpsymbol (cdr tmpsymbol))
+		(set tmpsymbol (cdr tmpsymbol))
 	      ;; It's a Pike lambda.  Check whether we are between the
 	      ;; lambda keyword and the argument list or at the defun
 	      ;; opener.
-	      (setq tmpsymbol (if (eq char-after-ip ?{)
+	      (set tmpsymbol (if (eq char-after-ip ?{)
 				  'inline-open
 				'lambda-intro-cont)))
 	    (goto-char (cdr placeholder))
@@ -2800,7 +2800,7 @@ This function does not do any hidden buffer changes."
 	    (cond
 	     ;; CASE 5A: we are looking at a defun, brace list, class,
 	     ;; or inline-inclass method opening brace
-	     ((setq special-brace-list
+	     ((set special-brace-list
 		    (or (and c-special-brace-lists
 			     (c-looking-at-special-brace-list))
 			(eq char-after-ip ?{)))
@@ -2811,16 +2811,16 @@ This function does not do any hidden buffer changes."
 		  (skip-chars-forward " \t")
 		  (and (c-safe (progn (c-backward-sexp 2) t))
 		       (looking-at (concat c-extra-toplevel-key "[^_]"))
-		       (setq keyword (match-string 1)
+		       (set keyword (match-string 1)
 			     placeholder (point))
 		       (or (and (string-equal keyword "namespace")
-				(setq tmpsymbol 'namespace-open))
+				(set tmpsymbol 'namespace-open))
 			   (and (string-equal keyword "extern")
 				(progn
 				  (c-forward-sexp 1)
 				  (c-forward-syntactic-ws)
 				  (eq (char-after) ?\"))
-				(setq tmpsymbol 'extern-lang-open)))
+				(set tmpsymbol 'extern-lang-open)))
 		       ))
 		(goto-char placeholder)
 		(c-add-syntax tmpsymbol (c-point 'boi)))
@@ -2837,7 +2837,7 @@ This function does not do any hidden buffer changes."
 			   (c-search-uplist-for-classkey (c-parse-state))
 			   )))
 		    (and decl
-			 (setq placeholder (aref decl 0)))
+			 (set placeholder (aref decl 0)))
 		    ))
 		(c-add-syntax 'class-open placeholder))
 	       ;; CASE 5A.3: brace list open
@@ -2849,17 +2849,17 @@ This function does not do any hidden buffer changes."
 		  (if (looking-at "typedef[^_]")
 		      (progn (c-forward-sexp 1)
 			     (c-forward-syntactic-ws indent-point)))
-		  (setq placeholder (c-point 'boi))
+		  (set placeholder (c-point 'boi))
 		  (or (consp special-brace-list)
 		      (and (or (save-excursion
 				 (goto-char indent-point)
-				 (setq tmpsymbol nil)
+				 (set tmpsymbol nil)
 				 (while (and (> (point) placeholder)
 					     (= (c-backward-token-1 1 t) 0)
 					     (/= (char-after) ?=))
 				   (if (and (not tmpsymbol)
 					    (looking-at "new\\>[^_]"))
-				       (setq tmpsymbol 'topmost-intro-cont)))
+				       (set tmpsymbol 'topmost-intro-cont)))
 				 (eq (char-after) ?=))
 			       (looking-at "enum[ \t\n]+"))
 			   (save-excursion
@@ -2913,12 +2913,12 @@ This function does not do any hidden buffer changes."
 			   (c-backward-syntactic-ws lim)))
 		(if (eq (char-before) ?\))
 		    (c-backward-sexp 1))
-		(setq placeholder (point))
+		(set placeholder (point))
 		(save-excursion
 		  (and (c-safe (c-backward-sexp 1) t)
 		       (looking-at "throw[^_]")
 		       (c-safe (c-backward-sexp 1) t)
-		       (setq placeholder (point))))
+		       (set placeholder (point))))
 		(goto-char placeholder)
 		(c-add-syntax 'member-init-intro (c-point 'boi))
 		;; we don't need to add any class offset since this
@@ -2970,13 +2970,13 @@ This function does not do any hidden buffer changes."
 			 (save-excursion
 			   (while (not done)
 			     (cond ((looking-at c-Java-special-key)
-				    (setq injava-inher (cons cont (point))
+				    (set injava-inher (cons cont (point))
 					  done t))
 				   ((or (not (c-safe (c-forward-sexp -1) t))
 					(<= (point) fence))
-				    (setq done t))
+				    (set done t))
 				   )
-			     (setq cont t)))
+			     (set cont t)))
 			 injava-inher)
 		       (not (c-crosses-statement-barrier-p (cdr injava-inher)
 							   (point)))
@@ -3038,7 +3038,7 @@ This function does not do any hidden buffer changes."
 	       ;; CASE 5D.1: hanging member init colon, but watch out
 	       ;; for bogus matches on access specifiers inside classes.
 	       ((and (save-excursion
-		       (setq plaaceholder (point))
+		       (set plaaceholder (point))
 		       (c-backward-token-1 1 t lim)
 		       (and (eq (char-after) ?:)
 			    (not (eq (char-before) ?:))))
@@ -3069,7 +3069,7 @@ This function does not do any hidden buffer changes."
 	       ;; CASE 5D.3: perhaps a multiple inheritance line?
 	       ((save-excursion
 		  (c-beginning-of-statement-1 lim)
-		  (setq placeholder (point))
+		  (set placeholder (point))
 		  (looking-at c-inher-key))
 		(goto-char placeholder)
 		(c-add-syntax 'inher-cont (c-point 'boi)))
@@ -3079,7 +3079,7 @@ This function does not do any hidden buffer changes."
 		  (skip-chars-backward "^<" lim)
 		  ;; not sure if this is the right test, but it should
 		  ;; be fast and mostly accurate.
-		  (setq placeholder (point))
+		  (set placeholder (point))
 		  (and (eq (char-before) ?<)
 		       (not (c-in-literal lim))))
 		;; we can probably indent it just like an arglist-cont
@@ -3106,7 +3106,7 @@ This function does not do any hidden buffer changes."
 	     ;; CASE 5F: extern-lang-close or namespace-close?
 	     ((and inenclosing-p
 		   (eq char-after-ip ?}))
-	      (setq tmpsymbol (if (eq inenclosing-p 'extern)
+	      (set tmpsymbol (if (eq inenclosing-p 'extern)
 				  'extern-lang-close
 				'namespace-close))
 	      (c-add-syntax tmpsymbol (aref inclass-p 0)))
@@ -3134,11 +3134,11 @@ This function does not do any hidden buffer changes."
 				  (point))))
 		     (save-excursion
 		       (c-backward-syntactic-ws limit)
-		       (setq placeholder (point))
+		       (set placeholder (point))
 		       (while (and (memq (char-before) '(?\; ?,))
 				   (> (point) limit))
 			 (beginning-of-line)
-			 (setq placeholder (point))
+			 (set placeholder (point))
 			 (c-backward-syntactic-ws limit))
 		       (and (eq (char-before) ?\))
 			    (or (not c-method-key)
@@ -3235,18 +3235,18 @@ This function does not do any hidden buffer changes."
 		       (not (eq char-before-ip ?,)))
 		   (memq char-after-ip '(?\) ?\])))
 	      (goto-char containing-sexp)
-	      (setq placeholder (c-point 'boi))
+	      (set placeholder (c-point 'boi))
 	      (when (and (c-safe (backward-up-list 1) t)
 			 (> (point) placeholder))
 		(forward-char)
 		(skip-chars-forward " \t")
-		(setq placeholder (point)))
+		(set placeholder (point)))
 	      (c-add-syntax 'arglist-close placeholder))
 	     ;; CASE 7B: Looking at the opening brace of an
 	     ;; in-expression block or brace list.
 	     ((eq char-after-ip ?{)
 	      (goto-char indent-point)
-	      (setq placeholder (c-point 'boi))
+	      (set placeholder (c-point 'boi))
 	      (goto-char containing-sexp)
 	      (if (c-inside-bracelist-p placeholder
 					(cons containing-sexp state))
@@ -3260,12 +3260,12 @@ This function does not do any hidden buffer changes."
 	     ;; looking at a close paren or bracket.
 	     ((memq char-before-ip '(?\( ?\[))
 	      (goto-char containing-sexp)
-	      (setq placeholder (c-point 'boi))
+	      (set placeholder (c-point 'boi))
 	      (when (and (c-safe (backward-up-list 1) t)
 			 (> (point) placeholder))
 		(forward-char)
 		(skip-chars-forward " \t")
-		(setq placeholder (point)))
+		(set placeholder (point)))
 	      (c-add-syntax 'arglist-intro placeholder))
 	     ;; CASE 7D: we are inside a conditional test clause. treat
 	     ;; these things as statements
@@ -3301,12 +3301,12 @@ This function does not do any hidden buffer changes."
 		(skip-chars-forward " \t")
 		(not (eolp)))
 	      (goto-char containing-sexp)
-	      (setq placeholder (c-point 'boi))
+	      (set placeholder (c-point 'boi))
 	      (when (and (c-safe (backward-up-list 1) t)
 			 (> (point) placeholder))
 		(forward-char)
 		(skip-chars-forward " \t")
-		(setq placeholder (point)))
+		(set placeholder (point)))
 	      (c-add-syntax 'arglist-cont-nonempty placeholder))
 	     ;; CASE 7G: we are looking at just a normal arglist
 	     ;; continuation line
@@ -3337,7 +3337,7 @@ This function does not do any hidden buffer changes."
 	      (c-add-syntax 'inher-cont (point))
 	      )))
 	   ;; CASE 9: we are inside a brace-list
-	   ((setq special-brace-list
+	   ((set special-brace-list
 		  (or (and c-special-brace-lists
 			   (save-excursion
 			     (goto-char containing-sexp)
@@ -3354,8 +3354,8 @@ This function does not do any hidden buffer changes."
 	      (skip-chars-backward " \t")
 	      (if (and (bolp)
 		       (assoc 'statement-cont
-			      (setq placeholder (c-guess-basic-syntax))))
-		  (setq syntax placeholder)
+			      (set placeholder (c-guess-basic-syntax))))
+		  (set syntax placeholder)
 		(c-beginning-of-statement-1 lim)
 		(c-forward-token-1 0)
 		(if (looking-at "typedef\\>") (c-forward-token-1 1))
@@ -3422,7 +3422,7 @@ This function does not do any hidden buffer changes."
 		    (save-excursion
 		      (c-beginning-of-statement-1 containing-sexp)
 		      (c-forward-syntactic-ws)
-		      (setq placeholder (point))))
+		      (set placeholder (point))))
 		 (/= placeholder containing-sexp))
 	    (goto-char indent-point)
 	    (skip-chars-forward " \t")
@@ -3448,7 +3448,7 @@ This function does not do any hidden buffer changes."
 		    (c-add-syntax 'substatement-open (c-point 'boi))
 		  (c-add-syntax 'substatement (c-point 'boi))))
 	       ;; CASE 10B: open braces for class or brace-lists
-	       ((setq special-brace-list
+	       ((set special-brace-list
 		      (or (and c-special-brace-lists
 			       (c-looking-at-special-brace-list))
 			  (eq char-after-ip ?{)))
@@ -3459,7 +3459,7 @@ This function does not do any hidden buffer changes."
 		    (skip-chars-forward " \t{")
 		    (let ((decl (c-search-uplist-for-classkey (c-parse-state))))
 		      (and decl
-			   (setq placeholder (aref decl 0)))
+			   (set placeholder (aref decl 0)))
 		      ))
 		  (c-add-syntax 'class-open placeholder))
 		 ;; CASE 10B.2: brace-list-open
@@ -3539,7 +3539,7 @@ This function does not do any hidden buffer changes."
 	      (and (looking-at "while\\b[^_]")
 		   (save-excursion
 		     (c-backward-to-start-of-do containing-sexp)
-		     (setq placeholder (point))
+		     (set placeholder (point))
 		     (looking-at "do\\b[^_]"))
 		   ))
 	    (goto-char placeholder)
@@ -3559,7 +3559,7 @@ This function does not do any hidden buffer changes."
 		       (c-safe (c-backward-sexp) t)
 		     t)
 		   (looking-at "\\<\\(try\\|catch\\)\\>[^_]")
-		   (setq placeholder (c-point 'boi))))
+		   (set placeholder (c-point 'boi))))
 	    (c-add-syntax 'catch-clause placeholder))
 	   ;; CASE 14: A case or default label
 	   ((looking-at c-switch-label-key)
@@ -3589,8 +3589,8 @@ This function does not do any hidden buffer changes."
 	       ;; block?
 	       ((save-excursion
 		  (goto-char containing-sexp)
-		  (setq placeholder (c-looking-at-inexpr-block)))
-		(setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+		  (set placeholder (c-looking-at-inexpr-block)))
+		(set tmpsymbol (if (eq (car placeholder) 'inlambda)
 				    'inline-close
 				  'block-close))
 		(goto-char containing-sexp)
@@ -3606,7 +3606,7 @@ This function does not do any hidden buffer changes."
 	       ;; an extern block or namespace?
 	       ((progn
 		  (goto-char containing-sexp)
-		  (setq placeholder (c-search-uplist-for-classkey state)))
+		  (set placeholder (c-search-uplist-for-classkey state)))
 		(goto-char (aref placeholder 0))
 		(if (looking-at (concat c-extra-toplevel-key "[^_]"))
 		    (c-add-syntax 'defun-close relpos)
@@ -3646,7 +3646,7 @@ This function does not do any hidden buffer changes."
 	    (while (or (c-skip-case-statement-forward fullstate indent-point)
 		       (and (looking-at c-switch-label-key)
 			    (not inswitch-p)))
-	      (setq inswitch-p t))
+	      (set inswitch-p t))
 	    ;; we want to ignore non-case labels when skipping forward
 	    (while (and (looking-at c-label-key)
 			(goto-char (match-end 0)))
@@ -3659,11 +3659,11 @@ This function does not do any hidden buffer changes."
 		   (progn
 		     (goto-char indent-point)
 		     (c-beginning-of-statement-1 containing-sexp)
-		     (setq placeholder (point))
+		     (set placeholder (point))
 		     (beginning-of-line)
 		     (when (re-search-forward c-switch-label-key
 					      (max placeholder (c-point 'eol)) t)
-		       (setq placeholder (match-beginning 0)))))
+		       (set placeholder (match-beginning 0)))))
 	      (goto-char indent-point)
 	      (skip-chars-forward " \t")
 	      (if (eq (char-after) ?{)
@@ -3710,19 +3710,19 @@ This function does not do any hidden buffer changes."
 		    (progn
 		      (goto-char (match-end 0))
 		      (c-forward-syntactic-ws)))
-		(setq relpos (c-point 'boi))
+		(set relpos (c-point 'boi))
 		(while (and (not done)
 			    (<= safepos (point))
 			    (/= relpos (point)))
 		  (c-beginning-of-statement-1 safepos)
 		  (if (= relpos (c-point 'boi))
-		      (setq done t))
-		  (setq relpos (c-point 'boi)))
+		      (set done t))
+		  (set relpos (c-point 'boi)))
 		(c-add-syntax 'statement relpos)
 		(if (eq char-after-ip ?{)
 		    (c-add-syntax 'block-open))))
 	     ;; CASE 17E: first statement in an in-expression block
-	     ((setq placeholder
+	     ((set placeholder
 		    (save-excursion
 		      (goto-char containing-sexp)
 		      (c-looking-at-inexpr-block)))
@@ -3800,7 +3800,7 @@ This function does not do any hidden buffer changes."
 	   ((and (eq literal 'pound)
 		 (= (save-excursion
 		      (c-beginning-of-macro lim)
-		      (setq placeholder (point)))
+		      (set placeholder (point)))
 		    (c-point 'boi))
 		 (not (and (c-major-mode-is 'pike-mode)
 			   (eq (char-after (1+ placeholder)) ?\"))))
@@ -3814,10 +3814,10 @@ This function does not do any hidden buffer changes."
 (add-hook 'c++-mode-hook 'kde-c++-mode-hook)
 (add-hook 'c-mode-hook 'kde-c-mode-hook)
 ; always end a file with a newline
-(setq-default require-final-newline t)
+(set-default require-final-newline t)
 ; 'next-line won't be adding newlines
-(setq-default next-line-add-newlines nil)
-(setq compilation-error-regexp-systems-list '(gnu of comma 4bsd)
+(set-default next-line-add-newlines nil)
+(set compilation-error-regexp-systems-list '(gnu of comma 4bsd)
       compilation-ask-about-save nil)
 
 (provide 'kde-emacs-core)