Slow fontification in C mode buffers

Slow fontification in C mode buffers

[Eli Zaretskii]

Did anyone else notice that scrolling the first time through a very
large comment in C mode became extremely slow lately?  For example,
visit xdisp.c in "emacs -Q", type M-<, then hit C-v several times in
quick succession.  Then watch in disbelief how long it takes for Emacs
to scroll by these several screenfuls.  In my case (6.5 year old
hardware), I even see the "hourglass cursor" kick in, and the CPU
meter shows 100% utilization of one execution unit for about 5
seconds.

If you then type M-< and again hit C-v several times, scrolling will
be at its usual speed.  Scrolling outside of large comments is also
reasonably fast, even for the first time.

Therefore, my prime suspect is font-lock, which is triggered by the
need to display a portion of the buffer that was not fontified yet.
This suspicion is corroborated by the fact that jit-stealth font-lock
of xdisp.c causes extremely high peaks of CPU usage, and Emacs
response time becomes very sluggish.

Is there something in C Mode's arrangements for fontification,
specifically related to comments, that was changed lately and that can
explain this slowdown?

Slow fontification in C mode buffers

[Sujith]

Eli Zaretskii wrote:
> Did anyone else notice that scrolling the first time through a very
> large comment in C mode became extremely slow lately?  For example,
> visit xdisp.c in "emacs -Q", type M-<, then hit C-v several times in
> quick succession.  Then watch in disbelief how long it takes for Emacs
> to scroll by these several screenfuls.  In my case (6.5 year old
> hardware), I even see the "hourglass cursor" kick in, and the CPU
> meter shows 100% utilization of one execution unit for about 5
> seconds.
> 
> If you then type M-< and again hit C-v several times, scrolling will
> be at its usual speed.  Scrolling outside of large comments is also
> reasonably fast, even for the first time.
> 
> Therefore, my prime suspect is font-lock, which is triggered by the
> need to display a portion of the buffer that was not fontified yet.
> This suspicion is corroborated by the fact that jit-stealth font-lock
> of xdisp.c causes extremely high peaks of CPU usage, and Emacs
> response time becomes very sluggish.
> 
> Is there something in C Mode's arrangements for fontification,
> specifically related to comments, that was changed lately and that can
> explain this slowdown?

I can see this behavior on a low-spec machine - Intel Atom @ 1.66 GHz with
1GB RAM running GNU/Linux. C mode is really slow with maximum font-lock
decoration and hitting C-v a few times is enough for the screen to lock up,
while the CPU chugs away at full usage. After the buffer has been fully fontified,
scrolling is fast. My current workaround is to set font-lock-maximum-decoration
to 2.

I tried the pretests to see if things have changed, but 24.0.92 has pretty much
the same behavior.

Sujith

Re: Slow fontification in C mode buffers

[Eli Zaretskii]

> From: Sujith <m.sujith@gmail.com>
> Date: Sat, 3 Dec 2011 20:33:15 +0530
> Cc: emacs-devel@gnu.org,
>     Alan Mackenzie <acm@muc.de>
> 
> I can see this behavior on a low-spec machine - Intel Atom @ 1.66 GHz with
> 1GB RAM running GNU/Linux. C mode is really slow with maximum font-lock
> decoration and hitting C-v a few times is enough for the screen to lock up,
> while the CPU chugs away at full usage. After the buffer has been fully fontified,
> scrolling is fast. My current workaround is to set font-lock-maximum-decoration
> to 2.
> 
> I tried the pretests to see if things have changed, but 24.0.92 has pretty much
> the same behavior.

Thanks.

Do you see any significant difference in performance between when
point is inside of a very large comment, like at the beginning of
src/xdisp.c, and when point is in "normal" C code, with only
relatively short comments?

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hi, Eli.

On Sat, Dec 03, 2011 at 03:19:47PM +0200, Eli Zaretskii wrote:
> Did anyone else notice that scrolling the first time through a very
> large comment in C mode became extremely slow lately?  For example,
> visit xdisp.c in "emacs -Q", type M-<, then hit C-v several times in
> quick succession.  Then watch in disbelief how long it takes for Emacs
> to scroll by these several screenfuls.  In my case (6.5 year old
> hardware), I even see the "hourglass cursor" kick in, and the CPU
> meter shows 100% utilization of one execution unit for about 5
> seconds.

> If you then type M-< and again hit C-v several times, scrolling will
> be at its usual speed.  Scrolling outside of large comments is also
> reasonably fast, even for the first time.

> Therefore, my prime suspect is font-lock, which is triggered by the
> need to display a portion of the buffer that was not fontified yet.
> This suspicion is corroborated by the fact that jit-stealth font-lock
> of xdisp.c causes extremely high peaks of CPU usage, and Emacs
> response time becomes very sluggish.

> Is there something in C Mode's arrangements for fontification,
> specifically related to comments, that was changed lately and that can
> explain this slowdown?

By a happy coincidence, I've just tracked down another sluggishness (in
large array initialisations, reported by Peter Milliken on bug-cc-mode)
which looks to have exactly the same cause, namely
`c-font-lock-enclosing-decls' which fontifies the innards of a
struct/union/enum when jit-lock etc. starts in the middle of it.

I've got a solution, though it's not fully worked out yet.  Give me till
later on today, possibly tomorrow.

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Sujith]

Eli Zaretskii wrote:
> Do you see any significant difference in performance between when
> point is inside of a very large comment, like at the beginning of
> src/xdisp.c, and when point is in "normal" C code, with only
> relatively short comments?

Yep, with 24.0.92 I can see this behavior. And it's easily reproducible too.

* Open a new C file (say a.c)
* Copy all text from COPYING.
* Paste into a.c
* Try to scroll backwards.

And here the CPU usage maxes out and doesn't really recover.

Sujith

Re: Slow fontification in C mode buffers

[Eli Zaretskii]

> Date: Sat, 3 Dec 2011 15:18:24 +0000
> From: Alan Mackenzie <acm@muc.de>
> Cc: emacs-devel@gnu.org
> 
> By a happy coincidence, I've just tracked down another sluggishness (in
> large array initialisations, reported by Peter Milliken on bug-cc-mode)
> which looks to have exactly the same cause, namely
> `c-font-lock-enclosing-decls' which fontifies the innards of a
> struct/union/enum when jit-lock etc. starts in the middle of it.

Can this explain the slowness when inside a long comment?

> I've got a solution, though it's not fully worked out yet.  Give me till
> later on today, possibly tomorrow.

Take your time, it's not a catastrophe.  Not many C source files have
such long commentary sections as xdisp.c.  It's just that I use
xdisp.c for my benchmark, since it's a large file.

Thanks.

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello again, Eli!

On Sat, Dec 03, 2011 at 03:19:47PM +0200, Eli Zaretskii wrote:
> Did anyone else notice that scrolling the first time through a very
> large comment in C mode became extremely slow lately?  For example,
> visit xdisp.c in "emacs -Q", type M-<, then hit C-v several times in
> quick succession.  Then watch in disbelief how long it takes for Emacs
> to scroll by these several screenfuls.  In my case (6.5 year old
> hardware), I even see the "hourglass cursor" kick in, and the CPU
> meter shows 100% utilization of one execution unit for about 5
> seconds.

> If you then type M-< and again hit C-v several times, scrolling will
> be at its usual speed.  Scrolling outside of large comments is also
> reasonably fast, even for the first time.

> Therefore, my prime suspect is font-lock, which is triggered by the
> need to display a portion of the buffer that was not fontified yet.
> This suspicion is corroborated by the fact that jit-stealth font-lock
> of xdisp.c causes extremely high peaks of CPU usage, and Emacs
> response time becomes very sluggish.

> Is there something in C Mode's arrangements for fontification,
> specifically related to comments, that was changed lately and that can
> explain this slowdown?

Would you please try out this patch.  It is not, perhaps, as fast as one
might wish, but it is a considerable improvement nonetheless.



=== modified file 'lisp/progmodes/cc-engine.el'
*** lisp/progmodes/cc-engine.el	2011-11-23 07:03:56 +0000
--- lisp/progmodes/cc-engine.el	2011-12-03 20:58:54 +0000
***************
*** 195,203 ****
        (not prevstate)
      (> arg 0)))
  
- ;; Dynamically bound cache for `c-in-literal'.
- (defvar c-in-literal-cache t)
- 
  \f
  ;; Basic handling of preprocessor directives.
  
--- 195,200 ----
***************
*** 2093,2120 ****
  ;; `c-state-literal-at'.
  
  (defsubst c-state-pp-to-literal (from to)
!   ;; Do a parse-partial-sexp from FROM to TO, returning the bounds of any
!   ;; literal at TO as a cons, otherwise NIL.
!   ;; FROM must not be in a literal, and the buffer should already be wide
!   ;; enough.
    (save-excursion
!     (let ((s (parse-partial-sexp from to)))
        (when (or (nth 3 s) (nth 4 s))	; in a string or comment
  	(parse-partial-sexp (point) (point-max)
  			    nil			 ; TARGETDEPTH
  			    nil			 ; STOPBEFORE
  			    s			 ; OLDSTATE
! 			    'syntax-table)	 ; stop at end of literal
! 	(cons (nth 8 s) (point))))))
! 
! (defun c-state-literal-at (here)
!   ;; If position HERE is inside a literal, return (START . END), the
!   ;; boundaries of the literal (which may be outside the accessible bit of the
!   ;; buffer).  Otherwise, return nil.
!   ;;
!   ;; This function is almost the same as `c-literal-limits'.  It differs in
!   ;; that it is a lower level function, and that it rigourously follows the
!   ;; syntax from BOB, whereas `c-literal-limits' uses a "local" safe position.
    ;;
    ;; NOTE: This function manipulates `c-state-nonlit-pos-cache'.  This cache
    ;; MAY NOT contain any positions within macros, since macros are frequently
--- 2090,2124 ----
  ;; `c-state-literal-at'.
  
  (defsubst c-state-pp-to-literal (from to)
!   ;; Do a parse-partial-sexp from FROM to TO, returning either
!   ;;     (STATE TYPE (BEG . END))     if TO is in a literal; or
!   ;;     (STATE)                      otherwise,
!   ;; where STATE is the parsing state at TO, TYPE is the type of the literal
!   ;; (one of 'c, 'c++, 'string) and (BEG . END) is the boundaries of the literal.
!   ;;
!   ;; Only elements 3 (in a string), 4 (in a comment), 5 (following a quote),
!   ;; 7 (comment type) and 8 (start of comment/string) (and possibly 9) of
!   ;; STATE are valid.
    (save-excursion
!     (let ((s (parse-partial-sexp from to))
! 	  ty)
        (when (or (nth 3 s) (nth 4 s))	; in a string or comment
+ 	(setq ty (cond
+ 		  ((nth 3 s) 'string)
+ 		  ((eq (nth 7 s) t) 'c++)
+ 		  (t 'c)))
  	(parse-partial-sexp (point) (point-max)
  			    nil			 ; TARGETDEPTH
  			    nil			 ; STOPBEFORE
  			    s			 ; OLDSTATE
! 			    'syntax-table))	 ; stop at end of literal
!       (if ty
! 	  `(,s ,ty (,(nth 8 s) . ,(point)))
! 	`(,s)))))
! 
! (defun c-state-safe-place (here)
!   ;; Return a buffer position before HERE which is "safe", i.e. outside any
!   ;; string, comment, or macro.
    ;;
    ;; NOTE: This function manipulates `c-state-nonlit-pos-cache'.  This cache
    ;; MAY NOT contain any positions within macros, since macros are frequently
***************
*** 2137,2143 ****
  
  	(while (<= (setq npos (+ pos c-state-nonlit-pos-interval))
  		   here)
! 	  (setq lit (c-state-pp-to-literal pos npos))
  	  (setq pos (or (cdr lit) npos)) ; end of literal containing npos.
  	  (goto-char pos)
  	  (when (and (c-beginning-of-macro) (/= (point) pos))
--- 2141,2147 ----
  
  	(while (<= (setq npos (+ pos c-state-nonlit-pos-interval))
  		   here)
! 	  (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
  	  (setq pos (or (cdr lit) npos)) ; end of literal containing npos.
  	  (goto-char pos)
  	  (when (and (c-beginning-of-macro) (/= (point) pos))
***************
*** 2148,2156 ****
  
  	(if (> pos c-state-nonlit-pos-cache-limit)
  	    (setq c-state-nonlit-pos-cache-limit pos))
! 	(if (< pos here)
! 	    (setq lit (c-state-pp-to-literal pos here)))
! 	lit))))
  
  (defsubst c-state-lit-beg (pos)
    ;; Return the start of the literal containing POS, or POS itself.
--- 2152,2173 ----
  
  	(if (> pos c-state-nonlit-pos-cache-limit)
  	    (setq c-state-nonlit-pos-cache-limit pos))
! 	pos))))
! 	
! (defun c-state-literal-at (here)
!   ;; If position HERE is inside a literal, return (START . END), the
!   ;; boundaries of the literal (which may be outside the accessible bit of the
!   ;; buffer).  Otherwise, return nil.
!   ;;
!   ;; This function is almost the same as `c-literal-limits'.  Previously, it
!   ;; differed in that it was a lower level function, and that it rigourously
!   ;; followed the syntax from BOB.  `c-literal-limits' is now (2011-12)
!   ;; virtually identical to this function.
!   (save-restriction
!     (widen)
!     (save-excursion
!       (let ((pos (c-state-safe-place here)))
! 	    (car (cddr (c-state-pp-to-literal pos here)))))))
  
  (defsubst c-state-lit-beg (pos)
    ;; Return the start of the literal containing POS, or POS itself.
***************
*** 4181,4187 ****
  \f
  ;; Tools for handling comments and string literals.
  
! (defun c-slow-in-literal (&optional lim detect-cpp)
    "Return the type of literal point is in, if any.
  The return value is `c' if in a C-style comment, `c++' if in a C++
  style comment, `string' if in a string literal, `pound' if DETECT-CPP
--- 4198,4204 ----
  \f
  ;; Tools for handling comments and string literals.
  
! (defun c-in-literal (&optional lim detect-cpp)
    "Return the type of literal point is in, if any.
  The return value is `c' if in a C-style comment, `c++' if in a C++
  style comment, `string' if in a string literal, `pound' if DETECT-CPP
***************
*** 4194,4260 ****
  
  Note that this function might do hidden buffer changes.  See the
  comment at the start of cc-engine.el for more info."
! 
!   (if (and (vectorp c-in-literal-cache)
! 	   (= (point) (aref c-in-literal-cache 0)))
!       (aref c-in-literal-cache 1)
!     (let ((rtn (save-excursion
! 		 (let* ((pos (point))
! 			(lim (or lim (progn
! 				       (c-beginning-of-syntax)
! 				       (point))))
! 			(state (parse-partial-sexp lim pos)))
! 		   (cond
! 		    ((elt state 3) 'string)
! 		    ((elt state 4) (if (elt state 7) 'c++ 'c))
! 		    ((and detect-cpp (c-beginning-of-macro lim)) 'pound)
! 		    (t nil))))))
!       ;; cache this result if the cache is enabled
!       (if (not c-in-literal-cache)
! 	  (setq c-in-literal-cache (vector (point) rtn)))
!       rtn)))
! 
! ;; XEmacs has a built-in function that should make this much quicker.
! ;; I don't think we even need the cache, which makes our lives more
! ;; complicated anyway.  In this case, lim is only used to detect
! ;; cpp directives.
! ;;
! ;; Note that there is a bug in XEmacs's buffer-syntactic-context when used in
! ;; conjunction with syntax-table-properties.  The bug is present in, e.g.,
! ;; XEmacs 21.4.4.  It manifested itself thus:
! ;;
! ;; Starting with an empty AWK Mode buffer, type
! ;; /regexp/ {<C-j>
! ;; Point gets wrongly left at column 0, rather than being indented to tab-width.
! ;;
! ;; AWK Mode is designed such that when the first / is typed, it gets the
! ;; syntax-table property "string fence".  When the second / is typed, BOTH /s
! ;; are given the s-t property "string".  However, buffer-syntactic-context
! ;; fails to take account of the change of the s-t property on the opening / to
! ;; "string", and reports that the { is within a string started by the second /.
! ;;
! ;; The workaround for this is for the AWK Mode initialization to switch the
! ;; defalias for c-in-literal to c-slow-in-literal.  This will slow down other
! ;; cc-modes in XEmacs whenever an awk-buffer has been initialized.
! ;;
! ;; (Alan Mackenzie, 2003/4/30).
! 
! (defun c-fast-in-literal (&optional lim detect-cpp)
!   ;; This function might do hidden buffer changes.
!   (let ((context (buffer-syntactic-context)))
!     (cond
!      ((eq context 'string) 'string)
!      ((eq context 'comment) 'c++)
!      ((eq context 'block-comment) 'c)
!      ((and detect-cpp (save-excursion (c-beginning-of-macro lim))) 'pound))))
! 
! (defalias 'c-in-literal
!   (if (fboundp 'buffer-syntactic-context)
!     'c-fast-in-literal                  ; XEmacs
!     'c-slow-in-literal))                ; GNU Emacs
! 
! ;; The defalias above isn't enough to shut up the byte compiler.
! (cc-bytecomp-defun c-in-literal)
  
  (defun c-literal-limits (&optional lim near not-in-delimiter)
    "Return a cons of the beginning and end positions of the comment or
--- 4211,4222 ----
  
  Note that this function might do hidden buffer changes.  See the
  comment at the start of cc-engine.el for more info."
!   (let* ((safe-place (c-state-safe-place (point)))
! 	 (lit (c-state-pp-to-literal safe-place (point))))
!     (or (cadr lit)
! 	(and detect-cpp
! 	     (save-excursion (c-beginning-of-macro))
! 	     'pound))))
  
  (defun c-literal-limits (&optional lim near not-in-delimiter)
    "Return a cons of the beginning and end positions of the comment or
***************
*** 4273,4336 ****
  
    (save-excursion
      (let* ((pos (point))
! 	   (lim (or lim (progn
! 			  (c-beginning-of-syntax)
! 			  (point))))
! 	   (state (parse-partial-sexp lim pos)))
! 
!       (cond ((elt state 3)		; String.
! 	     (goto-char (elt state 8))
! 	     (cons (point) (or (c-safe (c-forward-sexp 1) (point))
! 			       (point-max))))
! 
! 	    ((elt state 4)		; Comment.
! 	     (goto-char (elt state 8))
! 	     (cons (point) (progn (c-forward-single-comment) (point))))
! 
! 	    ((and (not not-in-delimiter)
! 		  (not (elt state 5))
! 		  (eq (char-before) ?/)
! 		  (looking-at "[/*]"))
! 	     ;; We're standing in a comment starter.
! 	     (backward-char 1)
! 	     (cons (point) (progn (c-forward-single-comment) (point))))
! 
! 	    (near
! 	     (goto-char pos)
! 
! 	     ;; Search forward for a literal.
! 	     (skip-chars-forward " \t")
! 
! 	     (cond
! 	      ((looking-at c-string-limit-regexp) ; String.
! 	       (cons (point) (or (c-safe (c-forward-sexp 1) (point))
! 				 (point-max))))
  
! 	      ((looking-at c-comment-start-regexp) ; Line or block comment.
! 	       (cons (point) (progn (c-forward-single-comment) (point))))
  
! 	      (t
! 	       ;; Search backward.
! 	       (skip-chars-backward " \t")
  
! 	       (let ((end (point)) beg)
! 		 (cond
! 		  ((save-excursion
! 		     (< (skip-syntax-backward c-string-syntax) 0)) ; String.
! 		   (setq beg (c-safe (c-backward-sexp 1) (point))))
! 
! 		  ((and (c-safe (forward-char -2) t)
! 			(looking-at "*/"))
! 		   ;; Block comment.  Due to the nature of line
! 		   ;; comments, they will always be covered by the
! 		   ;; normal case above.
! 		   (goto-char end)
! 		   (c-backward-single-comment)
! 		   ;; If LIM is bogus, beg will be bogus.
! 		   (setq beg (point))))
  
! 		 (if beg (cons beg end))))))
! 	    ))))
  
  ;; In case external callers use this; it did have a docstring.
  (defalias 'c-literal-limits-fast 'c-literal-limits)
--- 4235,4290 ----
  
    (save-excursion
      (let* ((pos (point))
! 	   (lim (or lim (c-state-safe-place pos)))
! 	   (pp-to-lit (c-state-pp-to-literal lim pos))
! 	   (state (car pp-to-lit))
! 	   (lit-type (cadr pp-to-lit))
! 	   (lit-limits (car (cddr pp-to-lit))))
  
!       (cond
!        (lit-limits)
!        ((and (not not-in-delimiter)
! 	     (not (elt state 5))
! 	     (eq (char-before) ?/)
! 	     (looking-at "[/*]")) ; FIXME!!! use c-line/block-comment-starter.  2008-09-28.
! 	;; We're standing in a comment starter.
! 	(backward-char 1)
! 	(cons (point) (progn (c-forward-single-comment) (point))))
  
!        (near
! 	(goto-char pos)
! 	;; Search forward for a literal.
! 	(skip-chars-forward " \t")
! 	(cond
! 	 ((looking-at c-string-limit-regexp) ; String.
! 	  (cons (point) (or (c-safe (c-forward-sexp 1) (point))
! 			    (point-max))))
! 
! 	 ((looking-at c-comment-start-regexp) ; Line or block comment.
! 	  (cons (point) (progn (c-forward-single-comment) (point))))
! 
! 	 (t
! 	  ;; Search backward.
! 	  (skip-chars-backward " \t")
  
! 	  (let ((end (point)) beg)
! 	    (cond
! 	     ((save-excursion
! 		(< (skip-syntax-backward c-string-syntax) 0)) ; String.
! 	      (setq beg (c-safe (c-backward-sexp 1) (point))))
! 
! 	     ((and (c-safe (forward-char -2) t)
! 		   (looking-at "*/"))
! 	      ;; Block comment.  Due to the nature of line
! 	      ;; comments, they will always be covered by the
! 	      ;; normal case above.
! 	      (goto-char end)
! 	      (c-backward-single-comment)
! 	      ;; If LIM is bogus, beg will be bogus.
! 	      (setq beg (point))))
  
! 	    (if beg (cons beg end))))))
!        ))))
  
  ;; In case external callers use this; it did have a docstring.
  (defalias 'c-literal-limits-fast 'c-literal-limits)

=== modified file 'lisp/progmodes/cc-fonts.el'
*** lisp/progmodes/cc-fonts.el	2011-11-20 02:29:42 +0000
--- lisp/progmodes/cc-fonts.el	2011-12-03 20:47:42 +0000
***************
*** 1535,1544 ****
    ;; Fontification".
    (let* ((paren-state (c-parse-state))
  	 (start (point))
  	 decl-context bo-decl in-typedef type-type ps-elt)
  
      ;; First, are we actually in a "local" declaration?
!     (setq decl-context (c-beginning-of-decl-1)
  	  bo-decl (point)
  	  in-typedef (looking-at c-typedef-key))
      (if in-typedef (c-forward-token-2))
--- 1535,1545 ----
    ;; Fontification".
    (let* ((paren-state (c-parse-state))
  	 (start (point))
+ 	 (bod-lim (max (- (point) 500) (point-min)))
  	 decl-context bo-decl in-typedef type-type ps-elt)
  
      ;; First, are we actually in a "local" declaration?
!     (setq decl-context (c-beginning-of-decl-1 bod-lim)
  	  bo-decl (point)
  	  in-typedef (looking-at c-typedef-key))
      (if in-typedef (c-forward-token-2))

=== modified file 'lisp/progmodes/cc-mode.el'
*** lisp/progmodes/cc-mode.el	2011-11-20 02:29:42 +0000
--- lisp/progmodes/cc-mode.el	2011-12-03 21:01:50 +0000
***************
*** 1562,1571 ****
    (c-common-init 'awk-mode)
    (c-awk-unstick-NL-prop)
  
-   ;; Prevent XEmacs's buffer-syntactic-context being used.  See the comment
-   ;; in cc-engine.el, just before (defun c-fast-in-literal ...
-   (defalias 'c-in-literal 'c-slow-in-literal)
- 
    (c-run-mode-hooks 'c-mode-common-hook 'awk-mode-hook)
    (c-update-modeline))
  
--- 1562,1567 ----


-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Eli Zaretskii]

> Date: Sat, 3 Dec 2011 21:15:29 +0000
> Cc: emacs-devel@gnu.org
> From: Alan Mackenzie <acm@muc.de>
> 
> Would you please try out this patch.  It is not, perhaps, as fast as one
> might wish, but it is a considerable improvement nonetheless.

It indeed makes scrolling considerably faster inside large comments.

Thanks.

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Alan Mackenzie <acm@muc.de> writes:

> By a happy coincidence, I've just tracked down another sluggishness (in
> large array initialisations, reported by Peter Milliken on bug-cc-mode)
> which looks to have exactly the same cause, namely
> `c-font-lock-enclosing-decls' which fontifies the innards of a
> struct/union/enum when jit-lock etc. starts in the middle of it.

Is this the same problem?

http://debbugs.gnu.org/cgi/bugreport.cgi?bug=10288

I cannot find the original report by Peter.

-- 
Kanru

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kanru.

On Tue, Dec 13, 2011 at 11:31:36PM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> > By a happy coincidence, I've just tracked down another sluggishness (in
> > large array initialisations, reported by Peter Milliken on bug-cc-mode)
> > which looks to have exactly the same cause, namely
> > `c-font-lock-enclosing-decls' which fontifies the innards of a
> > struct/union/enum when jit-lock etc. starts in the middle of it.

> Is this the same problem?

> http://debbugs.gnu.org/cgi/bugreport.cgi?bug=10288

I don't think it is.  I've tried it out on the version fixed for Peter,
and it still goes like a snail.

> I cannot find the original report by Peter.

He sent his bug report direct to bug-cc-mode@gnu.org.  :-) There are
instructions for signing up to this mailing list at
http://cc-mode@sourceforge.net.

> -- 
> Kanru

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello again, Kanru!

On Tue, Dec 13, 2011 at 11:31:36PM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> > By a happy coincidence, I've just tracked down another sluggishness (in
> > large array initialisations, reported by Peter Milliken on bug-cc-mode)
> > which looks to have exactly the same cause, namely
> > `c-font-lock-enclosing-decls' which fontifies the innards of a
> > struct/union/enum when jit-lock etc. starts in the middle of it.

> Is this the same problem?

NO!

> http://debbugs.gnu.org/cgi/bugreport.cgi?bug=10288

I've seen what the problem is.  You've got lots of declarations not
separated by commas.  If DEFINE_DATA_ENTRY is a macro "with its own
semicolon", follow the instructions in chapter "Macros with ;" in the CC
Mode manual.

> -- 
> Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

On Wed, Dec 14, 2011 at 11:30:25AM +0000, Alan Mackenzie wrote:
> Hello again, Kanru!

> On Tue, Dec 13, 2011 at 11:31:36PM +0800, Kan-Ru Chen wrote:
> > Alan Mackenzie <acm@muc.de> writes:

> > > By a happy coincidence, I've just tracked down another sluggishness (in
> > > large array initialisations, reported by Peter Milliken on bug-cc-mode)
> > > which looks to have exactly the same cause, namely
> > > `c-font-lock-enclosing-decls' which fontifies the innards of a
> > > struct/union/enum when jit-lock etc. starts in the middle of it.

> > Is this the same problem?

> NO!

> > http://debbugs.gnu.org/cgi/bugreport.cgi?bug=10288

> I've seen what the problem is.  You've got lots of declarations not
> separated by commas.  If DEFINE_DATA_ENTRY is a macro "with its own
> semicolon", follow the instructions in chapter "Macros with ;" in the CC
> Mode manual.

Sorry, please ignore the previous paragraph.  It's rubbish!

> > -- 
> > Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, yet again!

On Tue, Dec 13, 2011 at 11:31:36PM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> > By a happy coincidence, I've just tracked down another sluggishness (in
> > large array initialisations, reported by Peter Milliken on bug-cc-mode)
> > which looks to have exactly the same cause, namely
> > `c-font-lock-enclosing-decls' which fontifies the innards of a
> > struct/union/enum when jit-lock etc. starts in the middle of it.

> Is this the same problem?

> http://debbugs.gnu.org/cgi/bugreport.cgi?bug=10288

As a workaround, put this into your .emacs:

(add-hook 'c-mode-common-hook
          (lambda () (setq c-macro-with-semi-re nil)))
.  It gives a speed up of about a factor of 4.

As a more drastic workaround, disable font-locking with
    M-x font-lock-mode
.

> -- 
> Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Hi!

Alan Mackenzie <acm@muc.de> writes:

> Hello, yet again!
>
> On Tue, Dec 13, 2011 at 11:31:36PM +0800, Kan-Ru Chen wrote:
>> Alan Mackenzie <acm@muc.de> writes:
>
>> > By a happy coincidence, I've just tracked down another sluggishness (in
>> > large array initialisations, reported by Peter Milliken on bug-cc-mode)
>> > which looks to have exactly the same cause, namely
>> > `c-font-lock-enclosing-decls' which fontifies the innards of a
>> > struct/union/enum when jit-lock etc. starts in the middle of it.
>
>> Is this the same problem?
>
>> http://debbugs.gnu.org/cgi/bugreport.cgi?bug=10288

I was editing this file

https://hg.mozilla.org/mozilla-central/raw-file/tip/dom/base/nsDOMClassInfo.cpp

The one in bug report is a reduced example that has same behavior

> As a workaround, put this into your .emacs:
>
> (add-hook 'c-mode-common-hook
>           (lambda () (setq c-macro-with-semi-re nil)))
> .  It gives a speed up of about a factor of 4.

Thanks! "Macros with ;" is a very useful tip too.

> As a more drastic workaround, disable font-locking with
>     M-x font-lock-mode

The fix for Peter also helps a bit.

-- 
Kanru

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello mk.4 Kanru.

On Tue, Dec 13, 2011 at 11:31:36PM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> > By a happy coincidence, I've just tracked down another sluggishness (in
> > large array initialisations, reported by Peter Milliken on bug-cc-mode)
> > which looks to have exactly the same cause, namely
> > `c-font-lock-enclosing-decls' which fontifies the innards of a
> > struct/union/enum when jit-lock etc. starts in the middle of it.

> Is this the same problem?

> http://debbugs.gnu.org/cgi/bugreport.cgi?bug=10288

> I cannot find the original report by Peter.


Would you please try the following patch and let me know how it goes.
Thanks!


*** orig/cc-engine.el	2011-12-15 09:06:28.000000000 +0000
--- cc-engine.el	2011-12-15 13:41:25.000000000 +0000
***************
*** 8073,8078 ****
--- 8073,8094 ----
  	    next-open-brace (c-pull-open-brace paren-state)))
      open-brace))
  
+ (defun c-cheap-inside-bracelist-p (paren-state)
+   ;; Return the position of the L-brace if point is inside a brace list
+   ;; initialization of an array, etc.  This is an approximate function,
+   ;; designed for speed over accuracy.  We simply search for "= {" (naturally
+   ;; with syntactic whitespace allowed).  PAREN-STATE is the normal thing that
+   ;; it is everywhere else.
+   (let (b-pos)
+     (save-excursion
+       (while
+ 	  (and (setq b-pos (c-pull-open-brace paren-state))
+ 	       (progn (goto-char b-pos)
+ 		      (c-backward-sws)
+ 		      (c-backward-token-2)
+ 		      (not (looking-at "=")))))
+       b-pos)))
+ 
  (defun c-inside-bracelist-p (containing-sexp paren-state)
    ;; return the buffer position of the beginning of the brace list
    ;; statement if we're inside a brace list, otherwise return nil.
*** orig/cc-fonts.el	2011-12-15 09:06:28.000000000 +0000
--- cc-fonts.el	2011-12-15 13:15:43.000000000 +0000
***************
*** 1394,1399 ****
--- 1394,1405 ----
  	      (c-fontify-recorded-types-and-refs)
  	      nil)
  
+ 	     ;; If point is inside a bracelist, there's no point checking it
+ 	     ;; being at a declarator.
+ 	     ((let ((paren-state (c-parse-state)))
+ 		(c-cheap-inside-bracelist-p paren-state))
+ 	      nil)
+ 
  	     (t
  	      ;; Are we at a declarator?  Try to go back to the declaration
  	      ;; to check this.  If we get there, check whether a "typedef"

> -- 
> Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Alan Mackenzie <acm@muc.de> writes:

> Would you please try the following patch and let me know how it goes.
> Thanks!

No change. c-cheap-inside-bracelist-p seems not called at all.

> *** orig/cc-engine.el	2011-12-15 09:06:28.000000000 +0000
> --- cc-engine.el	2011-12-15 13:41:25.000000000 +0000
> ***************
> *** 8073,8078 ****
> --- 8073,8094 ----
>   	    next-open-brace (c-pull-open-brace paren-state)))
>       open-brace))
>   
> + (defun c-cheap-inside-bracelist-p (paren-state)
> +   ;; Return the position of the L-brace if point is inside a brace list
> +   ;; initialization of an array, etc.  This is an approximate function,
> +   ;; designed for speed over accuracy.  We simply search for "= {" (naturally
> +   ;; with syntactic whitespace allowed).  PAREN-STATE is the normal thing that
> +   ;; it is everywhere else.
> +   (let (b-pos)
> +     (save-excursion
> +       (while
> + 	  (and (setq b-pos (c-pull-open-brace paren-state))
> + 	       (progn (goto-char b-pos)
> + 		      (c-backward-sws)
> + 		      (c-backward-token-2)
> + 		      (not (looking-at "=")))))
> +       b-pos)))
> + 
>   (defun c-inside-bracelist-p (containing-sexp paren-state)
>     ;; return the buffer position of the beginning of the brace list
>     ;; statement if we're inside a brace list, otherwise return nil.
> *** orig/cc-fonts.el	2011-12-15 09:06:28.000000000 +0000
> --- cc-fonts.el	2011-12-15 13:15:43.000000000 +0000
> ***************
> *** 1394,1399 ****
> --- 1394,1405 ----
>   	      (c-fontify-recorded-types-and-refs)
>   	      nil)
>   
> + 	     ;; If point is inside a bracelist, there's no point checking it
> + 	     ;; being at a declarator.
> + 	     ((let ((paren-state (c-parse-state)))
> + 		(c-cheap-inside-bracelist-p paren-state))
> + 	      nil)
> + 
>   	     (t
>   	      ;; Are we at a declarator?  Try to go back to the declaration
>   	      ;; to check this.  If we get there, check whether a "typedef"
>
>> -- 
>> Kanru

-- 
Kanru

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, again.

On Fri, Dec 16, 2011 at 12:16:25AM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> > Would you please try the following patch and let me know how it goes.
> > Thanks!

> No change. c-cheap-inside-bracelist-p seems not called at all.

Hmm.  The place c-cheap-inside-bracelist-p is inside
c-font-lock-declarations, it can scarcely avoid being called.

Forgive me for asking you this, but are you sure you byte compiled the
two files after patching them, etc.?

> -- 
> Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Alan Mackenzie <acm@muc.de> writes:

> Hello, again.
>
> On Fri, Dec 16, 2011 at 12:16:25AM +0800, Kan-Ru Chen wrote:
>> Alan Mackenzie <acm@muc.de> writes:
>
>> > Would you please try the following patch and let me know how it goes.
>> > Thanks!
>
>> No change. c-cheap-inside-bracelist-p seems not called at all.
>
> Hmm.  The place c-cheap-inside-bracelist-p is inside
> c-font-lock-declarations, it can scarcely avoid being called.
>
> Forgive me for asking you this, but are you sure you byte compiled the
> two files after patching them, etc.?

I forgot that I've set font-lock-maximum-decoration to 2. I tested with
emacs -Q again. The first font-lock is slow, but pretty fast after
that. It occasionally hangs when I C-v the buffer. Below is the
elp-results:

Function Name                            Call Count  Elapsed Time  Average Time
c-beginning-of-decl-1                    1203        269.68204399  0.2241746001
c-beginning-of-statement-1               1242        269.60064599  0.2170697632
c-crosses-statement-barrier-p            241143      258.95701700  0.0010738732
c-font-lock-declarations                 179         160.73329700  0.8979513798
c-find-decl-spots                        179         160.732037    0.8979443407
c-at-macro-vsemi-p                       336240      159.34210499  0.0004738939
c-in-literal                             336240      150.66956800  0.0004481012
c-slow-in-literal                        336240      149.19536500  0.0004437168
c-literal-limits                         374344      85.649792999  0.0002287996
c-beginning-of-syntax                    522725      73.183792999  0.0001400043
c-font-lock-enclosing-decls              179         57.476122000  0.3210956536
c-backward-sws                           1215297     12.826941000  1.055...e-05
c-beginning-of-macro                     746198      4.2144529999  5.647...e-06
c-parse-state                            3326        1.0435710000  0.0003137615
c-parse-state-1                          3326        0.9558269999  0.0002873803
c-forward-decl-or-cast-1                 2089        0.4252059999  0.0002035452
c-append-to-state-cache                  3178        0.3954000000  0.0001244178
c-font-lock-declarators                  135         0.3788929999  0.0028066148
c-syntactic-re-search-forward            432         0.3418039999  0.0007912129
c-forward-type                           5008        0.2934280000  5.859...e-05
c-remove-stale-state-cache               2819        0.2530829999  8.977...e-05
c-font-lock-<>-arglists                  179         0.1875940000  0.0010480111
c-font-lock-enum-tail                    179         0.1730750000  0.0009668994
c-parse-state-get-strategy               3326        0.149166      4.484...e-05
c-get-fallback-scan-pos                  330         0.1159620000  0.0003514000
c-forward-name                           3509        0.1159080000  3.303...e-05
c-remove-stale-state-cache-backwards     507         0.1071120000  0.0002112662
c-font-lock-complex-decl-prepare         179         0.0924410000  0.0005164301
c-backward-token-2                       6514        0.0913669999  1.402...e-05
c-cheap-inside-bracelist-p               1954        0.0872260000  4.463...e-05
c-state-literal-at                       520         0.0582760000  0.0001120692
c-forward-label                          707         0.0382930000  5.416...e-05
c-at-toplevel-p                          128         0.0342679999  0.0002677187
c-syntactic-content                      2688        0.0300650000  1.118...e-05
c-forward-sws                            8547        0.0256289999  2.998...e-06
c-state-balance-parens-backwards         506         0.0250620000  4.952...e-05
c-search-uplist-for-classkey             128         0.0244740000  0.0001912031
c-looking-at-decl-block                  128         0.0230999999  0.0001804687
c-syntactic-skip-backward                128         0.0213989999  0.0001671796
c-after-conditional                      204         0.0180919999  8.868...e-05
c-beginning-of-current-token             4902        0.0143600000  2.929...e-06
c-get-cache-scan-pos                     3474        0.0119859999  3.450...e-06
c-end-of-macro                           2192        0.0077970000  3.557...e-06
c-syntactic-end-of-macro                 245         0.0049240000  2.009...e-05
c-add-type                               258         0.0042930000  1.663...e-05
c-looking-at-inexpr-block                95          0.0039379999  4.145...e-05
c-forward-annotation                     2089        0.0028189999  1.349...e-06
c-skip-comments-and-strings              1694        0.0025100000  1.481...e-06
c-font-lock-invalid-string               392         0.0018759999  4.785...e-06
c-state-get-min-scan-pos                 3674        0.0011130000  3.029...e-07
c-most-enclosing-brace                   1142        0.0008480000  7.425...e-07
c-fontify-recorded-types-and-refs        475         0.0005930000  1.248...e-06
c-forward-keyword-clause                 33          0.000508      1.539...e-05
c-append-lower-brace-pair-to-state-cache 1           0.00038       0.00038
c-safe-position                          256         0.0003150000  1.230...e-06
c-forward-to-cpp-define-body             32          0.0002930000  9.156...e-06
c-end-of-current-token                   32          6.500...e-05  2.031...e-06
c-leave-cc-mode-mode                     6           1.300...e-05  2.166...e-06
c-forward-single-comment                 2           1e-05         5e-06

-- 
Kanru

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kanru.

On Fri, Dec 16, 2011 at 10:32:20AM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> > Hello, again.

> > On Fri, Dec 16, 2011 at 12:16:25AM +0800, Kan-Ru Chen wrote:
> >> Alan Mackenzie <acm@muc.de> writes:

> >> > Would you please try the following patch and let me know how it goes.
> >> > Thanks!

> >> No change. c-cheap-inside-bracelist-p seems not called at all.

> > Hmm.  The place c-cheap-inside-bracelist-p is inside
> > c-font-lock-declarations, it can scarcely avoid being called.

> > Forgive me for asking you this, but are you sure you byte compiled the
> > two files after patching them, etc.?

> I forgot that I've set font-lock-maximum-decoration to 2. I tested with
> emacs -Q again. The first font-lock is slow, but pretty fast after
> that. It occasionally hangs when I C-v the buffer. Below is the
> elp-results:

You haven't said exactly how many operations, or what, you performed
before doing elp-results.  In my elp results below, I've:
(i) Loaded elp and instrumented the c- package.
(ii) Loaded your file.
(iii) Done M-x c++-mode
(iv) Done M-x elp-results (to clear the accumulated times)
(v) M->
(vi) M-x elp-results.

I've done this twice, once before my patch, once after.  See below.
(I've added some blank lines to your lines to make it easier to read.)

> Function Name                            Call Count  Elapsed Time  Average Time
> c-beginning-of-decl-1                    1203        269.68204399  0.2241746001
> c-beginning-of-statement-1               1242        269.60064599  0.2170697632
> c-crosses-statement-barrier-p            241143      258.95701700  0.0010738732
> c-font-lock-declarations                 179         160.73329700  0.8979513798
> c-find-decl-spots                        179         160.732037    0.8979443407

> c-at-macro-vsemi-p                       336240      159.34210499  0.0004738939
> c-in-literal                             336240      150.66956800  0.0004481012
> c-slow-in-literal                        336240      149.19536500  0.0004437168
> c-literal-limits                         374344      85.649792999  0.0002287996
> c-beginning-of-syntax                    522725      73.183792999  0.0001400043

> c-font-lock-enclosing-decls              179         57.476122000  0.3210956536
> c-backward-sws                           1215297     12.826941000  1.055...e-05
> c-beginning-of-macro                     746198      4.2144529999  5.647...e-06
> c-parse-state                            3326        1.0435710000  0.0003137615
> c-parse-state-1                          3326        0.9558269999  0.0002873803
[ .... ]

Here are the results.  Firstly, before my patch:

Function Name                                   Call Count Elapsed Time Average Time
c-font-lock-declarations                         7           17.564425     2.5092035714
c-find-decl-spots                                7           17.564371     2.5091958571
c-beginning-of-decl-1                            319         17.295377000  0.0542174827
c-beginning-of-statement-1                       333         17.290300000  0.0519228228
c-crosses-statement-barrier-p                    40773       14.900494999  0.0003654500

c-at-macro-vsemi-p                               41180       9.1869819999  0.0002230932
c-in-literal                                     41180       7.1732340000  0.0001741921
c-literal-limits                                 40126       3.7167549999  9.262...e-05
c-backward-sws                                   184630      2.7831049999  1.507...e-05
c-beginning-of-macro                             103323      0.6003159999  5.810...e-06

c-state-safe-place                               61257       0.4731989999  7.724...e-06
c-parse-state                                    326         0.2056420000  0.0006308036
c-parse-state-1                                  326         0.1998150000  0.0006129294
c-append-to-state-cache                          319         0.1097839999  0.0003441504
c-forward-decl-or-cast-1                         305         0.0845859999  0.0002773311


Secondly, after the patch.

Function Name                                   Call Count Elapsed Time Average Time
c-font-lock-declarations                         7           0.180145      0.025735
c-find-decl-spots                                7           0.1800869999  0.0257267142
c-font-lock-enclosing-decls                      7           0.0966709999  0.0138101428
c-beginning-of-decl-1                            14          0.0923319999  0.0065951428
c-beginning-of-statement-1                       28          0.0913820000  0.0032636428

c-parse-state                                    326         0.086686      0.0002659079
c-parse-state-1                                  326         0.0810159999  0.0002485153
c-crosses-statement-barrier-p                    147         0.0744919999  0.0005067482
c-forward-decl-or-cast-1                         305         0.0568969999  0.0001865475
c-forward-type                                   617         0.0472009999  7.650...e-05

c-append-to-state-cache                          319         0.0459020000  0.0001438934
c-at-macro-vsemi-p                               189         0.0408429999  0.0002161005
c-literal-limits                                 112         0.0402480000  0.0003593571
c-beginning-of-macro                             2186        0.0391449999  1.790...e-05
c-in-literal                                     189         0.0371179999  0.0001963915
[ .... ]
c-cheap-inside-bracelist-p                       305         0.0109840000  3.601...e-05


Would you please perform the test again, exactly as I have done, and then
send me the new results.  (The top 15 lines should be enough).

Thanks!

> -- 
> Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Alan Mackenzie <acm@muc.de> writes:

>> I forgot that I've set font-lock-maximum-decoration to 2. I tested with
>> emacs -Q again. The first font-lock is slow, but pretty fast after
>> that. It occasionally hangs when I C-v the buffer. Below is the
>> elp-results:
>
> You haven't said exactly how many operations, or what, you performed
> before doing elp-results.  In my elp results below, I've:
> (i) Loaded elp and instrumented the c- package.
> (ii) Loaded your file.
> (iii) Done M-x c++-mode
> (iv) Done M-x elp-results (to clear the accumulated times)
> (v) M->
> (vi) M-x elp-results.

Please forgive me for using the other files, it is closer to the real
case. You can get the file from

https://hg.mozilla.org/mozilla-central/raw-file/tip/dom/base/nsDOMClassInfo.cpp

(i) Loaded elp and instrumented the c- package.
(ii) Loaded nsDOMClassInfo.cpp
(iii) Done M-x c++-mode
(iv) Done M-x elp-results (to clear the accumulated times)
(v) C-s battery until failing to find 
(vi) M-x elp-results.

Before:

c-beginning-of-decl-1                          201         13.065947999  0.0650047164
c-beginning-of-statement-1                     229         13.061191     0.0570357685
c-crosses-statement-barrier-p                  35466       11.622212999  0.0003277001
c-font-lock-declarations                       16          9.4090929999  0.5880683124
c-find-decl-spots                              16          9.4089879999  0.5880617499

c-at-macro-vsemi-p                             46569       6.6139159999  0.0001420240
c-in-literal                                   46569       5.4569670000  0.0001171802
c-literal-limits                               51666       3.1393819999  6.076...e-05
c-backward-sws                                 176682      1.6644079999  9.420...e-06
c-beginning-of-macro                           104078      0.5568430000  5.350...e-06

c-state-safe-place                             72459       0.3154430000  4.353...e-06
c-parse-state                                  225         0.1421229999  0.0006316577
c-parse-state-1                                225         0.1385559999  0.0006158044
c-font-lock-enclosing-decls                    16          0.1365140000  0.0085321250
c-append-to-state-cache                        196         0.0641449999  0.0003272704

After:

c-beginning-of-decl-1                          137         9.6732900000  0.0706079562
c-beginning-of-statement-1                     165         9.6693369999  0.0586020424
c-crosses-statement-barrier-p                  25584       8.5505400000  0.0003342143
c-font-lock-declarations                       16          6.059768      0.3787355
c-find-decl-spots                              16          6.059666      0.378729125

c-at-macro-vsemi-p                             35149       4.7420429999  0.0001349126
c-in-literal                                   35149       4.0154739999  0.0001142414
c-literal-limits                               38962       2.5425719999  6.525...e-05
c-backward-sws                                 128214      1.1421259999  8.907...e-06
c-beginning-of-macro                           78145       0.3845660000  4.921...e-06

c-state-safe-place                             54703       0.2419970000  4.423...e-06
c-parse-state                                  317         0.1464209999  0.0004618958
c-font-lock-enclosing-decls                    16          0.137945      0.0086215625
c-parse-state-1                                317         0.1331939999  0.0004201703
c-font-lock-declarators                        24          0.065522      0.0027300833

-- 
Kanru

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kanru.

On Sun, Dec 18, 2011 at 12:06:00AM +0800, Kan-Ru Chen wrote:

> Please forgive me for using the other files, it is closer to the real
> case. You can get the file from

> https://hg.mozilla.org/mozilla-central/raw-file/tip/dom/base/nsDOMClassInfo.cpp

OK, now I understand.  I feel your pain.  ;-(

> (i) Loaded elp and instrumented the c- package.
> (ii) Loaded nsDOMClassInfo.cpp
> (iii) Done M-x c++-mode
> (iv) Done M-x elp-results (to clear the accumulated times)
> (v) C-s battery until failing to find 
> (vi) M-x elp-results.

> Before:

> c-beginning-of-decl-1                          201         13.065947999  0.0650047164
> c-beginning-of-statement-1                     229         13.061191     0.0570357685
> c-crosses-statement-barrier-p                  35466       11.622212999  0.0003277001
> c-font-lock-declarations                       16          9.4090929999  0.5880683124
> c-find-decl-spots                              16          9.4089879999  0.5880617499

> c-at-macro-vsemi-p                             46569       6.6139159999  0.0001420240
> c-in-literal                                   46569       5.4569670000  0.0001171802
> c-literal-limits                               51666       3.1393819999  6.076...e-05
> c-backward-sws                                 176682      1.6644079999  9.420...e-06
> c-beginning-of-macro                           104078      0.5568430000  5.350...e-06

> c-state-safe-place                             72459       0.3154430000  4.353...e-06
> c-parse-state                                  225         0.1421229999  0.0006316577
> c-parse-state-1                                225         0.1385559999  0.0006158044
> c-font-lock-enclosing-decls                    16          0.1365140000  0.0085321250
> c-append-to-state-cache                        196         0.0641449999  0.0003272704

> After:

> c-beginning-of-decl-1                          137         9.6732900000  0.0706079562
> c-beginning-of-statement-1                     165         9.6693369999  0.0586020424
> c-crosses-statement-barrier-p                  25584       8.5505400000  0.0003342143
> c-font-lock-declarations                       16          6.059768      0.3787355
> c-find-decl-spots                              16          6.059666      0.378729125

> c-at-macro-vsemi-p                             35149       4.7420429999  0.0001349126
> c-in-literal                                   35149       4.0154739999  0.0001142414
> c-literal-limits                               38962       2.5425719999  6.525...e-05
> c-backward-sws                                 128214      1.1421259999  8.907...e-06
> c-beginning-of-macro                           78145       0.3845660000  4.921...e-06

> c-state-safe-place                             54703       0.2419970000  4.423...e-06
> c-parse-state                                  317         0.1464209999  0.0004618958
> c-font-lock-enclosing-decls                    16          0.137945      0.0086215625
> c-parse-state-1                                317         0.1331939999  0.0004201703
> c-font-lock-declarators                        24          0.065522      0.0027300833

It looks like my latest change is saving ~25% of the runtime.  That is
not enough, not nearly enough.  Also, your hardware is _much_ faster than
mine.  ;-)

The problem is quite clear - because of the dearth of
semicolons/right-braces, searching backwards to the beginning of
statements (function "c-beginning-of-statement-1") takes forever during
fontification.  To solve this will involve putting a limit on backward
search and somehow coping with not finding BO-statement.

This is going to be a lot of work, and I'm not going to be able to get it
finished this year.  Sorry.  But I'm sure the bug can be fixed.  

In the meantime, I suggest turning font-lock off for this file.

> -- Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Geoff Gole]

[-- Attachment #1: Type: text/plain, Size: 249 bytes --]

If another data point will help, I've also noticed *very* slow c-mode
fontification in a script generated header,
/usr/include/GL/gl_mangle.h. In case you don't have this header, a
copy is attached.

The file is basically several thousand #defines.

[-- Attachment #2: gl_mangle.h --]
[-- Type: text/x-chdr, Size: 110027 bytes --]

#if 0
#define GL_MANGLE_C1 "DO NOT EDIT!!! - TO REGENERATE from gl.h, EXECUTE THIS FILE IN SHELL (/bin/sh) and save the output"
#define GL_MANGLE_C2 "This file is used to create GL function protypes and aliases for the function names"
	files="gl.h glext.h"
#define GL_MANGLE_C3 "get regeneration header - copy everything in this file above the 'REGENERATE_TO_END' line"
	awk 	'!done; /^\/\*REGENERATE_TO_END/ {done=1}' $0
	echo ""
#define GL_MANGLE_C4 get aliases
	grep '^GLAPI' $files | sed -e 's/.*ENTRY gl\([^( ]*\).*$/#define gl\1		MANGLE(\1)/' | sort | uniq
	echo ""
	echo "#endif /* GL_MANGLE_H */"
	exit
#endif /* REGENERATION */

/*
 * If you compile Mesa with USE_MGL_NAMESPACE defined then you can link
 * your application both with OpenGL and Mesa.  The Mesa functions will
 * be redefined so they are prefixed with "mgl" instead of "gl".
 * Mgl contributed by Randy Frank (rfrank@rsinc.com)
 * Regneration code contributed by Ray Tice (rayt@ma.ultra.net)
 */

#ifndef GL_MANGLE_H
#define GL_MANGLE_H

#ifndef   MANGLE
#define   MANGLE(x) mgl##x
#endif  /*MANGLE*/

/*REGENERATE_TO_END-----------ALL LINES BELOW HERE GET REPLACED ON REGENERATION */

#define glAccum		MANGLE(Accum)
#define glActiveProgramEXT		MANGLE(ActiveProgramEXT)
#define glActiveStencilFaceEXT		MANGLE(ActiveStencilFaceEXT)
#define glActiveTextureARB		MANGLE(ActiveTextureARB)
#define glActiveTexture		MANGLE(ActiveTexture)
#define glActiveVaryingNV		MANGLE(ActiveVaryingNV)
#define glAlphaFragmentOp1ATI		MANGLE(AlphaFragmentOp1ATI)
#define glAlphaFragmentOp2ATI		MANGLE(AlphaFragmentOp2ATI)
#define glAlphaFragmentOp3ATI		MANGLE(AlphaFragmentOp3ATI)
#define glAlphaFunc		MANGLE(AlphaFunc)
#define glApplyTextureEXT		MANGLE(ApplyTextureEXT)
#define glAreProgramsResidentNV		MANGLE(AreProgramsResidentNV)
#define glAreTexturesResidentEXT		MANGLE(AreTexturesResidentEXT)
#define glAreTexturesResident		MANGLE(AreTexturesResident)
#define glArrayElementEXT		MANGLE(ArrayElementEXT)
#define glArrayElement		MANGLE(ArrayElement)
#define glArrayObjectATI		MANGLE(ArrayObjectATI)
#define glAsyncMarkerSGIX		MANGLE(AsyncMarkerSGIX)
#define glAttachObjectARB		MANGLE(AttachObjectARB)
#define glAttachShader		MANGLE(AttachShader)
#define glBeginConditionalRender		MANGLE(BeginConditionalRender)
#define glBeginConditionalRenderNV		MANGLE(BeginConditionalRenderNV)
#define glBeginFragmentShaderATI		MANGLE(BeginFragmentShaderATI)
#define glBegin		MANGLE(Begin)
#define glBeginOcclusionQueryNV		MANGLE(BeginOcclusionQueryNV)
#define glBeginPerfMonitorAMD		MANGLE(BeginPerfMonitorAMD)
#define glBeginQueryARB		MANGLE(BeginQueryARB)
#define glBeginQuery		MANGLE(BeginQuery)
#define glBeginTransformFeedbackEXT		MANGLE(BeginTransformFeedbackEXT)
#define glBeginTransformFeedback		MANGLE(BeginTransformFeedback)
#define glBeginTransformFeedbackNV		MANGLE(BeginTransformFeedbackNV)
#define glBeginVertexShaderEXT		MANGLE(BeginVertexShaderEXT)
#define glBeginVideoCaptureNV		MANGLE(BeginVideoCaptureNV)
#define glBindAttribLocationARB		MANGLE(BindAttribLocationARB)
#define glBindAttribLocation		MANGLE(BindAttribLocation)
#define glBindBufferARB		MANGLE(BindBufferARB)
#define glBindBufferBaseEXT		MANGLE(BindBufferBaseEXT)
#define glBindBufferBase		MANGLE(BindBufferBase)
#define glBindBufferBaseNV		MANGLE(BindBufferBaseNV)
#define glBindBuffer		MANGLE(BindBuffer)
#define glBindBufferOffsetEXT		MANGLE(BindBufferOffsetEXT)
#define glBindBufferOffsetNV		MANGLE(BindBufferOffsetNV)
#define glBindBufferRangeEXT		MANGLE(BindBufferRangeEXT)
#define glBindBufferRange		MANGLE(BindBufferRange)
#define glBindBufferRangeNV		MANGLE(BindBufferRangeNV)
#define glBindFragDataLocationEXT		MANGLE(BindFragDataLocationEXT)
#define glBindFragDataLocation		MANGLE(BindFragDataLocation)
#define glBindFragmentShaderATI		MANGLE(BindFragmentShaderATI)
#define glBindFramebufferEXT		MANGLE(BindFramebufferEXT)
#define glBindFramebuffer		MANGLE(BindFramebuffer)
#define glBindLightParameterEXT		MANGLE(BindLightParameterEXT)
#define glBindMaterialParameterEXT		MANGLE(BindMaterialParameterEXT)
#define glBindMultiTextureEXT		MANGLE(BindMultiTextureEXT)
#define glBindParameterEXT		MANGLE(BindParameterEXT)
#define glBindProgramARB		MANGLE(BindProgramARB)
#define glBindProgramNV		MANGLE(BindProgramNV)
#define glBindRenderbufferEXT		MANGLE(BindRenderbufferEXT)
#define glBindRenderbuffer		MANGLE(BindRenderbuffer)
#define glBindTexGenParameterEXT		MANGLE(BindTexGenParameterEXT)
#define glBindTextureEXT		MANGLE(BindTextureEXT)
#define glBindTexture		MANGLE(BindTexture)
#define glBindTextureUnitParameterEXT		MANGLE(BindTextureUnitParameterEXT)
#define glBindTransformFeedbackNV		MANGLE(BindTransformFeedbackNV)
#define glBindVertexArrayAPPLE		MANGLE(BindVertexArrayAPPLE)
#define glBindVertexArray		MANGLE(BindVertexArray)
#define glBindVertexShaderEXT		MANGLE(BindVertexShaderEXT)
#define glBindVideoCaptureStreamBufferNV		MANGLE(BindVideoCaptureStreamBufferNV)
#define glBindVideoCaptureStreamTextureNV		MANGLE(BindVideoCaptureStreamTextureNV)
#define glBinormal3bEXT		MANGLE(Binormal3bEXT)
#define glBinormal3bvEXT		MANGLE(Binormal3bvEXT)
#define glBinormal3dEXT		MANGLE(Binormal3dEXT)
#define glBinormal3dvEXT		MANGLE(Binormal3dvEXT)
#define glBinormal3fEXT		MANGLE(Binormal3fEXT)
#define glBinormal3fvEXT		MANGLE(Binormal3fvEXT)
#define glBinormal3iEXT		MANGLE(Binormal3iEXT)
#define glBinormal3ivEXT		MANGLE(Binormal3ivEXT)
#define glBinormal3sEXT		MANGLE(Binormal3sEXT)
#define glBinormal3svEXT		MANGLE(Binormal3svEXT)
#define glBinormalPointerEXT		MANGLE(BinormalPointerEXT)
#define glBitmap		MANGLE(Bitmap)
#define glBlendColorEXT		MANGLE(BlendColorEXT)
#define glBlendColor		MANGLE(BlendColor)
#define glBlendEquationEXT		MANGLE(BlendEquationEXT)
#define glBlendEquationi		MANGLE(BlendEquationi)
#define glBlendEquationIndexedAMD		MANGLE(BlendEquationIndexedAMD)
#define glBlendEquation		MANGLE(BlendEquation)
#define glBlendEquationSeparateATI		MANGLE(BlendEquationSeparateATI)
#define glBlendEquationSeparateEXT		MANGLE(BlendEquationSeparateEXT)
#define glBlendEquationSeparatei		MANGLE(BlendEquationSeparatei)
#define glBlendEquationSeparateIndexedAMD		MANGLE(BlendEquationSeparateIndexedAMD)
#define glBlendEquationSeparate		MANGLE(BlendEquationSeparate)
#define glBlendFunci		MANGLE(BlendFunci)
#define glBlendFuncIndexedAMD		MANGLE(BlendFuncIndexedAMD)
#define glBlendFunc		MANGLE(BlendFunc)
#define glBlendFuncSeparateEXT		MANGLE(BlendFuncSeparateEXT)
#define glBlendFuncSeparatei		MANGLE(BlendFuncSeparatei)
#define glBlendFuncSeparateIndexedAMD		MANGLE(BlendFuncSeparateIndexedAMD)
#define glBlendFuncSeparateINGR		MANGLE(BlendFuncSeparateINGR)
#define glBlendFuncSeparate		MANGLE(BlendFuncSeparate)
#define glBlitFramebufferEXT		MANGLE(BlitFramebufferEXT)
#define glBlitFramebuffer		MANGLE(BlitFramebuffer)
#define glBufferAddressRangeNV		MANGLE(BufferAddressRangeNV)
#define glBufferDataARB		MANGLE(BufferDataARB)
#define glBufferData		MANGLE(BufferData)
#define glBufferParameteriAPPLE		MANGLE(BufferParameteriAPPLE)
#define glBufferSubDataARB		MANGLE(BufferSubDataARB)
#define glBufferSubData		MANGLE(BufferSubData)
#define glCallList		MANGLE(CallList)
#define glCallLists		MANGLE(CallLists)
#define glCheckFramebufferStatusEXT		MANGLE(CheckFramebufferStatusEXT)
#define glCheckFramebufferStatus		MANGLE(CheckFramebufferStatus)
#define glCheckNamedFramebufferStatusEXT		MANGLE(CheckNamedFramebufferStatusEXT)
#define glClampColorARB		MANGLE(ClampColorARB)
#define glClampColor		MANGLE(ClampColor)
#define glClearAccum		MANGLE(ClearAccum)
#define glClearBufferfi		MANGLE(ClearBufferfi)
#define glClearBufferfv		MANGLE(ClearBufferfv)
#define glClearBufferiv		MANGLE(ClearBufferiv)
#define glClearBufferuiv		MANGLE(ClearBufferuiv)
#define glClearColorIiEXT		MANGLE(ClearColorIiEXT)
#define glClearColorIuiEXT		MANGLE(ClearColorIuiEXT)
#define glClearColor		MANGLE(ClearColor)
#define glClearDebugLogMESA		MANGLE(ClearDebugLogMESA)
#define glClearDepthdNV		MANGLE(ClearDepthdNV)
#define glClearDepth		MANGLE(ClearDepth)
#define glClearIndex		MANGLE(ClearIndex)
#define glClear		MANGLE(Clear)
#define glClearStencil		MANGLE(ClearStencil)
#define glClientActiveTextureARB		MANGLE(ClientActiveTextureARB)
#define glClientActiveTexture		MANGLE(ClientActiveTexture)
#define glClientActiveVertexStreamATI		MANGLE(ClientActiveVertexStreamATI)
#define glClientAttribDefaultEXT		MANGLE(ClientAttribDefaultEXT)
#define glClientWaitSync		MANGLE(ClientWaitSync)
#define glClipPlane		MANGLE(ClipPlane)
#define glColor3b		MANGLE(Color3b)
#define glColor3bv		MANGLE(Color3bv)
#define glColor3d		MANGLE(Color3d)
#define glColor3dv		MANGLE(Color3dv)
#define glColor3f		MANGLE(Color3f)
#define glColor3fVertex3fSUN		MANGLE(Color3fVertex3fSUN)
#define glColor3fVertex3fvSUN		MANGLE(Color3fVertex3fvSUN)
#define glColor3fv		MANGLE(Color3fv)
#define glColor3hNV		MANGLE(Color3hNV)
#define glColor3hvNV		MANGLE(Color3hvNV)
#define glColor3i		MANGLE(Color3i)
#define glColor3iv		MANGLE(Color3iv)
#define glColor3s		MANGLE(Color3s)
#define glColor3sv		MANGLE(Color3sv)
#define glColor3ub		MANGLE(Color3ub)
#define glColor3ubv		MANGLE(Color3ubv)
#define glColor3ui		MANGLE(Color3ui)
#define glColor3uiv		MANGLE(Color3uiv)
#define glColor3us		MANGLE(Color3us)
#define glColor3usv		MANGLE(Color3usv)
#define glColor4b		MANGLE(Color4b)
#define glColor4bv		MANGLE(Color4bv)
#define glColor4d		MANGLE(Color4d)
#define glColor4dv		MANGLE(Color4dv)
#define glColor4f		MANGLE(Color4f)
#define glColor4fNormal3fVertex3fSUN		MANGLE(Color4fNormal3fVertex3fSUN)
#define glColor4fNormal3fVertex3fvSUN		MANGLE(Color4fNormal3fVertex3fvSUN)
#define glColor4fv		MANGLE(Color4fv)
#define glColor4hNV		MANGLE(Color4hNV)
#define glColor4hvNV		MANGLE(Color4hvNV)
#define glColor4i		MANGLE(Color4i)
#define glColor4iv		MANGLE(Color4iv)
#define glColor4s		MANGLE(Color4s)
#define glColor4sv		MANGLE(Color4sv)
#define glColor4ub		MANGLE(Color4ub)
#define glColor4ubVertex2fSUN		MANGLE(Color4ubVertex2fSUN)
#define glColor4ubVertex2fvSUN		MANGLE(Color4ubVertex2fvSUN)
#define glColor4ubVertex3fSUN		MANGLE(Color4ubVertex3fSUN)
#define glColor4ubVertex3fvSUN		MANGLE(Color4ubVertex3fvSUN)
#define glColor4ubv		MANGLE(Color4ubv)
#define glColor4ui		MANGLE(Color4ui)
#define glColor4uiv		MANGLE(Color4uiv)
#define glColor4us		MANGLE(Color4us)
#define glColor4usv		MANGLE(Color4usv)
#define glColorFormatNV		MANGLE(ColorFormatNV)
#define glColorFragmentOp1ATI		MANGLE(ColorFragmentOp1ATI)
#define glColorFragmentOp2ATI		MANGLE(ColorFragmentOp2ATI)
#define glColorFragmentOp3ATI		MANGLE(ColorFragmentOp3ATI)
#define glColorMaski		MANGLE(ColorMaski)
#define glColorMaskIndexedEXT		MANGLE(ColorMaskIndexedEXT)
#define glColorMask		MANGLE(ColorMask)
#define glColorMaterial		MANGLE(ColorMaterial)
#define glColorPointerEXT		MANGLE(ColorPointerEXT)
#define glColorPointerListIBM		MANGLE(ColorPointerListIBM)
#define glColorPointer		MANGLE(ColorPointer)
#define glColorPointervINTEL		MANGLE(ColorPointervINTEL)
#define glColorSubTableEXT		MANGLE(ColorSubTableEXT)
#define glColorSubTable		MANGLE(ColorSubTable)
#define glColorTableEXT		MANGLE(ColorTableEXT)
#define glColorTable		MANGLE(ColorTable)
#define glColorTableParameterfv		MANGLE(ColorTableParameterfv)
#define glColorTableParameterfvSGI		MANGLE(ColorTableParameterfvSGI)
#define glColorTableParameteriv		MANGLE(ColorTableParameteriv)
#define glColorTableParameterivSGI		MANGLE(ColorTableParameterivSGI)
#define glColorTableSGI		MANGLE(ColorTableSGI)
#define glCombinerInputNV		MANGLE(CombinerInputNV)
#define glCombinerOutputNV		MANGLE(CombinerOutputNV)
#define glCombinerParameterfNV		MANGLE(CombinerParameterfNV)
#define glCombinerParameterfvNV		MANGLE(CombinerParameterfvNV)
#define glCombinerParameteriNV		MANGLE(CombinerParameteriNV)
#define glCombinerParameterivNV		MANGLE(CombinerParameterivNV)
#define glCombinerStageParameterfvNV		MANGLE(CombinerStageParameterfvNV)
#define glCompileShaderARB		MANGLE(CompileShaderARB)
#define glCompileShader		MANGLE(CompileShader)
#define glCompressedMultiTexImage1DEXT		MANGLE(CompressedMultiTexImage1DEXT)
#define glCompressedMultiTexImage2DEXT		MANGLE(CompressedMultiTexImage2DEXT)
#define glCompressedMultiTexImage3DEXT		MANGLE(CompressedMultiTexImage3DEXT)
#define glCompressedMultiTexSubImage1DEXT		MANGLE(CompressedMultiTexSubImage1DEXT)
#define glCompressedMultiTexSubImage2DEXT		MANGLE(CompressedMultiTexSubImage2DEXT)
#define glCompressedMultiTexSubImage3DEXT		MANGLE(CompressedMultiTexSubImage3DEXT)
#define glCompressedTexImage1DARB		MANGLE(CompressedTexImage1DARB)
#define glCompressedTexImage1D		MANGLE(CompressedTexImage1D)
#define glCompressedTexImage2DARB		MANGLE(CompressedTexImage2DARB)
#define glCompressedTexImage2D		MANGLE(CompressedTexImage2D)
#define glCompressedTexImage3DARB		MANGLE(CompressedTexImage3DARB)
#define glCompressedTexImage3D		MANGLE(CompressedTexImage3D)
#define glCompressedTexSubImage1DARB		MANGLE(CompressedTexSubImage1DARB)
#define glCompressedTexSubImage1D		MANGLE(CompressedTexSubImage1D)
#define glCompressedTexSubImage2DARB		MANGLE(CompressedTexSubImage2DARB)
#define glCompressedTexSubImage2D		MANGLE(CompressedTexSubImage2D)
#define glCompressedTexSubImage3DARB		MANGLE(CompressedTexSubImage3DARB)
#define glCompressedTexSubImage3D		MANGLE(CompressedTexSubImage3D)
#define glCompressedTextureImage1DEXT		MANGLE(CompressedTextureImage1DEXT)
#define glCompressedTextureImage2DEXT		MANGLE(CompressedTextureImage2DEXT)
#define glCompressedTextureImage3DEXT		MANGLE(CompressedTextureImage3DEXT)
#define glCompressedTextureSubImage1DEXT		MANGLE(CompressedTextureSubImage1DEXT)
#define glCompressedTextureSubImage2DEXT		MANGLE(CompressedTextureSubImage2DEXT)
#define glCompressedTextureSubImage3DEXT		MANGLE(CompressedTextureSubImage3DEXT)
#define glConvolutionFilter1DEXT		MANGLE(ConvolutionFilter1DEXT)
#define glConvolutionFilter1D		MANGLE(ConvolutionFilter1D)
#define glConvolutionFilter2DEXT		MANGLE(ConvolutionFilter2DEXT)
#define glConvolutionFilter2D		MANGLE(ConvolutionFilter2D)
#define glConvolutionParameterfEXT		MANGLE(ConvolutionParameterfEXT)
#define glConvolutionParameterf		MANGLE(ConvolutionParameterf)
#define glConvolutionParameterfvEXT		MANGLE(ConvolutionParameterfvEXT)
#define glConvolutionParameterfv		MANGLE(ConvolutionParameterfv)
#define glConvolutionParameteriEXT		MANGLE(ConvolutionParameteriEXT)
#define glConvolutionParameteri		MANGLE(ConvolutionParameteri)
#define glConvolutionParameterivEXT		MANGLE(ConvolutionParameterivEXT)
#define glConvolutionParameteriv		MANGLE(ConvolutionParameteriv)
#define glCopyBufferSubData		MANGLE(CopyBufferSubData)
#define glCopyColorSubTableEXT		MANGLE(CopyColorSubTableEXT)
#define glCopyColorSubTable		MANGLE(CopyColorSubTable)
#define glCopyColorTable		MANGLE(CopyColorTable)
#define glCopyColorTableSGI		MANGLE(CopyColorTableSGI)
#define glCopyConvolutionFilter1DEXT		MANGLE(CopyConvolutionFilter1DEXT)
#define glCopyConvolutionFilter1D		MANGLE(CopyConvolutionFilter1D)
#define glCopyConvolutionFilter2DEXT		MANGLE(CopyConvolutionFilter2DEXT)
#define glCopyConvolutionFilter2D		MANGLE(CopyConvolutionFilter2D)
#define glCopyImageSubDataNV		MANGLE(CopyImageSubDataNV)
#define glCopyMultiTexImage1DEXT		MANGLE(CopyMultiTexImage1DEXT)
#define glCopyMultiTexImage2DEXT		MANGLE(CopyMultiTexImage2DEXT)
#define glCopyMultiTexSubImage1DEXT		MANGLE(CopyMultiTexSubImage1DEXT)
#define glCopyMultiTexSubImage2DEXT		MANGLE(CopyMultiTexSubImage2DEXT)
#define glCopyMultiTexSubImage3DEXT		MANGLE(CopyMultiTexSubImage3DEXT)
#define glCopyPixels		MANGLE(CopyPixels)
#define glCopyTexImage1DEXT		MANGLE(CopyTexImage1DEXT)
#define glCopyTexImage1D		MANGLE(CopyTexImage1D)
#define glCopyTexImage2DEXT		MANGLE(CopyTexImage2DEXT)
#define glCopyTexImage2D		MANGLE(CopyTexImage2D)
#define glCopyTexSubImage1DEXT		MANGLE(CopyTexSubImage1DEXT)
#define glCopyTexSubImage1D		MANGLE(CopyTexSubImage1D)
#define glCopyTexSubImage2DEXT		MANGLE(CopyTexSubImage2DEXT)
#define glCopyTexSubImage2D		MANGLE(CopyTexSubImage2D)
#define glCopyTexSubImage3DEXT		MANGLE(CopyTexSubImage3DEXT)
#define glCopyTexSubImage3D		MANGLE(CopyTexSubImage3D)
#define glCopyTextureImage1DEXT		MANGLE(CopyTextureImage1DEXT)
#define glCopyTextureImage2DEXT		MANGLE(CopyTextureImage2DEXT)
#define glCopyTextureSubImage1DEXT		MANGLE(CopyTextureSubImage1DEXT)
#define glCopyTextureSubImage2DEXT		MANGLE(CopyTextureSubImage2DEXT)
#define glCopyTextureSubImage3DEXT		MANGLE(CopyTextureSubImage3DEXT)
#define glCreateDebugObjectMESA		MANGLE(CreateDebugObjectMESA)
#define glCreateProgram		MANGLE(CreateProgram)
#define glCreateProgramObjectARB		MANGLE(CreateProgramObjectARB)
#define glCreateShader		MANGLE(CreateShader)
#define glCreateShaderObjectARB		MANGLE(CreateShaderObjectARB)
#define glCreateShaderProgramEXT		MANGLE(CreateShaderProgramEXT)
#define glCullFace		MANGLE(CullFace)
#define glCullParameterdvEXT		MANGLE(CullParameterdvEXT)
#define glCullParameterfvEXT		MANGLE(CullParameterfvEXT)
#define glCurrentPaletteMatrixARB		MANGLE(CurrentPaletteMatrixARB)
#define glDeformationMap3dSGIX		MANGLE(DeformationMap3dSGIX)
#define glDeformationMap3fSGIX		MANGLE(DeformationMap3fSGIX)
#define glDeformSGIX		MANGLE(DeformSGIX)
#define glDeleteAsyncMarkersSGIX		MANGLE(DeleteAsyncMarkersSGIX)
#define glDeleteBuffersARB		MANGLE(DeleteBuffersARB)
#define glDeleteBuffers		MANGLE(DeleteBuffers)
#define glDeleteFencesAPPLE		MANGLE(DeleteFencesAPPLE)
#define glDeleteFencesNV		MANGLE(DeleteFencesNV)
#define glDeleteFragmentShaderATI		MANGLE(DeleteFragmentShaderATI)
#define glDeleteFramebuffersEXT		MANGLE(DeleteFramebuffersEXT)
#define glDeleteFramebuffers		MANGLE(DeleteFramebuffers)
#define glDeleteLists		MANGLE(DeleteLists)
#define glDeleteObjectARB		MANGLE(DeleteObjectARB)
#define glDeleteOcclusionQueriesNV		MANGLE(DeleteOcclusionQueriesNV)
#define glDeletePerfMonitorsAMD		MANGLE(DeletePerfMonitorsAMD)
#define glDeleteProgram		MANGLE(DeleteProgram)
#define glDeleteProgramsARB		MANGLE(DeleteProgramsARB)
#define glDeleteProgramsNV		MANGLE(DeleteProgramsNV)
#define glDeleteQueriesARB		MANGLE(DeleteQueriesARB)
#define glDeleteQueries		MANGLE(DeleteQueries)
#define glDeleteRenderbuffersEXT		MANGLE(DeleteRenderbuffersEXT)
#define glDeleteRenderbuffers		MANGLE(DeleteRenderbuffers)
#define glDeleteShader		MANGLE(DeleteShader)
#define glDeleteSync		MANGLE(DeleteSync)
#define glDeleteTexturesEXT		MANGLE(DeleteTexturesEXT)
#define glDeleteTextures		MANGLE(DeleteTextures)
#define glDeleteTransformFeedbacksNV		MANGLE(DeleteTransformFeedbacksNV)
#define glDeleteVertexArraysAPPLE		MANGLE(DeleteVertexArraysAPPLE)
#define glDeleteVertexArrays		MANGLE(DeleteVertexArrays)
#define glDeleteVertexShaderEXT		MANGLE(DeleteVertexShaderEXT)
#define glDepthBoundsdNV		MANGLE(DepthBoundsdNV)
#define glDepthBoundsEXT		MANGLE(DepthBoundsEXT)
#define glDepthFunc		MANGLE(DepthFunc)
#define glDepthMask		MANGLE(DepthMask)
#define glDepthRangedNV		MANGLE(DepthRangedNV)
#define glDepthRange		MANGLE(DepthRange)
#define glDetachObjectARB		MANGLE(DetachObjectARB)
#define glDetachShader		MANGLE(DetachShader)
#define glDetailTexFuncSGIS		MANGLE(DetailTexFuncSGIS)
#define glDisableClientStateIndexedEXT		MANGLE(DisableClientStateIndexedEXT)
#define glDisableClientState		MANGLE(DisableClientState)
#define glDisablei		MANGLE(Disablei)
#define glDisableIndexedEXT		MANGLE(DisableIndexedEXT)
#define glDisable		MANGLE(Disable)
#define glDisableVariantClientStateEXT		MANGLE(DisableVariantClientStateEXT)
#define glDisableVertexAttribAPPLE		MANGLE(DisableVertexAttribAPPLE)
#define glDisableVertexAttribArrayARB		MANGLE(DisableVertexAttribArrayARB)
#define glDisableVertexAttribArray		MANGLE(DisableVertexAttribArray)
#define glDrawArraysEXT		MANGLE(DrawArraysEXT)
#define glDrawArraysInstancedARB		MANGLE(DrawArraysInstancedARB)
#define glDrawArraysInstancedEXT		MANGLE(DrawArraysInstancedEXT)
#define glDrawArraysInstanced		MANGLE(DrawArraysInstanced)
#define glDrawArrays		MANGLE(DrawArrays)
#define glDrawBuffer		MANGLE(DrawBuffer)
#define glDrawBuffersARB		MANGLE(DrawBuffersARB)
#define glDrawBuffersATI		MANGLE(DrawBuffersATI)
#define glDrawBuffers		MANGLE(DrawBuffers)
#define glDrawElementArrayAPPLE		MANGLE(DrawElementArrayAPPLE)
#define glDrawElementArrayATI		MANGLE(DrawElementArrayATI)
#define glDrawElementsBaseVertex		MANGLE(DrawElementsBaseVertex)
#define glDrawElementsInstancedARB		MANGLE(DrawElementsInstancedARB)
#define glDrawElementsInstancedBaseVertex		MANGLE(DrawElementsInstancedBaseVertex)
#define glDrawElementsInstancedEXT		MANGLE(DrawElementsInstancedEXT)
#define glDrawElementsInstanced		MANGLE(DrawElementsInstanced)
#define glDrawElements		MANGLE(DrawElements)
#define glDrawMeshArraysSUN		MANGLE(DrawMeshArraysSUN)
#define glDrawPixels		MANGLE(DrawPixels)
#define glDrawRangeElementArrayAPPLE		MANGLE(DrawRangeElementArrayAPPLE)
#define glDrawRangeElementArrayATI		MANGLE(DrawRangeElementArrayATI)
#define glDrawRangeElementsBaseVertex		MANGLE(DrawRangeElementsBaseVertex)
#define glDrawRangeElementsEXT		MANGLE(DrawRangeElementsEXT)
#define glDrawRangeElements		MANGLE(DrawRangeElements)
#define glDrawTransformFeedbackNV		MANGLE(DrawTransformFeedbackNV)
#define glEdgeFlagFormatNV		MANGLE(EdgeFlagFormatNV)
#define glEdgeFlag		MANGLE(EdgeFlag)
#define glEdgeFlagPointerEXT		MANGLE(EdgeFlagPointerEXT)
#define glEdgeFlagPointerListIBM		MANGLE(EdgeFlagPointerListIBM)
#define glEdgeFlagPointer		MANGLE(EdgeFlagPointer)
#define glEdgeFlagv		MANGLE(EdgeFlagv)
#define glElementPointerAPPLE		MANGLE(ElementPointerAPPLE)
#define glElementPointerATI		MANGLE(ElementPointerATI)
#define glEnableClientStateIndexedEXT		MANGLE(EnableClientStateIndexedEXT)
#define glEnableClientState		MANGLE(EnableClientState)
#define glEnablei		MANGLE(Enablei)
#define glEnableIndexedEXT		MANGLE(EnableIndexedEXT)
#define glEnable		MANGLE(Enable)
#define glEnableVariantClientStateEXT		MANGLE(EnableVariantClientStateEXT)
#define glEnableVertexAttribAPPLE		MANGLE(EnableVertexAttribAPPLE)
#define glEnableVertexAttribArrayARB		MANGLE(EnableVertexAttribArrayARB)
#define glEnableVertexAttribArray		MANGLE(EnableVertexAttribArray)
#define glEndConditionalRender		MANGLE(EndConditionalRender)
#define glEndConditionalRenderNV		MANGLE(EndConditionalRenderNV)
#define glEndFragmentShaderATI		MANGLE(EndFragmentShaderATI)
#define glEndList		MANGLE(EndList)
#define glEnd		MANGLE(End)
#define glEndOcclusionQueryNV		MANGLE(EndOcclusionQueryNV)
#define glEndPerfMonitorAMD		MANGLE(EndPerfMonitorAMD)
#define glEndQueryARB		MANGLE(EndQueryARB)
#define glEndQuery		MANGLE(EndQuery)
#define glEndTransformFeedbackEXT		MANGLE(EndTransformFeedbackEXT)
#define glEndTransformFeedback		MANGLE(EndTransformFeedback)
#define glEndTransformFeedbackNV		MANGLE(EndTransformFeedbackNV)
#define glEndVertexShaderEXT		MANGLE(EndVertexShaderEXT)
#define glEndVideoCaptureNV		MANGLE(EndVideoCaptureNV)
#define glEvalCoord1d		MANGLE(EvalCoord1d)
#define glEvalCoord1dv		MANGLE(EvalCoord1dv)
#define glEvalCoord1f		MANGLE(EvalCoord1f)
#define glEvalCoord1fv		MANGLE(EvalCoord1fv)
#define glEvalCoord2d		MANGLE(EvalCoord2d)
#define glEvalCoord2dv		MANGLE(EvalCoord2dv)
#define glEvalCoord2f		MANGLE(EvalCoord2f)
#define glEvalCoord2fv		MANGLE(EvalCoord2fv)
#define glEvalMapsNV		MANGLE(EvalMapsNV)
#define glEvalMesh1		MANGLE(EvalMesh1)
#define glEvalMesh2		MANGLE(EvalMesh2)
#define glEvalPoint1		MANGLE(EvalPoint1)
#define glEvalPoint2		MANGLE(EvalPoint2)
#define glExecuteProgramNV		MANGLE(ExecuteProgramNV)
#define glExtractComponentEXT		MANGLE(ExtractComponentEXT)
#define glFeedbackBuffer		MANGLE(FeedbackBuffer)
#define glFenceSync		MANGLE(FenceSync)
#define glFinalCombinerInputNV		MANGLE(FinalCombinerInputNV)
#define glFinishAsyncSGIX		MANGLE(FinishAsyncSGIX)
#define glFinishFenceAPPLE		MANGLE(FinishFenceAPPLE)
#define glFinishFenceNV		MANGLE(FinishFenceNV)
#define glFinish		MANGLE(Finish)
#define glFinishObjectAPPLE		MANGLE(FinishObjectAPPLE)
#define glFinishTextureSUNX		MANGLE(FinishTextureSUNX)
#define glFlush		MANGLE(Flush)
#define glFlushMappedBufferRangeAPPLE		MANGLE(FlushMappedBufferRangeAPPLE)
#define glFlushMappedBufferRange		MANGLE(FlushMappedBufferRange)
#define glFlushPixelDataRangeNV		MANGLE(FlushPixelDataRangeNV)
#define glFlushRasterSGIX		MANGLE(FlushRasterSGIX)
#define glFlushVertexArrayRangeAPPLE		MANGLE(FlushVertexArrayRangeAPPLE)
#define glFlushVertexArrayRangeNV		MANGLE(FlushVertexArrayRangeNV)
#define glFogCoorddEXT		MANGLE(FogCoorddEXT)
#define glFogCoordd		MANGLE(FogCoordd)
#define glFogCoorddvEXT		MANGLE(FogCoorddvEXT)
#define glFogCoorddv		MANGLE(FogCoorddv)
#define glFogCoordfEXT		MANGLE(FogCoordfEXT)
#define glFogCoordf		MANGLE(FogCoordf)
#define glFogCoordFormatNV		MANGLE(FogCoordFormatNV)
#define glFogCoordfvEXT		MANGLE(FogCoordfvEXT)
#define glFogCoordfv		MANGLE(FogCoordfv)
#define glFogCoordhNV		MANGLE(FogCoordhNV)
#define glFogCoordhvNV		MANGLE(FogCoordhvNV)
#define glFogCoordPointerEXT		MANGLE(FogCoordPointerEXT)
#define glFogCoordPointerListIBM		MANGLE(FogCoordPointerListIBM)
#define glFogCoordPointer		MANGLE(FogCoordPointer)
#define glFogf		MANGLE(Fogf)
#define glFogFuncSGIS		MANGLE(FogFuncSGIS)
#define glFogfv		MANGLE(Fogfv)
#define glFogi		MANGLE(Fogi)
#define glFogiv		MANGLE(Fogiv)
#define glFragmentColorMaterialSGIX		MANGLE(FragmentColorMaterialSGIX)
#define glFragmentLightfSGIX		MANGLE(FragmentLightfSGIX)
#define glFragmentLightfvSGIX		MANGLE(FragmentLightfvSGIX)
#define glFragmentLightiSGIX		MANGLE(FragmentLightiSGIX)
#define glFragmentLightivSGIX		MANGLE(FragmentLightivSGIX)
#define glFragmentLightModelfSGIX		MANGLE(FragmentLightModelfSGIX)
#define glFragmentLightModelfvSGIX		MANGLE(FragmentLightModelfvSGIX)
#define glFragmentLightModeliSGIX		MANGLE(FragmentLightModeliSGIX)
#define glFragmentLightModelivSGIX		MANGLE(FragmentLightModelivSGIX)
#define glFragmentMaterialfSGIX		MANGLE(FragmentMaterialfSGIX)
#define glFragmentMaterialfvSGIX		MANGLE(FragmentMaterialfvSGIX)
#define glFragmentMaterialiSGIX		MANGLE(FragmentMaterialiSGIX)
#define glFragmentMaterialivSGIX		MANGLE(FragmentMaterialivSGIX)
#define glFramebufferDrawBufferEXT		MANGLE(FramebufferDrawBufferEXT)
#define glFramebufferDrawBuffersEXT		MANGLE(FramebufferDrawBuffersEXT)
#define glFramebufferReadBufferEXT		MANGLE(FramebufferReadBufferEXT)
#define glFramebufferRenderbufferEXT		MANGLE(FramebufferRenderbufferEXT)
#define glFramebufferRenderbuffer		MANGLE(FramebufferRenderbuffer)
#define glFramebufferTexture1DEXT		MANGLE(FramebufferTexture1DEXT)
#define glFramebufferTexture1D		MANGLE(FramebufferTexture1D)
#define glFramebufferTexture2DEXT		MANGLE(FramebufferTexture2DEXT)
#define glFramebufferTexture2D		MANGLE(FramebufferTexture2D)
#define glFramebufferTexture3DEXT		MANGLE(FramebufferTexture3DEXT)
#define glFramebufferTexture3D		MANGLE(FramebufferTexture3D)
#define glFramebufferTextureARB		MANGLE(FramebufferTextureARB)
#define glFramebufferTextureEXT		MANGLE(FramebufferTextureEXT)
#define glFramebufferTextureFaceARB		MANGLE(FramebufferTextureFaceARB)
#define glFramebufferTextureFaceEXT		MANGLE(FramebufferTextureFaceEXT)
#define glFramebufferTextureFace		MANGLE(FramebufferTextureFace)
#define glFramebufferTextureLayerARB		MANGLE(FramebufferTextureLayerARB)
#define glFramebufferTextureLayerEXT		MANGLE(FramebufferTextureLayerEXT)
#define glFramebufferTextureLayer		MANGLE(FramebufferTextureLayer)
#define glFramebufferTexture		MANGLE(FramebufferTexture)
#define glFrameTerminatorGREMEDY		MANGLE(FrameTerminatorGREMEDY)
#define glFrameZoomSGIX		MANGLE(FrameZoomSGIX)
#define glFreeObjectBufferATI		MANGLE(FreeObjectBufferATI)
#define glFrontFace		MANGLE(FrontFace)
#define glFrustum		MANGLE(Frustum)
#define glGenAsyncMarkersSGIX		MANGLE(GenAsyncMarkersSGIX)
#define glGenBuffersARB		MANGLE(GenBuffersARB)
#define glGenBuffers		MANGLE(GenBuffers)
#define glGenerateMipmapEXT		MANGLE(GenerateMipmapEXT)
#define glGenerateMipmap		MANGLE(GenerateMipmap)
#define glGenerateMultiTexMipmapEXT		MANGLE(GenerateMultiTexMipmapEXT)
#define glGenerateTextureMipmapEXT		MANGLE(GenerateTextureMipmapEXT)
#define glGenFencesAPPLE		MANGLE(GenFencesAPPLE)
#define glGenFencesNV		MANGLE(GenFencesNV)
#define glGenFragmentShadersATI		MANGLE(GenFragmentShadersATI)
#define glGenFramebuffersEXT		MANGLE(GenFramebuffersEXT)
#define glGenFramebuffers		MANGLE(GenFramebuffers)
#define glGenLists		MANGLE(GenLists)
#define glGenOcclusionQueriesNV		MANGLE(GenOcclusionQueriesNV)
#define glGenPerfMonitorsAMD		MANGLE(GenPerfMonitorsAMD)
#define glGenProgramsARB		MANGLE(GenProgramsARB)
#define glGenProgramsNV		MANGLE(GenProgramsNV)
#define glGenQueriesARB		MANGLE(GenQueriesARB)
#define glGenQueries		MANGLE(GenQueries)
#define glGenRenderbuffersEXT		MANGLE(GenRenderbuffersEXT)
#define glGenRenderbuffers		MANGLE(GenRenderbuffers)
#define glGenSymbolsEXT		MANGLE(GenSymbolsEXT)
#define glGenTexturesEXT		MANGLE(GenTexturesEXT)
#define glGenTextures		MANGLE(GenTextures)
#define glGenTransformFeedbacksNV		MANGLE(GenTransformFeedbacksNV)
#define glGenVertexArraysAPPLE		MANGLE(GenVertexArraysAPPLE)
#define glGenVertexArrays		MANGLE(GenVertexArrays)
#define glGenVertexShadersEXT		MANGLE(GenVertexShadersEXT)
#define glGetActiveAttribARB		MANGLE(GetActiveAttribARB)
#define glGetActiveAttrib		MANGLE(GetActiveAttrib)
#define glGetActiveUniformARB		MANGLE(GetActiveUniformARB)
#define glGetActiveUniformBlockiv		MANGLE(GetActiveUniformBlockiv)
#define glGetActiveUniformBlockName		MANGLE(GetActiveUniformBlockName)
#define glGetActiveUniform		MANGLE(GetActiveUniform)
#define glGetActiveUniformName		MANGLE(GetActiveUniformName)
#define glGetActiveUniformsiv		MANGLE(GetActiveUniformsiv)
#define glGetActiveVaryingNV		MANGLE(GetActiveVaryingNV)
#define glGetArrayObjectfvATI		MANGLE(GetArrayObjectfvATI)
#define glGetArrayObjectivATI		MANGLE(GetArrayObjectivATI)
#define glGetAttachedObjectsARB		MANGLE(GetAttachedObjectsARB)
#define glGetAttachedShaders		MANGLE(GetAttachedShaders)
#define glGetAttribLocationARB		MANGLE(GetAttribLocationARB)
#define glGetAttribLocation		MANGLE(GetAttribLocation)
#define glGetBooleanIndexedvEXT		MANGLE(GetBooleanIndexedvEXT)
#define glGetBooleani_v		MANGLE(GetBooleani_v)
#define glGetBooleanv		MANGLE(GetBooleanv)
#define glGetBufferParameteri64v		MANGLE(GetBufferParameteri64v)
#define glGetBufferParameterivARB		MANGLE(GetBufferParameterivARB)
#define glGetBufferParameteriv		MANGLE(GetBufferParameteriv)
#define glGetBufferParameterui64vNV		MANGLE(GetBufferParameterui64vNV)
#define glGetBufferPointervARB		MANGLE(GetBufferPointervARB)
#define glGetBufferPointerv		MANGLE(GetBufferPointerv)
#define glGetBufferSubDataARB		MANGLE(GetBufferSubDataARB)
#define glGetBufferSubData		MANGLE(GetBufferSubData)
#define glGetClipPlane		MANGLE(GetClipPlane)
#define glGetColorTableEXT		MANGLE(GetColorTableEXT)
#define glGetColorTable		MANGLE(GetColorTable)
#define glGetColorTableParameterfvEXT		MANGLE(GetColorTableParameterfvEXT)
#define glGetColorTableParameterfv		MANGLE(GetColorTableParameterfv)
#define glGetColorTableParameterfvSGI		MANGLE(GetColorTableParameterfvSGI)
#define glGetColorTableParameterivEXT		MANGLE(GetColorTableParameterivEXT)
#define glGetColorTableParameteriv		MANGLE(GetColorTableParameteriv)
#define glGetColorTableParameterivSGI		MANGLE(GetColorTableParameterivSGI)
#define glGetColorTableSGI		MANGLE(GetColorTableSGI)
#define glGetCombinerInputParameterfvNV		MANGLE(GetCombinerInputParameterfvNV)
#define glGetCombinerInputParameterivNV		MANGLE(GetCombinerInputParameterivNV)
#define glGetCombinerOutputParameterfvNV		MANGLE(GetCombinerOutputParameterfvNV)
#define glGetCombinerOutputParameterivNV		MANGLE(GetCombinerOutputParameterivNV)
#define glGetCombinerStageParameterfvNV		MANGLE(GetCombinerStageParameterfvNV)
#define glGetCompressedMultiTexImageEXT		MANGLE(GetCompressedMultiTexImageEXT)
#define glGetCompressedTexImageARB		MANGLE(GetCompressedTexImageARB)
#define glGetCompressedTexImage		MANGLE(GetCompressedTexImage)
#define glGetCompressedTextureImageEXT		MANGLE(GetCompressedTextureImageEXT)
#define glGetConvolutionFilterEXT		MANGLE(GetConvolutionFilterEXT)
#define glGetConvolutionFilter		MANGLE(GetConvolutionFilter)
#define glGetConvolutionParameterfvEXT		MANGLE(GetConvolutionParameterfvEXT)
#define glGetConvolutionParameterfv		MANGLE(GetConvolutionParameterfv)
#define glGetConvolutionParameterivEXT		MANGLE(GetConvolutionParameterivEXT)
#define glGetConvolutionParameteriv		MANGLE(GetConvolutionParameteriv)
#define glGetDebugLogLengthMESA		MANGLE(GetDebugLogLengthMESA)
#define glGetDebugLogMESA		MANGLE(GetDebugLogMESA)
#define glGetDetailTexFuncSGIS		MANGLE(GetDetailTexFuncSGIS)
#define glGetDoubleIndexedvEXT		MANGLE(GetDoubleIndexedvEXT)
#define glGetDoublev		MANGLE(GetDoublev)
#define glGetError		MANGLE(GetError)
#define glGetFenceivNV		MANGLE(GetFenceivNV)
#define glGetFinalCombinerInputParameterfvNV		MANGLE(GetFinalCombinerInputParameterfvNV)
#define glGetFinalCombinerInputParameterivNV		MANGLE(GetFinalCombinerInputParameterivNV)
#define glGetFloatIndexedvEXT		MANGLE(GetFloatIndexedvEXT)
#define glGetFloatv		MANGLE(GetFloatv)
#define glGetFogFuncSGIS		MANGLE(GetFogFuncSGIS)
#define glGetFragDataLocationEXT		MANGLE(GetFragDataLocationEXT)
#define glGetFragDataLocation		MANGLE(GetFragDataLocation)
#define glGetFragmentLightfvSGIX		MANGLE(GetFragmentLightfvSGIX)
#define glGetFragmentLightivSGIX		MANGLE(GetFragmentLightivSGIX)
#define glGetFragmentMaterialfvSGIX		MANGLE(GetFragmentMaterialfvSGIX)
#define glGetFragmentMaterialivSGIX		MANGLE(GetFragmentMaterialivSGIX)
#define glGetFramebufferAttachmentParameterivEXT		MANGLE(GetFramebufferAttachmentParameterivEXT)
#define glGetFramebufferAttachmentParameteriv		MANGLE(GetFramebufferAttachmentParameteriv)
#define glGetFramebufferParameterivEXT		MANGLE(GetFramebufferParameterivEXT)
#define glGetHandleARB		MANGLE(GetHandleARB)
#define glGetHistogramEXT		MANGLE(GetHistogramEXT)
#define glGetHistogram		MANGLE(GetHistogram)
#define glGetHistogramParameterfvEXT		MANGLE(GetHistogramParameterfvEXT)
#define glGetHistogramParameterfv		MANGLE(GetHistogramParameterfv)
#define glGetHistogramParameterivEXT		MANGLE(GetHistogramParameterivEXT)
#define glGetHistogramParameteriv		MANGLE(GetHistogramParameteriv)
#define glGetImageTransformParameterfvHP		MANGLE(GetImageTransformParameterfvHP)
#define glGetImageTransformParameterivHP		MANGLE(GetImageTransformParameterivHP)
#define glGetInfoLogARB		MANGLE(GetInfoLogARB)
#define glGetInstrumentsSGIX		MANGLE(GetInstrumentsSGIX)
#define glGetInteger64i_v		MANGLE(GetInteger64i_v)
#define glGetInteger64v		MANGLE(GetInteger64v)
#define glGetIntegerIndexedvEXT		MANGLE(GetIntegerIndexedvEXT)
#define glGetIntegeri_v		MANGLE(GetIntegeri_v)
#define glGetIntegerui64i_vNV		MANGLE(GetIntegerui64i_vNV)
#define glGetIntegerui64vNV		MANGLE(GetIntegerui64vNV)
#define glGetIntegerv		MANGLE(GetIntegerv)
#define glGetInvariantBooleanvEXT		MANGLE(GetInvariantBooleanvEXT)
#define glGetInvariantFloatvEXT		MANGLE(GetInvariantFloatvEXT)
#define glGetInvariantIntegervEXT		MANGLE(GetInvariantIntegervEXT)
#define glGetLightfv		MANGLE(GetLightfv)
#define glGetLightiv		MANGLE(GetLightiv)
#define glGetListParameterfvSGIX		MANGLE(GetListParameterfvSGIX)
#define glGetListParameterivSGIX		MANGLE(GetListParameterivSGIX)
#define glGetLocalConstantBooleanvEXT		MANGLE(GetLocalConstantBooleanvEXT)
#define glGetLocalConstantFloatvEXT		MANGLE(GetLocalConstantFloatvEXT)
#define glGetLocalConstantIntegervEXT		MANGLE(GetLocalConstantIntegervEXT)
#define glGetMapAttribParameterfvNV		MANGLE(GetMapAttribParameterfvNV)
#define glGetMapAttribParameterivNV		MANGLE(GetMapAttribParameterivNV)
#define glGetMapControlPointsNV		MANGLE(GetMapControlPointsNV)
#define glGetMapdv		MANGLE(GetMapdv)
#define glGetMapfv		MANGLE(GetMapfv)
#define glGetMapiv		MANGLE(GetMapiv)
#define glGetMapParameterfvNV		MANGLE(GetMapParameterfvNV)
#define glGetMapParameterivNV		MANGLE(GetMapParameterivNV)
#define glGetMaterialfv		MANGLE(GetMaterialfv)
#define glGetMaterialiv		MANGLE(GetMaterialiv)
#define glGetMinmaxEXT		MANGLE(GetMinmaxEXT)
#define glGetMinmax		MANGLE(GetMinmax)
#define glGetMinmaxParameterfvEXT		MANGLE(GetMinmaxParameterfvEXT)
#define glGetMinmaxParameterfv		MANGLE(GetMinmaxParameterfv)
#define glGetMinmaxParameterivEXT		MANGLE(GetMinmaxParameterivEXT)
#define glGetMinmaxParameteriv		MANGLE(GetMinmaxParameteriv)
#define glGetMultisamplefv		MANGLE(GetMultisamplefv)
#define glGetMultisamplefvNV		MANGLE(GetMultisamplefvNV)
#define glGetMultiTexEnvfvEXT		MANGLE(GetMultiTexEnvfvEXT)
#define glGetMultiTexEnvivEXT		MANGLE(GetMultiTexEnvivEXT)
#define glGetMultiTexGendvEXT		MANGLE(GetMultiTexGendvEXT)
#define glGetMultiTexGenfvEXT		MANGLE(GetMultiTexGenfvEXT)
#define glGetMultiTexGenivEXT		MANGLE(GetMultiTexGenivEXT)
#define glGetMultiTexImageEXT		MANGLE(GetMultiTexImageEXT)
#define glGetMultiTexLevelParameterfvEXT		MANGLE(GetMultiTexLevelParameterfvEXT)
#define glGetMultiTexLevelParameterivEXT		MANGLE(GetMultiTexLevelParameterivEXT)
#define glGetMultiTexParameterfvEXT		MANGLE(GetMultiTexParameterfvEXT)
#define glGetMultiTexParameterIivEXT		MANGLE(GetMultiTexParameterIivEXT)
#define glGetMultiTexParameterIuivEXT		MANGLE(GetMultiTexParameterIuivEXT)
#define glGetMultiTexParameterivEXT		MANGLE(GetMultiTexParameterivEXT)
#define glGetNamedBufferParameterivEXT		MANGLE(GetNamedBufferParameterivEXT)
#define glGetNamedBufferParameterui64vNV		MANGLE(GetNamedBufferParameterui64vNV)
#define glGetNamedBufferPointervEXT		MANGLE(GetNamedBufferPointervEXT)
#define glGetNamedBufferSubDataEXT		MANGLE(GetNamedBufferSubDataEXT)
#define glGetNamedFramebufferAttachmentParameterivEXT		MANGLE(GetNamedFramebufferAttachmentParameterivEXT)
#define glGetNamedProgramivEXT		MANGLE(GetNamedProgramivEXT)
#define glGetNamedProgramLocalParameterdvEXT		MANGLE(GetNamedProgramLocalParameterdvEXT)
#define glGetNamedProgramLocalParameterfvEXT		MANGLE(GetNamedProgramLocalParameterfvEXT)
#define glGetNamedProgramLocalParameterIivEXT		MANGLE(GetNamedProgramLocalParameterIivEXT)
#define glGetNamedProgramLocalParameterIuivEXT		MANGLE(GetNamedProgramLocalParameterIuivEXT)
#define glGetNamedProgramStringEXT		MANGLE(GetNamedProgramStringEXT)
#define glGetNamedRenderbufferParameterivEXT		MANGLE(GetNamedRenderbufferParameterivEXT)
#define glGetObjectBufferfvATI		MANGLE(GetObjectBufferfvATI)
#define glGetObjectBufferivATI		MANGLE(GetObjectBufferivATI)
#define glGetObjectParameterfvARB		MANGLE(GetObjectParameterfvARB)
#define glGetObjectParameterivAPPLE		MANGLE(GetObjectParameterivAPPLE)
#define glGetObjectParameterivARB		MANGLE(GetObjectParameterivARB)
#define glGetOcclusionQueryivNV		MANGLE(GetOcclusionQueryivNV)
#define glGetOcclusionQueryuivNV		MANGLE(GetOcclusionQueryuivNV)
#define glGetPerfMonitorCounterDataAMD		MANGLE(GetPerfMonitorCounterDataAMD)
#define glGetPerfMonitorCounterInfoAMD		MANGLE(GetPerfMonitorCounterInfoAMD)
#define glGetPerfMonitorCountersAMD		MANGLE(GetPerfMonitorCountersAMD)
#define glGetPerfMonitorCounterStringAMD		MANGLE(GetPerfMonitorCounterStringAMD)
#define glGetPerfMonitorGroupsAMD		MANGLE(GetPerfMonitorGroupsAMD)
#define glGetPerfMonitorGroupStringAMD		MANGLE(GetPerfMonitorGroupStringAMD)
#define glGetPixelMapfv		MANGLE(GetPixelMapfv)
#define glGetPixelMapuiv		MANGLE(GetPixelMapuiv)
#define glGetPixelMapusv		MANGLE(GetPixelMapusv)
#define glGetPixelTexGenParameterfvSGIS		MANGLE(GetPixelTexGenParameterfvSGIS)
#define glGetPixelTexGenParameterivSGIS		MANGLE(GetPixelTexGenParameterivSGIS)
#define glGetPointerIndexedvEXT		MANGLE(GetPointerIndexedvEXT)
#define glGetPointervEXT		MANGLE(GetPointervEXT)
#define glGetPointerv		MANGLE(GetPointerv)
#define glGetPolygonStipple		MANGLE(GetPolygonStipple)
#define glGetProgramEnvParameterdvARB		MANGLE(GetProgramEnvParameterdvARB)
#define glGetProgramEnvParameterfvARB		MANGLE(GetProgramEnvParameterfvARB)
#define glGetProgramEnvParameterIivNV		MANGLE(GetProgramEnvParameterIivNV)
#define glGetProgramEnvParameterIuivNV		MANGLE(GetProgramEnvParameterIuivNV)
#define glGetProgramInfoLog		MANGLE(GetProgramInfoLog)
#define glGetProgramivARB		MANGLE(GetProgramivARB)
#define glGetProgramiv		MANGLE(GetProgramiv)
#define glGetProgramivNV		MANGLE(GetProgramivNV)
#define glGetProgramLocalParameterdvARB		MANGLE(GetProgramLocalParameterdvARB)
#define glGetProgramLocalParameterfvARB		MANGLE(GetProgramLocalParameterfvARB)
#define glGetProgramLocalParameterIivNV		MANGLE(GetProgramLocalParameterIivNV)
#define glGetProgramLocalParameterIuivNV		MANGLE(GetProgramLocalParameterIuivNV)
#define glGetProgramNamedParameterdvNV		MANGLE(GetProgramNamedParameterdvNV)
#define glGetProgramNamedParameterfvNV		MANGLE(GetProgramNamedParameterfvNV)
#define glGetProgramParameterdvNV		MANGLE(GetProgramParameterdvNV)
#define glGetProgramParameterfvNV		MANGLE(GetProgramParameterfvNV)
#define glGetProgramRegisterfvMESA		MANGLE(GetProgramRegisterfvMESA)
#define glGetProgramStringARB		MANGLE(GetProgramStringARB)
#define glGetProgramStringNV		MANGLE(GetProgramStringNV)
#define glGetQueryivARB		MANGLE(GetQueryivARB)
#define glGetQueryiv		MANGLE(GetQueryiv)
#define glGetQueryObjecti64vEXT		MANGLE(GetQueryObjecti64vEXT)
#define glGetQueryObjectivARB		MANGLE(GetQueryObjectivARB)
#define glGetQueryObjectiv		MANGLE(GetQueryObjectiv)
#define glGetQueryObjectui64vEXT		MANGLE(GetQueryObjectui64vEXT)
#define glGetQueryObjectuivARB		MANGLE(GetQueryObjectuivARB)
#define glGetQueryObjectuiv		MANGLE(GetQueryObjectuiv)
#define glGetRenderbufferParameterivEXT		MANGLE(GetRenderbufferParameterivEXT)
#define glGetRenderbufferParameteriv		MANGLE(GetRenderbufferParameteriv)
#define glGetSeparableFilterEXT		MANGLE(GetSeparableFilterEXT)
#define glGetSeparableFilter		MANGLE(GetSeparableFilter)
#define glGetShaderInfoLog		MANGLE(GetShaderInfoLog)
#define glGetShaderiv		MANGLE(GetShaderiv)
#define glGetShaderSourceARB		MANGLE(GetShaderSourceARB)
#define glGetShaderSource		MANGLE(GetShaderSource)
#define glGetSharpenTexFuncSGIS		MANGLE(GetSharpenTexFuncSGIS)
#define glGetStringi		MANGLE(GetStringi)
#define glGetString		MANGLE(GetString)
#define glGetSynciv		MANGLE(GetSynciv)
#define glGetTexBumpParameterfvATI		MANGLE(GetTexBumpParameterfvATI)
#define glGetTexBumpParameterivATI		MANGLE(GetTexBumpParameterivATI)
#define glGetTexEnvfv		MANGLE(GetTexEnvfv)
#define glGetTexEnviv		MANGLE(GetTexEnviv)
#define glGetTexFilterFuncSGIS		MANGLE(GetTexFilterFuncSGIS)
#define glGetTexGendv		MANGLE(GetTexGendv)
#define glGetTexGenfv		MANGLE(GetTexGenfv)
#define glGetTexGeniv		MANGLE(GetTexGeniv)
#define glGetTexImage		MANGLE(GetTexImage)
#define glGetTexLevelParameterfv		MANGLE(GetTexLevelParameterfv)
#define glGetTexLevelParameteriv		MANGLE(GetTexLevelParameteriv)
#define glGetTexParameterfv		MANGLE(GetTexParameterfv)
#define glGetTexParameterIivEXT		MANGLE(GetTexParameterIivEXT)
#define glGetTexParameterIiv		MANGLE(GetTexParameterIiv)
#define glGetTexParameterIuivEXT		MANGLE(GetTexParameterIuivEXT)
#define glGetTexParameterIuiv		MANGLE(GetTexParameterIuiv)
#define glGetTexParameteriv		MANGLE(GetTexParameteriv)
#define glGetTexParameterPointervAPPLE		MANGLE(GetTexParameterPointervAPPLE)
#define glGetTextureImageEXT		MANGLE(GetTextureImageEXT)
#define glGetTextureLevelParameterfvEXT		MANGLE(GetTextureLevelParameterfvEXT)
#define glGetTextureLevelParameterivEXT		MANGLE(GetTextureLevelParameterivEXT)
#define glGetTextureParameterfvEXT		MANGLE(GetTextureParameterfvEXT)
#define glGetTextureParameterIivEXT		MANGLE(GetTextureParameterIivEXT)
#define glGetTextureParameterIuivEXT		MANGLE(GetTextureParameterIuivEXT)
#define glGetTextureParameterivEXT		MANGLE(GetTextureParameterivEXT)
#define glGetTrackMatrixivNV		MANGLE(GetTrackMatrixivNV)
#define glGetTransformFeedbackVaryingEXT		MANGLE(GetTransformFeedbackVaryingEXT)
#define glGetTransformFeedbackVarying		MANGLE(GetTransformFeedbackVarying)
#define glGetTransformFeedbackVaryingNV		MANGLE(GetTransformFeedbackVaryingNV)
#define glGetUniformBlockIndex		MANGLE(GetUniformBlockIndex)
#define glGetUniformBufferSizeEXT		MANGLE(GetUniformBufferSizeEXT)
#define glGetUniformfvARB		MANGLE(GetUniformfvARB)
#define glGetUniformfv		MANGLE(GetUniformfv)
#define glGetUniformIndices		MANGLE(GetUniformIndices)
#define glGetUniformivARB		MANGLE(GetUniformivARB)
#define glGetUniformiv		MANGLE(GetUniformiv)
#define glGetUniformLocationARB		MANGLE(GetUniformLocationARB)
#define glGetUniformLocation		MANGLE(GetUniformLocation)
#define glGetUniformOffsetEXT		MANGLE(GetUniformOffsetEXT)
#define glGetUniformui64vNV		MANGLE(GetUniformui64vNV)
#define glGetUniformuivEXT		MANGLE(GetUniformuivEXT)
#define glGetUniformuiv		MANGLE(GetUniformuiv)
#define glGetVariantArrayObjectfvATI		MANGLE(GetVariantArrayObjectfvATI)
#define glGetVariantArrayObjectivATI		MANGLE(GetVariantArrayObjectivATI)
#define glGetVariantBooleanvEXT		MANGLE(GetVariantBooleanvEXT)
#define glGetVariantFloatvEXT		MANGLE(GetVariantFloatvEXT)
#define glGetVariantIntegervEXT		MANGLE(GetVariantIntegervEXT)
#define glGetVariantPointervEXT		MANGLE(GetVariantPointervEXT)
#define glGetVaryingLocationNV		MANGLE(GetVaryingLocationNV)
#define glGetVertexAttribArrayObjectfvATI		MANGLE(GetVertexAttribArrayObjectfvATI)
#define glGetVertexAttribArrayObjectivATI		MANGLE(GetVertexAttribArrayObjectivATI)
#define glGetVertexAttribdvARB		MANGLE(GetVertexAttribdvARB)
#define glGetVertexAttribdv		MANGLE(GetVertexAttribdv)
#define glGetVertexAttribdvNV		MANGLE(GetVertexAttribdvNV)
#define glGetVertexAttribfvARB		MANGLE(GetVertexAttribfvARB)
#define glGetVertexAttribfv		MANGLE(GetVertexAttribfv)
#define glGetVertexAttribfvNV		MANGLE(GetVertexAttribfvNV)
#define glGetVertexAttribIivEXT		MANGLE(GetVertexAttribIivEXT)
#define glGetVertexAttribIiv		MANGLE(GetVertexAttribIiv)
#define glGetVertexAttribIuivEXT		MANGLE(GetVertexAttribIuivEXT)
#define glGetVertexAttribIuiv		MANGLE(GetVertexAttribIuiv)
#define glGetVertexAttribivARB		MANGLE(GetVertexAttribivARB)
#define glGetVertexAttribiv		MANGLE(GetVertexAttribiv)
#define glGetVertexAttribivNV		MANGLE(GetVertexAttribivNV)
#define glGetVertexAttribPointervARB		MANGLE(GetVertexAttribPointervARB)
#define glGetVertexAttribPointerv		MANGLE(GetVertexAttribPointerv)
#define glGetVertexAttribPointervNV		MANGLE(GetVertexAttribPointervNV)
#define glGetVideoCaptureivNV		MANGLE(GetVideoCaptureivNV)
#define glGetVideoCaptureStreamdvNV		MANGLE(GetVideoCaptureStreamdvNV)
#define glGetVideoCaptureStreamfvNV		MANGLE(GetVideoCaptureStreamfvNV)
#define glGetVideoCaptureStreamivNV		MANGLE(GetVideoCaptureStreamivNV)
#define glGetVideoi64vNV		MANGLE(GetVideoi64vNV)
#define glGetVideoivNV		MANGLE(GetVideoivNV)
#define glGetVideoui64vNV		MANGLE(GetVideoui64vNV)
#define glGetVideouivNV		MANGLE(GetVideouivNV)
#define glGlobalAlphaFactorbSUN		MANGLE(GlobalAlphaFactorbSUN)
#define glGlobalAlphaFactordSUN		MANGLE(GlobalAlphaFactordSUN)
#define glGlobalAlphaFactorfSUN		MANGLE(GlobalAlphaFactorfSUN)
#define glGlobalAlphaFactoriSUN		MANGLE(GlobalAlphaFactoriSUN)
#define glGlobalAlphaFactorsSUN		MANGLE(GlobalAlphaFactorsSUN)
#define glGlobalAlphaFactorubSUN		MANGLE(GlobalAlphaFactorubSUN)
#define glGlobalAlphaFactoruiSUN		MANGLE(GlobalAlphaFactoruiSUN)
#define glGlobalAlphaFactorusSUN		MANGLE(GlobalAlphaFactorusSUN)
#define glHint		MANGLE(Hint)
#define glHintPGI		MANGLE(HintPGI)
#define glHistogramEXT		MANGLE(HistogramEXT)
#define glHistogram		MANGLE(Histogram)
#define glIglooInterfaceSGIX		MANGLE(IglooInterfaceSGIX)
#define glImageTransformParameterfHP		MANGLE(ImageTransformParameterfHP)
#define glImageTransformParameterfvHP		MANGLE(ImageTransformParameterfvHP)
#define glImageTransformParameteriHP		MANGLE(ImageTransformParameteriHP)
#define glImageTransformParameterivHP		MANGLE(ImageTransformParameterivHP)
#define glIndexd		MANGLE(Indexd)
#define glIndexdv		MANGLE(Indexdv)
#define glIndexf		MANGLE(Indexf)
#define glIndexFormatNV		MANGLE(IndexFormatNV)
#define glIndexFuncEXT		MANGLE(IndexFuncEXT)
#define glIndexfv		MANGLE(Indexfv)
#define glIndexi		MANGLE(Indexi)
#define glIndexiv		MANGLE(Indexiv)
#define glIndexMask		MANGLE(IndexMask)
#define glIndexMaterialEXT		MANGLE(IndexMaterialEXT)
#define glIndexPointerEXT		MANGLE(IndexPointerEXT)
#define glIndexPointerListIBM		MANGLE(IndexPointerListIBM)
#define glIndexPointer		MANGLE(IndexPointer)
#define glIndexs		MANGLE(Indexs)
#define glIndexsv		MANGLE(Indexsv)
#define glIndexub		MANGLE(Indexub)
#define glIndexubv		MANGLE(Indexubv)
#define glInitNames		MANGLE(InitNames)
#define glInsertComponentEXT		MANGLE(InsertComponentEXT)
#define glInstrumentsBufferSGIX		MANGLE(InstrumentsBufferSGIX)
#define glInterleavedArrays		MANGLE(InterleavedArrays)
#define glIsAsyncMarkerSGIX		MANGLE(IsAsyncMarkerSGIX)
#define glIsBufferARB		MANGLE(IsBufferARB)
#define glIsBuffer		MANGLE(IsBuffer)
#define glIsBufferResidentNV		MANGLE(IsBufferResidentNV)
#define glIsEnabledi		MANGLE(IsEnabledi)
#define glIsEnabledIndexedEXT		MANGLE(IsEnabledIndexedEXT)
#define glIsEnabled		MANGLE(IsEnabled)
#define glIsFenceAPPLE		MANGLE(IsFenceAPPLE)
#define glIsFenceNV		MANGLE(IsFenceNV)
#define glIsFramebufferEXT		MANGLE(IsFramebufferEXT)
#define glIsFramebuffer		MANGLE(IsFramebuffer)
#define glIsList		MANGLE(IsList)
#define glIsNamedBufferResidentNV		MANGLE(IsNamedBufferResidentNV)
#define glIsObjectBufferATI		MANGLE(IsObjectBufferATI)
#define glIsOcclusionQueryNV		MANGLE(IsOcclusionQueryNV)
#define glIsProgramARB		MANGLE(IsProgramARB)
#define glIsProgram		MANGLE(IsProgram)
#define glIsProgramNV		MANGLE(IsProgramNV)
#define glIsQueryARB		MANGLE(IsQueryARB)
#define glIsQuery		MANGLE(IsQuery)
#define glIsRenderbufferEXT		MANGLE(IsRenderbufferEXT)
#define glIsRenderbuffer		MANGLE(IsRenderbuffer)
#define glIsShader		MANGLE(IsShader)
#define glIsSync		MANGLE(IsSync)
#define glIsTextureEXT		MANGLE(IsTextureEXT)
#define glIsTexture		MANGLE(IsTexture)
#define glIsTransformFeedbackNV		MANGLE(IsTransformFeedbackNV)
#define glIsVariantEnabledEXT		MANGLE(IsVariantEnabledEXT)
#define glIsVertexArrayAPPLE		MANGLE(IsVertexArrayAPPLE)
#define glIsVertexArray		MANGLE(IsVertexArray)
#define glIsVertexAttribEnabledAPPLE		MANGLE(IsVertexAttribEnabledAPPLE)
#define glLightEnviSGIX		MANGLE(LightEnviSGIX)
#define glLightf		MANGLE(Lightf)
#define glLightfv		MANGLE(Lightfv)
#define glLighti		MANGLE(Lighti)
#define glLightiv		MANGLE(Lightiv)
#define glLightModelf		MANGLE(LightModelf)
#define glLightModelfv		MANGLE(LightModelfv)
#define glLightModeli		MANGLE(LightModeli)
#define glLightModeliv		MANGLE(LightModeliv)
#define glLineStipple		MANGLE(LineStipple)
#define glLineWidth		MANGLE(LineWidth)
#define glLinkProgramARB		MANGLE(LinkProgramARB)
#define glLinkProgram		MANGLE(LinkProgram)
#define glListBase		MANGLE(ListBase)
#define glListParameterfSGIX		MANGLE(ListParameterfSGIX)
#define glListParameterfvSGIX		MANGLE(ListParameterfvSGIX)
#define glListParameteriSGIX		MANGLE(ListParameteriSGIX)
#define glListParameterivSGIX		MANGLE(ListParameterivSGIX)
#define glLoadIdentityDeformationMapSGIX		MANGLE(LoadIdentityDeformationMapSGIX)
#define glLoadIdentity		MANGLE(LoadIdentity)
#define glLoadMatrixd		MANGLE(LoadMatrixd)
#define glLoadMatrixf		MANGLE(LoadMatrixf)
#define glLoadName		MANGLE(LoadName)
#define glLoadProgramNV		MANGLE(LoadProgramNV)
#define glLoadTransposeMatrixdARB		MANGLE(LoadTransposeMatrixdARB)
#define glLoadTransposeMatrixd		MANGLE(LoadTransposeMatrixd)
#define glLoadTransposeMatrixfARB		MANGLE(LoadTransposeMatrixfARB)
#define glLoadTransposeMatrixf		MANGLE(LoadTransposeMatrixf)
#define glLockArraysEXT		MANGLE(LockArraysEXT)
#define glLogicOp		MANGLE(LogicOp)
#define glMakeBufferNonResidentNV		MANGLE(MakeBufferNonResidentNV)
#define glMakeBufferResidentNV		MANGLE(MakeBufferResidentNV)
#define glMap1d		MANGLE(Map1d)
#define glMap1f		MANGLE(Map1f)
#define glMap2d		MANGLE(Map2d)
#define glMap2f		MANGLE(Map2f)
#define glMapBufferARB		MANGLE(MapBufferARB)
#define glMapBuffer		MANGLE(MapBuffer)
#define glMapBufferRange		MANGLE(MapBufferRange)
#define glMapControlPointsNV		MANGLE(MapControlPointsNV)
#define glMapGrid1d		MANGLE(MapGrid1d)
#define glMapGrid1f		MANGLE(MapGrid1f)
#define glMapGrid2d		MANGLE(MapGrid2d)
#define glMapGrid2f		MANGLE(MapGrid2f)
#define glMapNamedBufferEXT		MANGLE(MapNamedBufferEXT)
#define glMapObjectBufferATI		MANGLE(MapObjectBufferATI)
#define glMapParameterfvNV		MANGLE(MapParameterfvNV)
#define glMapParameterivNV		MANGLE(MapParameterivNV)
#define glMapVertexAttrib1dAPPLE		MANGLE(MapVertexAttrib1dAPPLE)
#define glMapVertexAttrib1fAPPLE		MANGLE(MapVertexAttrib1fAPPLE)
#define glMapVertexAttrib2dAPPLE		MANGLE(MapVertexAttrib2dAPPLE)
#define glMapVertexAttrib2fAPPLE		MANGLE(MapVertexAttrib2fAPPLE)
#define glMaterialf		MANGLE(Materialf)
#define glMaterialfv		MANGLE(Materialfv)
#define glMateriali		MANGLE(Materiali)
#define glMaterialiv		MANGLE(Materialiv)
#define glMatrixFrustumEXT		MANGLE(MatrixFrustumEXT)
#define glMatrixIndexPointerARB		MANGLE(MatrixIndexPointerARB)
#define glMatrixIndexubvARB		MANGLE(MatrixIndexubvARB)
#define glMatrixIndexuivARB		MANGLE(MatrixIndexuivARB)
#define glMatrixIndexusvARB		MANGLE(MatrixIndexusvARB)
#define glMatrixLoaddEXT		MANGLE(MatrixLoaddEXT)
#define glMatrixLoadfEXT		MANGLE(MatrixLoadfEXT)
#define glMatrixLoadIdentityEXT		MANGLE(MatrixLoadIdentityEXT)
#define glMatrixLoadTransposedEXT		MANGLE(MatrixLoadTransposedEXT)
#define glMatrixLoadTransposefEXT		MANGLE(MatrixLoadTransposefEXT)
#define glMatrixMode		MANGLE(MatrixMode)
#define glMatrixMultdEXT		MANGLE(MatrixMultdEXT)
#define glMatrixMultfEXT		MANGLE(MatrixMultfEXT)
#define glMatrixMultTransposedEXT		MANGLE(MatrixMultTransposedEXT)
#define glMatrixMultTransposefEXT		MANGLE(MatrixMultTransposefEXT)
#define glMatrixOrthoEXT		MANGLE(MatrixOrthoEXT)
#define glMatrixPopEXT		MANGLE(MatrixPopEXT)
#define glMatrixPushEXT		MANGLE(MatrixPushEXT)
#define glMatrixRotatedEXT		MANGLE(MatrixRotatedEXT)
#define glMatrixRotatefEXT		MANGLE(MatrixRotatefEXT)
#define glMatrixScaledEXT		MANGLE(MatrixScaledEXT)
#define glMatrixScalefEXT		MANGLE(MatrixScalefEXT)
#define glMatrixTranslatedEXT		MANGLE(MatrixTranslatedEXT)
#define glMatrixTranslatefEXT		MANGLE(MatrixTranslatefEXT)
#define glMinmaxEXT		MANGLE(MinmaxEXT)
#define glMinmax		MANGLE(Minmax)
#define glMinSampleShading		MANGLE(MinSampleShading)
#define glMultiDrawArraysEXT		MANGLE(MultiDrawArraysEXT)
#define glMultiDrawArrays		MANGLE(MultiDrawArrays)
#define glMultiDrawElementArrayAPPLE		MANGLE(MultiDrawElementArrayAPPLE)
#define glMultiDrawElementsBaseVertex		MANGLE(MultiDrawElementsBaseVertex)
#define glMultiDrawElementsEXT		MANGLE(MultiDrawElementsEXT)
#define glMultiDrawElements		MANGLE(MultiDrawElements)
#define glMultiDrawRangeElementArrayAPPLE		MANGLE(MultiDrawRangeElementArrayAPPLE)
#define glMultiModeDrawArraysIBM		MANGLE(MultiModeDrawArraysIBM)
#define glMultiModeDrawElementsIBM		MANGLE(MultiModeDrawElementsIBM)
#define glMultiTexBufferEXT		MANGLE(MultiTexBufferEXT)
#define glMultiTexCoord1dARB		MANGLE(MultiTexCoord1dARB)
#define glMultiTexCoord1d		MANGLE(MultiTexCoord1d)
#define glMultiTexCoord1dvARB		MANGLE(MultiTexCoord1dvARB)
#define glMultiTexCoord1dv		MANGLE(MultiTexCoord1dv)
#define glMultiTexCoord1fARB		MANGLE(MultiTexCoord1fARB)
#define glMultiTexCoord1f		MANGLE(MultiTexCoord1f)
#define glMultiTexCoord1fvARB		MANGLE(MultiTexCoord1fvARB)
#define glMultiTexCoord1fv		MANGLE(MultiTexCoord1fv)
#define glMultiTexCoord1hNV		MANGLE(MultiTexCoord1hNV)
#define glMultiTexCoord1hvNV		MANGLE(MultiTexCoord1hvNV)
#define glMultiTexCoord1iARB		MANGLE(MultiTexCoord1iARB)
#define glMultiTexCoord1i		MANGLE(MultiTexCoord1i)
#define glMultiTexCoord1ivARB		MANGLE(MultiTexCoord1ivARB)
#define glMultiTexCoord1iv		MANGLE(MultiTexCoord1iv)
#define glMultiTexCoord1sARB		MANGLE(MultiTexCoord1sARB)
#define glMultiTexCoord1s		MANGLE(MultiTexCoord1s)
#define glMultiTexCoord1svARB		MANGLE(MultiTexCoord1svARB)
#define glMultiTexCoord1sv		MANGLE(MultiTexCoord1sv)
#define glMultiTexCoord2dARB		MANGLE(MultiTexCoord2dARB)
#define glMultiTexCoord2d		MANGLE(MultiTexCoord2d)
#define glMultiTexCoord2dvARB		MANGLE(MultiTexCoord2dvARB)
#define glMultiTexCoord2dv		MANGLE(MultiTexCoord2dv)
#define glMultiTexCoord2fARB		MANGLE(MultiTexCoord2fARB)
#define glMultiTexCoord2f		MANGLE(MultiTexCoord2f)
#define glMultiTexCoord2fvARB		MANGLE(MultiTexCoord2fvARB)
#define glMultiTexCoord2fv		MANGLE(MultiTexCoord2fv)
#define glMultiTexCoord2hNV		MANGLE(MultiTexCoord2hNV)
#define glMultiTexCoord2hvNV		MANGLE(MultiTexCoord2hvNV)
#define glMultiTexCoord2iARB		MANGLE(MultiTexCoord2iARB)
#define glMultiTexCoord2i		MANGLE(MultiTexCoord2i)
#define glMultiTexCoord2ivARB		MANGLE(MultiTexCoord2ivARB)
#define glMultiTexCoord2iv		MANGLE(MultiTexCoord2iv)
#define glMultiTexCoord2sARB		MANGLE(MultiTexCoord2sARB)
#define glMultiTexCoord2s		MANGLE(MultiTexCoord2s)
#define glMultiTexCoord2svARB		MANGLE(MultiTexCoord2svARB)
#define glMultiTexCoord2sv		MANGLE(MultiTexCoord2sv)
#define glMultiTexCoord3dARB		MANGLE(MultiTexCoord3dARB)
#define glMultiTexCoord3d		MANGLE(MultiTexCoord3d)
#define glMultiTexCoord3dvARB		MANGLE(MultiTexCoord3dvARB)
#define glMultiTexCoord3dv		MANGLE(MultiTexCoord3dv)
#define glMultiTexCoord3fARB		MANGLE(MultiTexCoord3fARB)
#define glMultiTexCoord3f		MANGLE(MultiTexCoord3f)
#define glMultiTexCoord3fvARB		MANGLE(MultiTexCoord3fvARB)
#define glMultiTexCoord3fv		MANGLE(MultiTexCoord3fv)
#define glMultiTexCoord3hNV		MANGLE(MultiTexCoord3hNV)
#define glMultiTexCoord3hvNV		MANGLE(MultiTexCoord3hvNV)
#define glMultiTexCoord3iARB		MANGLE(MultiTexCoord3iARB)
#define glMultiTexCoord3i		MANGLE(MultiTexCoord3i)
#define glMultiTexCoord3ivARB		MANGLE(MultiTexCoord3ivARB)
#define glMultiTexCoord3iv		MANGLE(MultiTexCoord3iv)
#define glMultiTexCoord3sARB		MANGLE(MultiTexCoord3sARB)
#define glMultiTexCoord3s		MANGLE(MultiTexCoord3s)
#define glMultiTexCoord3svARB		MANGLE(MultiTexCoord3svARB)
#define glMultiTexCoord3sv		MANGLE(MultiTexCoord3sv)
#define glMultiTexCoord4dARB		MANGLE(MultiTexCoord4dARB)
#define glMultiTexCoord4d		MANGLE(MultiTexCoord4d)
#define glMultiTexCoord4dvARB		MANGLE(MultiTexCoord4dvARB)
#define glMultiTexCoord4dv		MANGLE(MultiTexCoord4dv)
#define glMultiTexCoord4fARB		MANGLE(MultiTexCoord4fARB)
#define glMultiTexCoord4f		MANGLE(MultiTexCoord4f)
#define glMultiTexCoord4fvARB		MANGLE(MultiTexCoord4fvARB)
#define glMultiTexCoord4fv		MANGLE(MultiTexCoord4fv)
#define glMultiTexCoord4hNV		MANGLE(MultiTexCoord4hNV)
#define glMultiTexCoord4hvNV		MANGLE(MultiTexCoord4hvNV)
#define glMultiTexCoord4iARB		MANGLE(MultiTexCoord4iARB)
#define glMultiTexCoord4i		MANGLE(MultiTexCoord4i)
#define glMultiTexCoord4ivARB		MANGLE(MultiTexCoord4ivARB)
#define glMultiTexCoord4iv		MANGLE(MultiTexCoord4iv)
#define glMultiTexCoord4sARB		MANGLE(MultiTexCoord4sARB)
#define glMultiTexCoord4s		MANGLE(MultiTexCoord4s)
#define glMultiTexCoord4svARB		MANGLE(MultiTexCoord4svARB)
#define glMultiTexCoord4sv		MANGLE(MultiTexCoord4sv)
#define glMultiTexCoordPointerEXT		MANGLE(MultiTexCoordPointerEXT)
#define glMultiTexEnvfEXT		MANGLE(MultiTexEnvfEXT)
#define glMultiTexEnvfvEXT		MANGLE(MultiTexEnvfvEXT)
#define glMultiTexEnviEXT		MANGLE(MultiTexEnviEXT)
#define glMultiTexEnvivEXT		MANGLE(MultiTexEnvivEXT)
#define glMultiTexGendEXT		MANGLE(MultiTexGendEXT)
#define glMultiTexGendvEXT		MANGLE(MultiTexGendvEXT)
#define glMultiTexGenfEXT		MANGLE(MultiTexGenfEXT)
#define glMultiTexGenfvEXT		MANGLE(MultiTexGenfvEXT)
#define glMultiTexGeniEXT		MANGLE(MultiTexGeniEXT)
#define glMultiTexGenivEXT		MANGLE(MultiTexGenivEXT)
#define glMultiTexImage1DEXT		MANGLE(MultiTexImage1DEXT)
#define glMultiTexImage2DEXT		MANGLE(MultiTexImage2DEXT)
#define glMultiTexImage3DEXT		MANGLE(MultiTexImage3DEXT)
#define glMultiTexParameterfEXT		MANGLE(MultiTexParameterfEXT)
#define glMultiTexParameterfvEXT		MANGLE(MultiTexParameterfvEXT)
#define glMultiTexParameteriEXT		MANGLE(MultiTexParameteriEXT)
#define glMultiTexParameterIivEXT		MANGLE(MultiTexParameterIivEXT)
#define glMultiTexParameterIuivEXT		MANGLE(MultiTexParameterIuivEXT)
#define glMultiTexParameterivEXT		MANGLE(MultiTexParameterivEXT)
#define glMultiTexRenderbufferEXT		MANGLE(MultiTexRenderbufferEXT)
#define glMultiTexSubImage1DEXT		MANGLE(MultiTexSubImage1DEXT)
#define glMultiTexSubImage2DEXT		MANGLE(MultiTexSubImage2DEXT)
#define glMultiTexSubImage3DEXT		MANGLE(MultiTexSubImage3DEXT)
#define glMultMatrixd		MANGLE(MultMatrixd)
#define glMultMatrixf		MANGLE(MultMatrixf)
#define glMultTransposeMatrixdARB		MANGLE(MultTransposeMatrixdARB)
#define glMultTransposeMatrixd		MANGLE(MultTransposeMatrixd)
#define glMultTransposeMatrixfARB		MANGLE(MultTransposeMatrixfARB)
#define glMultTransposeMatrixf		MANGLE(MultTransposeMatrixf)
#define glNamedBufferDataEXT		MANGLE(NamedBufferDataEXT)
#define glNamedBufferSubDataEXT		MANGLE(NamedBufferSubDataEXT)
#define glNamedFramebufferRenderbufferEXT		MANGLE(NamedFramebufferRenderbufferEXT)
#define glNamedFramebufferTexture1DEXT		MANGLE(NamedFramebufferTexture1DEXT)
#define glNamedFramebufferTexture2DEXT		MANGLE(NamedFramebufferTexture2DEXT)
#define glNamedFramebufferTexture3DEXT		MANGLE(NamedFramebufferTexture3DEXT)
#define glNamedFramebufferTextureEXT		MANGLE(NamedFramebufferTextureEXT)
#define glNamedFramebufferTextureFaceEXT		MANGLE(NamedFramebufferTextureFaceEXT)
#define glNamedFramebufferTextureLayerEXT		MANGLE(NamedFramebufferTextureLayerEXT)
#define glNamedMakeBufferNonResidentNV		MANGLE(NamedMakeBufferNonResidentNV)
#define glNamedMakeBufferResidentNV		MANGLE(NamedMakeBufferResidentNV)
#define glNamedProgramLocalParameter4dEXT		MANGLE(NamedProgramLocalParameter4dEXT)
#define glNamedProgramLocalParameter4dvEXT		MANGLE(NamedProgramLocalParameter4dvEXT)
#define glNamedProgramLocalParameter4fEXT		MANGLE(NamedProgramLocalParameter4fEXT)
#define glNamedProgramLocalParameter4fvEXT		MANGLE(NamedProgramLocalParameter4fvEXT)
#define glNamedProgramLocalParameterI4iEXT		MANGLE(NamedProgramLocalParameterI4iEXT)
#define glNamedProgramLocalParameterI4ivEXT		MANGLE(NamedProgramLocalParameterI4ivEXT)
#define glNamedProgramLocalParameterI4uiEXT		MANGLE(NamedProgramLocalParameterI4uiEXT)
#define glNamedProgramLocalParameterI4uivEXT		MANGLE(NamedProgramLocalParameterI4uivEXT)
#define glNamedProgramLocalParameters4fvEXT		MANGLE(NamedProgramLocalParameters4fvEXT)
#define glNamedProgramLocalParametersI4ivEXT		MANGLE(NamedProgramLocalParametersI4ivEXT)
#define glNamedProgramLocalParametersI4uivEXT		MANGLE(NamedProgramLocalParametersI4uivEXT)
#define glNamedProgramStringEXT		MANGLE(NamedProgramStringEXT)
#define glNamedRenderbufferStorageEXT		MANGLE(NamedRenderbufferStorageEXT)
#define glNamedRenderbufferStorageMultisampleCoverageEXT		MANGLE(NamedRenderbufferStorageMultisampleCoverageEXT)
#define glNamedRenderbufferStorageMultisampleEXT		MANGLE(NamedRenderbufferStorageMultisampleEXT)
#define glNewList		MANGLE(NewList)
#define glNewObjectBufferATI		MANGLE(NewObjectBufferATI)
#define glNormal3b		MANGLE(Normal3b)
#define glNormal3bv		MANGLE(Normal3bv)
#define glNormal3d		MANGLE(Normal3d)
#define glNormal3dv		MANGLE(Normal3dv)
#define glNormal3f		MANGLE(Normal3f)
#define glNormal3fVertex3fSUN		MANGLE(Normal3fVertex3fSUN)
#define glNormal3fVertex3fvSUN		MANGLE(Normal3fVertex3fvSUN)
#define glNormal3fv		MANGLE(Normal3fv)
#define glNormal3hNV		MANGLE(Normal3hNV)
#define glNormal3hvNV		MANGLE(Normal3hvNV)
#define glNormal3i		MANGLE(Normal3i)
#define glNormal3iv		MANGLE(Normal3iv)
#define glNormal3s		MANGLE(Normal3s)
#define glNormal3sv		MANGLE(Normal3sv)
#define glNormalFormatNV		MANGLE(NormalFormatNV)
#define glNormalPointerEXT		MANGLE(NormalPointerEXT)
#define glNormalPointerListIBM		MANGLE(NormalPointerListIBM)
#define glNormalPointer		MANGLE(NormalPointer)
#define glNormalPointervINTEL		MANGLE(NormalPointervINTEL)
#define glNormalStream3bATI		MANGLE(NormalStream3bATI)
#define glNormalStream3bvATI		MANGLE(NormalStream3bvATI)
#define glNormalStream3dATI		MANGLE(NormalStream3dATI)
#define glNormalStream3dvATI		MANGLE(NormalStream3dvATI)
#define glNormalStream3fATI		MANGLE(NormalStream3fATI)
#define glNormalStream3fvATI		MANGLE(NormalStream3fvATI)
#define glNormalStream3iATI		MANGLE(NormalStream3iATI)
#define glNormalStream3ivATI		MANGLE(NormalStream3ivATI)
#define glNormalStream3sATI		MANGLE(NormalStream3sATI)
#define glNormalStream3svATI		MANGLE(NormalStream3svATI)
#define glObjectPurgeableAPPLE		MANGLE(ObjectPurgeableAPPLE)
#define glObjectUnpurgeableAPPLE		MANGLE(ObjectUnpurgeableAPPLE)
#define glOrtho		MANGLE(Ortho)
#define glPassTexCoordATI		MANGLE(PassTexCoordATI)
#define glPassThrough		MANGLE(PassThrough)
#define glPauseTransformFeedbackNV		MANGLE(PauseTransformFeedbackNV)
#define glPixelDataRangeNV		MANGLE(PixelDataRangeNV)
#define glPixelMapfv		MANGLE(PixelMapfv)
#define glPixelMapuiv		MANGLE(PixelMapuiv)
#define glPixelMapusv		MANGLE(PixelMapusv)
#define glPixelStoref		MANGLE(PixelStoref)
#define glPixelStorei		MANGLE(PixelStorei)
#define glPixelTexGenParameterfSGIS		MANGLE(PixelTexGenParameterfSGIS)
#define glPixelTexGenParameterfvSGIS		MANGLE(PixelTexGenParameterfvSGIS)
#define glPixelTexGenParameteriSGIS		MANGLE(PixelTexGenParameteriSGIS)
#define glPixelTexGenParameterivSGIS		MANGLE(PixelTexGenParameterivSGIS)
#define glPixelTexGenSGIX		MANGLE(PixelTexGenSGIX)
#define glPixelTransferf		MANGLE(PixelTransferf)
#define glPixelTransferi		MANGLE(PixelTransferi)
#define glPixelTransformParameterfEXT		MANGLE(PixelTransformParameterfEXT)
#define glPixelTransformParameterfvEXT		MANGLE(PixelTransformParameterfvEXT)
#define glPixelTransformParameteriEXT		MANGLE(PixelTransformParameteriEXT)
#define glPixelTransformParameterivEXT		MANGLE(PixelTransformParameterivEXT)
#define glPixelZoom		MANGLE(PixelZoom)
#define glPNTrianglesfATI		MANGLE(PNTrianglesfATI)
#define glPNTrianglesiATI		MANGLE(PNTrianglesiATI)
#define glPointParameterfARB		MANGLE(PointParameterfARB)
#define glPointParameterfEXT		MANGLE(PointParameterfEXT)
#define glPointParameterf		MANGLE(PointParameterf)
#define glPointParameterfSGIS		MANGLE(PointParameterfSGIS)
#define glPointParameterfvARB		MANGLE(PointParameterfvARB)
#define glPointParameterfvEXT		MANGLE(PointParameterfvEXT)
#define glPointParameterfv		MANGLE(PointParameterfv)
#define glPointParameterfvSGIS		MANGLE(PointParameterfvSGIS)
#define glPointParameteri		MANGLE(PointParameteri)
#define glPointParameteriNV		MANGLE(PointParameteriNV)
#define glPointParameteriv		MANGLE(PointParameteriv)
#define glPointParameterivNV		MANGLE(PointParameterivNV)
#define glPointSize		MANGLE(PointSize)
#define glPollAsyncSGIX		MANGLE(PollAsyncSGIX)
#define glPollInstrumentsSGIX		MANGLE(PollInstrumentsSGIX)
#define glPolygonMode		MANGLE(PolygonMode)
#define glPolygonOffsetEXT		MANGLE(PolygonOffsetEXT)
#define glPolygonOffset		MANGLE(PolygonOffset)
#define glPolygonStipple		MANGLE(PolygonStipple)
#define glPopAttrib		MANGLE(PopAttrib)
#define glPopClientAttrib		MANGLE(PopClientAttrib)
#define glPopMatrix		MANGLE(PopMatrix)
#define glPopName		MANGLE(PopName)
#define glPresentFrameDualFillNV		MANGLE(PresentFrameDualFillNV)
#define glPresentFrameKeyedNV		MANGLE(PresentFrameKeyedNV)
#define glPrimitiveRestartIndex		MANGLE(PrimitiveRestartIndex)
#define glPrimitiveRestartIndexNV		MANGLE(PrimitiveRestartIndexNV)
#define glPrimitiveRestartNV		MANGLE(PrimitiveRestartNV)
#define glPrioritizeTexturesEXT		MANGLE(PrioritizeTexturesEXT)
#define glPrioritizeTextures		MANGLE(PrioritizeTextures)
#define glProgramBufferParametersfvNV		MANGLE(ProgramBufferParametersfvNV)
#define glProgramBufferParametersIivNV		MANGLE(ProgramBufferParametersIivNV)
#define glProgramBufferParametersIuivNV		MANGLE(ProgramBufferParametersIuivNV)
#define glProgramCallbackMESA		MANGLE(ProgramCallbackMESA)
#define glProgramEnvParameter4dARB		MANGLE(ProgramEnvParameter4dARB)
#define glProgramEnvParameter4dvARB		MANGLE(ProgramEnvParameter4dvARB)
#define glProgramEnvParameter4fARB		MANGLE(ProgramEnvParameter4fARB)
#define glProgramEnvParameter4fvARB		MANGLE(ProgramEnvParameter4fvARB)
#define glProgramEnvParameterI4iNV		MANGLE(ProgramEnvParameterI4iNV)
#define glProgramEnvParameterI4ivNV		MANGLE(ProgramEnvParameterI4ivNV)
#define glProgramEnvParameterI4uiNV		MANGLE(ProgramEnvParameterI4uiNV)
#define glProgramEnvParameterI4uivNV		MANGLE(ProgramEnvParameterI4uivNV)
#define glProgramEnvParameters4fvEXT		MANGLE(ProgramEnvParameters4fvEXT)
#define glProgramEnvParametersI4ivNV		MANGLE(ProgramEnvParametersI4ivNV)
#define glProgramEnvParametersI4uivNV		MANGLE(ProgramEnvParametersI4uivNV)
#define glProgramLocalParameter4dARB		MANGLE(ProgramLocalParameter4dARB)
#define glProgramLocalParameter4dvARB		MANGLE(ProgramLocalParameter4dvARB)
#define glProgramLocalParameter4fARB		MANGLE(ProgramLocalParameter4fARB)
#define glProgramLocalParameter4fvARB		MANGLE(ProgramLocalParameter4fvARB)
#define glProgramLocalParameterI4iNV		MANGLE(ProgramLocalParameterI4iNV)
#define glProgramLocalParameterI4ivNV		MANGLE(ProgramLocalParameterI4ivNV)
#define glProgramLocalParameterI4uiNV		MANGLE(ProgramLocalParameterI4uiNV)
#define glProgramLocalParameterI4uivNV		MANGLE(ProgramLocalParameterI4uivNV)
#define glProgramLocalParameters4fvEXT		MANGLE(ProgramLocalParameters4fvEXT)
#define glProgramLocalParametersI4ivNV		MANGLE(ProgramLocalParametersI4ivNV)
#define glProgramLocalParametersI4uivNV		MANGLE(ProgramLocalParametersI4uivNV)
#define glProgramNamedParameter4dNV		MANGLE(ProgramNamedParameter4dNV)
#define glProgramNamedParameter4dvNV		MANGLE(ProgramNamedParameter4dvNV)
#define glProgramNamedParameter4fNV		MANGLE(ProgramNamedParameter4fNV)
#define glProgramNamedParameter4fvNV		MANGLE(ProgramNamedParameter4fvNV)
#define glProgramParameter4dNV		MANGLE(ProgramParameter4dNV)
#define glProgramParameter4dvNV		MANGLE(ProgramParameter4dvNV)
#define glProgramParameter4fNV		MANGLE(ProgramParameter4fNV)
#define glProgramParameter4fvNV		MANGLE(ProgramParameter4fvNV)
#define glProgramParameteriARB		MANGLE(ProgramParameteriARB)
#define glProgramParameteriEXT		MANGLE(ProgramParameteriEXT)
#define glProgramParameteri		MANGLE(ProgramParameteri)
#define glProgramParameters4dvNV		MANGLE(ProgramParameters4dvNV)
#define glProgramParameters4fvNV		MANGLE(ProgramParameters4fvNV)
#define glProgramStringARB		MANGLE(ProgramStringARB)
#define glProgramUniform1fEXT		MANGLE(ProgramUniform1fEXT)
#define glProgramUniform1fvEXT		MANGLE(ProgramUniform1fvEXT)
#define glProgramUniform1iEXT		MANGLE(ProgramUniform1iEXT)
#define glProgramUniform1ivEXT		MANGLE(ProgramUniform1ivEXT)
#define glProgramUniform1uiEXT		MANGLE(ProgramUniform1uiEXT)
#define glProgramUniform1uivEXT		MANGLE(ProgramUniform1uivEXT)
#define glProgramUniform2fEXT		MANGLE(ProgramUniform2fEXT)
#define glProgramUniform2fvEXT		MANGLE(ProgramUniform2fvEXT)
#define glProgramUniform2iEXT		MANGLE(ProgramUniform2iEXT)
#define glProgramUniform2ivEXT		MANGLE(ProgramUniform2ivEXT)
#define glProgramUniform2uiEXT		MANGLE(ProgramUniform2uiEXT)
#define glProgramUniform2uivEXT		MANGLE(ProgramUniform2uivEXT)
#define glProgramUniform3fEXT		MANGLE(ProgramUniform3fEXT)
#define glProgramUniform3fvEXT		MANGLE(ProgramUniform3fvEXT)
#define glProgramUniform3iEXT		MANGLE(ProgramUniform3iEXT)
#define glProgramUniform3ivEXT		MANGLE(ProgramUniform3ivEXT)
#define glProgramUniform3uiEXT		MANGLE(ProgramUniform3uiEXT)
#define glProgramUniform3uivEXT		MANGLE(ProgramUniform3uivEXT)
#define glProgramUniform4fEXT		MANGLE(ProgramUniform4fEXT)
#define glProgramUniform4fvEXT		MANGLE(ProgramUniform4fvEXT)
#define glProgramUniform4iEXT		MANGLE(ProgramUniform4iEXT)
#define glProgramUniform4ivEXT		MANGLE(ProgramUniform4ivEXT)
#define glProgramUniform4uiEXT		MANGLE(ProgramUniform4uiEXT)
#define glProgramUniform4uivEXT		MANGLE(ProgramUniform4uivEXT)
#define glProgramUniformMatrix2fvEXT		MANGLE(ProgramUniformMatrix2fvEXT)
#define glProgramUniformMatrix2x3fvEXT		MANGLE(ProgramUniformMatrix2x3fvEXT)
#define glProgramUniformMatrix2x4fvEXT		MANGLE(ProgramUniformMatrix2x4fvEXT)
#define glProgramUniformMatrix3fvEXT		MANGLE(ProgramUniformMatrix3fvEXT)
#define glProgramUniformMatrix3x2fvEXT		MANGLE(ProgramUniformMatrix3x2fvEXT)
#define glProgramUniformMatrix3x4fvEXT		MANGLE(ProgramUniformMatrix3x4fvEXT)
#define glProgramUniformMatrix4fvEXT		MANGLE(ProgramUniformMatrix4fvEXT)
#define glProgramUniformMatrix4x2fvEXT		MANGLE(ProgramUniformMatrix4x2fvEXT)
#define glProgramUniformMatrix4x3fvEXT		MANGLE(ProgramUniformMatrix4x3fvEXT)
#define glProgramUniformui64NV		MANGLE(ProgramUniformui64NV)
#define glProgramUniformui64vNV		MANGLE(ProgramUniformui64vNV)
#define glProgramVertexLimitNV		MANGLE(ProgramVertexLimitNV)
#define glProvokingVertexEXT		MANGLE(ProvokingVertexEXT)
#define glProvokingVertex		MANGLE(ProvokingVertex)
#define glPushAttrib		MANGLE(PushAttrib)
#define glPushClientAttribDefaultEXT		MANGLE(PushClientAttribDefaultEXT)
#define glPushClientAttrib		MANGLE(PushClientAttrib)
#define glPushMatrix		MANGLE(PushMatrix)
#define glPushName		MANGLE(PushName)
#define glRasterPos2d		MANGLE(RasterPos2d)
#define glRasterPos2dv		MANGLE(RasterPos2dv)
#define glRasterPos2f		MANGLE(RasterPos2f)
#define glRasterPos2fv		MANGLE(RasterPos2fv)
#define glRasterPos2i		MANGLE(RasterPos2i)
#define glRasterPos2iv		MANGLE(RasterPos2iv)
#define glRasterPos2s		MANGLE(RasterPos2s)
#define glRasterPos2sv		MANGLE(RasterPos2sv)
#define glRasterPos3d		MANGLE(RasterPos3d)
#define glRasterPos3dv		MANGLE(RasterPos3dv)
#define glRasterPos3f		MANGLE(RasterPos3f)
#define glRasterPos3fv		MANGLE(RasterPos3fv)
#define glRasterPos3i		MANGLE(RasterPos3i)
#define glRasterPos3iv		MANGLE(RasterPos3iv)
#define glRasterPos3s		MANGLE(RasterPos3s)
#define glRasterPos3sv		MANGLE(RasterPos3sv)
#define glRasterPos4d		MANGLE(RasterPos4d)
#define glRasterPos4dv		MANGLE(RasterPos4dv)
#define glRasterPos4f		MANGLE(RasterPos4f)
#define glRasterPos4fv		MANGLE(RasterPos4fv)
#define glRasterPos4i		MANGLE(RasterPos4i)
#define glRasterPos4iv		MANGLE(RasterPos4iv)
#define glRasterPos4s		MANGLE(RasterPos4s)
#define glRasterPos4sv		MANGLE(RasterPos4sv)
#define glReadBuffer		MANGLE(ReadBuffer)
#define glReadInstrumentsSGIX		MANGLE(ReadInstrumentsSGIX)
#define glReadPixels		MANGLE(ReadPixels)
#define glRectd		MANGLE(Rectd)
#define glRectdv		MANGLE(Rectdv)
#define glRectf		MANGLE(Rectf)
#define glRectfv		MANGLE(Rectfv)
#define glRecti		MANGLE(Recti)
#define glRectiv		MANGLE(Rectiv)
#define glRects		MANGLE(Rects)
#define glRectsv		MANGLE(Rectsv)
#define glReferencePlaneSGIX		MANGLE(ReferencePlaneSGIX)
#define glRenderbufferStorageEXT		MANGLE(RenderbufferStorageEXT)
#define glRenderbufferStorage		MANGLE(RenderbufferStorage)
#define glRenderbufferStorageMultisampleCoverageNV		MANGLE(RenderbufferStorageMultisampleCoverageNV)
#define glRenderbufferStorageMultisampleEXT		MANGLE(RenderbufferStorageMultisampleEXT)
#define glRenderbufferStorageMultisample		MANGLE(RenderbufferStorageMultisample)
#define glRenderMode		MANGLE(RenderMode)
#define glReplacementCodePointerSUN		MANGLE(ReplacementCodePointerSUN)
#define glReplacementCodeubSUN		MANGLE(ReplacementCodeubSUN)
#define glReplacementCodeubvSUN		MANGLE(ReplacementCodeubvSUN)
#define glReplacementCodeuiColor3fVertex3fSUN		MANGLE(ReplacementCodeuiColor3fVertex3fSUN)
#define glReplacementCodeuiColor3fVertex3fvSUN		MANGLE(ReplacementCodeuiColor3fVertex3fvSUN)
#define glReplacementCodeuiColor4fNormal3fVertex3fSUN		MANGLE(ReplacementCodeuiColor4fNormal3fVertex3fSUN)
#define glReplacementCodeuiColor4fNormal3fVertex3fvSUN		MANGLE(ReplacementCodeuiColor4fNormal3fVertex3fvSUN)
#define glReplacementCodeuiColor4ubVertex3fSUN		MANGLE(ReplacementCodeuiColor4ubVertex3fSUN)
#define glReplacementCodeuiColor4ubVertex3fvSUN		MANGLE(ReplacementCodeuiColor4ubVertex3fvSUN)
#define glReplacementCodeuiNormal3fVertex3fSUN		MANGLE(ReplacementCodeuiNormal3fVertex3fSUN)
#define glReplacementCodeuiNormal3fVertex3fvSUN		MANGLE(ReplacementCodeuiNormal3fVertex3fvSUN)
#define glReplacementCodeuiSUN		MANGLE(ReplacementCodeuiSUN)
#define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN		MANGLE(ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)
#define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN		MANGLE(ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)
#define glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN		MANGLE(ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)
#define glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN		MANGLE(ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)
#define glReplacementCodeuiTexCoord2fVertex3fSUN		MANGLE(ReplacementCodeuiTexCoord2fVertex3fSUN)
#define glReplacementCodeuiTexCoord2fVertex3fvSUN		MANGLE(ReplacementCodeuiTexCoord2fVertex3fvSUN)
#define glReplacementCodeuiVertex3fSUN		MANGLE(ReplacementCodeuiVertex3fSUN)
#define glReplacementCodeuiVertex3fvSUN		MANGLE(ReplacementCodeuiVertex3fvSUN)
#define glReplacementCodeuivSUN		MANGLE(ReplacementCodeuivSUN)
#define glReplacementCodeusSUN		MANGLE(ReplacementCodeusSUN)
#define glReplacementCodeusvSUN		MANGLE(ReplacementCodeusvSUN)
#define glRequestResidentProgramsNV		MANGLE(RequestResidentProgramsNV)
#define glResetHistogramEXT		MANGLE(ResetHistogramEXT)
#define glResetHistogram		MANGLE(ResetHistogram)
#define glResetMinmaxEXT		MANGLE(ResetMinmaxEXT)
#define glResetMinmax		MANGLE(ResetMinmax)
#define glResizeBuffersMESA		MANGLE(ResizeBuffersMESA)
#define glResumeTransformFeedbackNV		MANGLE(ResumeTransformFeedbackNV)
#define glRotated		MANGLE(Rotated)
#define glRotatef		MANGLE(Rotatef)
#define glSampleCoverageARB		MANGLE(SampleCoverageARB)
#define glSampleCoverage		MANGLE(SampleCoverage)
#define glSampleMapATI		MANGLE(SampleMapATI)
#define glSampleMaskEXT		MANGLE(SampleMaskEXT)
#define glSampleMaski		MANGLE(SampleMaski)
#define glSampleMaskIndexedNV		MANGLE(SampleMaskIndexedNV)
#define glSampleMaskSGIS		MANGLE(SampleMaskSGIS)
#define glSamplePatternEXT		MANGLE(SamplePatternEXT)
#define glSamplePatternSGIS		MANGLE(SamplePatternSGIS)
#define glScaled		MANGLE(Scaled)
#define glScalef		MANGLE(Scalef)
#define glScissor		MANGLE(Scissor)
#define glSecondaryColor3bEXT		MANGLE(SecondaryColor3bEXT)
#define glSecondaryColor3b		MANGLE(SecondaryColor3b)
#define glSecondaryColor3bvEXT		MANGLE(SecondaryColor3bvEXT)
#define glSecondaryColor3bv		MANGLE(SecondaryColor3bv)
#define glSecondaryColor3dEXT		MANGLE(SecondaryColor3dEXT)
#define glSecondaryColor3d		MANGLE(SecondaryColor3d)
#define glSecondaryColor3dvEXT		MANGLE(SecondaryColor3dvEXT)
#define glSecondaryColor3dv		MANGLE(SecondaryColor3dv)
#define glSecondaryColor3fEXT		MANGLE(SecondaryColor3fEXT)
#define glSecondaryColor3f		MANGLE(SecondaryColor3f)
#define glSecondaryColor3fvEXT		MANGLE(SecondaryColor3fvEXT)
#define glSecondaryColor3fv		MANGLE(SecondaryColor3fv)
#define glSecondaryColor3hNV		MANGLE(SecondaryColor3hNV)
#define glSecondaryColor3hvNV		MANGLE(SecondaryColor3hvNV)
#define glSecondaryColor3iEXT		MANGLE(SecondaryColor3iEXT)
#define glSecondaryColor3i		MANGLE(SecondaryColor3i)
#define glSecondaryColor3ivEXT		MANGLE(SecondaryColor3ivEXT)
#define glSecondaryColor3iv		MANGLE(SecondaryColor3iv)
#define glSecondaryColor3sEXT		MANGLE(SecondaryColor3sEXT)
#define glSecondaryColor3s		MANGLE(SecondaryColor3s)
#define glSecondaryColor3svEXT		MANGLE(SecondaryColor3svEXT)
#define glSecondaryColor3sv		MANGLE(SecondaryColor3sv)
#define glSecondaryColor3ubEXT		MANGLE(SecondaryColor3ubEXT)
#define glSecondaryColor3ub		MANGLE(SecondaryColor3ub)
#define glSecondaryColor3ubvEXT		MANGLE(SecondaryColor3ubvEXT)
#define glSecondaryColor3ubv		MANGLE(SecondaryColor3ubv)
#define glSecondaryColor3uiEXT		MANGLE(SecondaryColor3uiEXT)
#define glSecondaryColor3ui		MANGLE(SecondaryColor3ui)
#define glSecondaryColor3uivEXT		MANGLE(SecondaryColor3uivEXT)
#define glSecondaryColor3uiv		MANGLE(SecondaryColor3uiv)
#define glSecondaryColor3usEXT		MANGLE(SecondaryColor3usEXT)
#define glSecondaryColor3us		MANGLE(SecondaryColor3us)
#define glSecondaryColor3usvEXT		MANGLE(SecondaryColor3usvEXT)
#define glSecondaryColor3usv		MANGLE(SecondaryColor3usv)
#define glSecondaryColorFormatNV		MANGLE(SecondaryColorFormatNV)
#define glSecondaryColorPointerEXT		MANGLE(SecondaryColorPointerEXT)
#define glSecondaryColorPointerListIBM		MANGLE(SecondaryColorPointerListIBM)
#define glSecondaryColorPointer		MANGLE(SecondaryColorPointer)
#define glSelectBuffer		MANGLE(SelectBuffer)
#define glSelectPerfMonitorCountersAMD		MANGLE(SelectPerfMonitorCountersAMD)
#define glSeparableFilter2DEXT		MANGLE(SeparableFilter2DEXT)
#define glSeparableFilter2D		MANGLE(SeparableFilter2D)
#define glSetFenceAPPLE		MANGLE(SetFenceAPPLE)
#define glSetFenceNV		MANGLE(SetFenceNV)
#define glSetFragmentShaderConstantATI		MANGLE(SetFragmentShaderConstantATI)
#define glSetInvariantEXT		MANGLE(SetInvariantEXT)
#define glSetLocalConstantEXT		MANGLE(SetLocalConstantEXT)
#define glShadeModel		MANGLE(ShadeModel)
#define glShaderOp1EXT		MANGLE(ShaderOp1EXT)
#define glShaderOp2EXT		MANGLE(ShaderOp2EXT)
#define glShaderOp3EXT		MANGLE(ShaderOp3EXT)
#define glShaderSourceARB		MANGLE(ShaderSourceARB)
#define glShaderSource		MANGLE(ShaderSource)
#define glSharpenTexFuncSGIS		MANGLE(SharpenTexFuncSGIS)
#define glSpriteParameterfSGIX		MANGLE(SpriteParameterfSGIX)
#define glSpriteParameterfvSGIX		MANGLE(SpriteParameterfvSGIX)
#define glSpriteParameteriSGIX		MANGLE(SpriteParameteriSGIX)
#define glSpriteParameterivSGIX		MANGLE(SpriteParameterivSGIX)
#define glStartInstrumentsSGIX		MANGLE(StartInstrumentsSGIX)
#define glStencilClearTagEXT		MANGLE(StencilClearTagEXT)
#define glStencilFunc		MANGLE(StencilFunc)
#define glStencilFuncSeparateATI		MANGLE(StencilFuncSeparateATI)
#define glStencilFuncSeparate		MANGLE(StencilFuncSeparate)
#define glStencilMask		MANGLE(StencilMask)
#define glStencilMaskSeparate		MANGLE(StencilMaskSeparate)
#define glStencilOp		MANGLE(StencilOp)
#define glStencilOpSeparateATI		MANGLE(StencilOpSeparateATI)
#define glStencilOpSeparate		MANGLE(StencilOpSeparate)
#define glStopInstrumentsSGIX		MANGLE(StopInstrumentsSGIX)
#define glStringMarkerGREMEDY		MANGLE(StringMarkerGREMEDY)
#define glSwizzleEXT		MANGLE(SwizzleEXT)
#define glTagSampleBufferSGIX		MANGLE(TagSampleBufferSGIX)
#define glTangent3bEXT		MANGLE(Tangent3bEXT)
#define glTangent3bvEXT		MANGLE(Tangent3bvEXT)
#define glTangent3dEXT		MANGLE(Tangent3dEXT)
#define glTangent3dvEXT		MANGLE(Tangent3dvEXT)
#define glTangent3fEXT		MANGLE(Tangent3fEXT)
#define glTangent3fvEXT		MANGLE(Tangent3fvEXT)
#define glTangent3iEXT		MANGLE(Tangent3iEXT)
#define glTangent3ivEXT		MANGLE(Tangent3ivEXT)
#define glTangent3sEXT		MANGLE(Tangent3sEXT)
#define glTangent3svEXT		MANGLE(Tangent3svEXT)
#define glTangentPointerEXT		MANGLE(TangentPointerEXT)
#define glTbufferMask3DFX		MANGLE(TbufferMask3DFX)
#define glTessellationFactorAMD		MANGLE(TessellationFactorAMD)
#define glTessellationModeAMD		MANGLE(TessellationModeAMD)
#define glTestFenceAPPLE		MANGLE(TestFenceAPPLE)
#define glTestFenceNV		MANGLE(TestFenceNV)
#define glTestObjectAPPLE		MANGLE(TestObjectAPPLE)
#define glTexBufferARB		MANGLE(TexBufferARB)
#define glTexBufferEXT		MANGLE(TexBufferEXT)
#define glTexBuffer		MANGLE(TexBuffer)
#define glTexBumpParameterfvATI		MANGLE(TexBumpParameterfvATI)
#define glTexBumpParameterivATI		MANGLE(TexBumpParameterivATI)
#define glTexCoord1d		MANGLE(TexCoord1d)
#define glTexCoord1dv		MANGLE(TexCoord1dv)
#define glTexCoord1f		MANGLE(TexCoord1f)
#define glTexCoord1fv		MANGLE(TexCoord1fv)
#define glTexCoord1hNV		MANGLE(TexCoord1hNV)
#define glTexCoord1hvNV		MANGLE(TexCoord1hvNV)
#define glTexCoord1i		MANGLE(TexCoord1i)
#define glTexCoord1iv		MANGLE(TexCoord1iv)
#define glTexCoord1s		MANGLE(TexCoord1s)
#define glTexCoord1sv		MANGLE(TexCoord1sv)
#define glTexCoord2d		MANGLE(TexCoord2d)
#define glTexCoord2dv		MANGLE(TexCoord2dv)
#define glTexCoord2fColor3fVertex3fSUN		MANGLE(TexCoord2fColor3fVertex3fSUN)
#define glTexCoord2fColor3fVertex3fvSUN		MANGLE(TexCoord2fColor3fVertex3fvSUN)
#define glTexCoord2fColor4fNormal3fVertex3fSUN		MANGLE(TexCoord2fColor4fNormal3fVertex3fSUN)
#define glTexCoord2fColor4fNormal3fVertex3fvSUN		MANGLE(TexCoord2fColor4fNormal3fVertex3fvSUN)
#define glTexCoord2fColor4ubVertex3fSUN		MANGLE(TexCoord2fColor4ubVertex3fSUN)
#define glTexCoord2fColor4ubVertex3fvSUN		MANGLE(TexCoord2fColor4ubVertex3fvSUN)
#define glTexCoord2f		MANGLE(TexCoord2f)
#define glTexCoord2fNormal3fVertex3fSUN		MANGLE(TexCoord2fNormal3fVertex3fSUN)
#define glTexCoord2fNormal3fVertex3fvSUN		MANGLE(TexCoord2fNormal3fVertex3fvSUN)
#define glTexCoord2fVertex3fSUN		MANGLE(TexCoord2fVertex3fSUN)
#define glTexCoord2fVertex3fvSUN		MANGLE(TexCoord2fVertex3fvSUN)
#define glTexCoord2fv		MANGLE(TexCoord2fv)
#define glTexCoord2hNV		MANGLE(TexCoord2hNV)
#define glTexCoord2hvNV		MANGLE(TexCoord2hvNV)
#define glTexCoord2i		MANGLE(TexCoord2i)
#define glTexCoord2iv		MANGLE(TexCoord2iv)
#define glTexCoord2s		MANGLE(TexCoord2s)
#define glTexCoord2sv		MANGLE(TexCoord2sv)
#define glTexCoord3d		MANGLE(TexCoord3d)
#define glTexCoord3dv		MANGLE(TexCoord3dv)
#define glTexCoord3f		MANGLE(TexCoord3f)
#define glTexCoord3fv		MANGLE(TexCoord3fv)
#define glTexCoord3hNV		MANGLE(TexCoord3hNV)
#define glTexCoord3hvNV		MANGLE(TexCoord3hvNV)
#define glTexCoord3i		MANGLE(TexCoord3i)
#define glTexCoord3iv		MANGLE(TexCoord3iv)
#define glTexCoord3s		MANGLE(TexCoord3s)
#define glTexCoord3sv		MANGLE(TexCoord3sv)
#define glTexCoord4d		MANGLE(TexCoord4d)
#define glTexCoord4dv		MANGLE(TexCoord4dv)
#define glTexCoord4fColor4fNormal3fVertex4fSUN		MANGLE(TexCoord4fColor4fNormal3fVertex4fSUN)
#define glTexCoord4fColor4fNormal3fVertex4fvSUN		MANGLE(TexCoord4fColor4fNormal3fVertex4fvSUN)
#define glTexCoord4f		MANGLE(TexCoord4f)
#define glTexCoord4fVertex4fSUN		MANGLE(TexCoord4fVertex4fSUN)
#define glTexCoord4fVertex4fvSUN		MANGLE(TexCoord4fVertex4fvSUN)
#define glTexCoord4fv		MANGLE(TexCoord4fv)
#define glTexCoord4hNV		MANGLE(TexCoord4hNV)
#define glTexCoord4hvNV		MANGLE(TexCoord4hvNV)
#define glTexCoord4i		MANGLE(TexCoord4i)
#define glTexCoord4iv		MANGLE(TexCoord4iv)
#define glTexCoord4s		MANGLE(TexCoord4s)
#define glTexCoord4sv		MANGLE(TexCoord4sv)
#define glTexCoordFormatNV		MANGLE(TexCoordFormatNV)
#define glTexCoordPointerEXT		MANGLE(TexCoordPointerEXT)
#define glTexCoordPointerListIBM		MANGLE(TexCoordPointerListIBM)
#define glTexCoordPointer		MANGLE(TexCoordPointer)
#define glTexCoordPointervINTEL		MANGLE(TexCoordPointervINTEL)
#define glTexEnvf		MANGLE(TexEnvf)
#define glTexEnvfv		MANGLE(TexEnvfv)
#define glTexEnvi		MANGLE(TexEnvi)
#define glTexEnviv		MANGLE(TexEnviv)
#define glTexFilterFuncSGIS		MANGLE(TexFilterFuncSGIS)
#define glTexGend		MANGLE(TexGend)
#define glTexGendv		MANGLE(TexGendv)
#define glTexGenf		MANGLE(TexGenf)
#define glTexGenfv		MANGLE(TexGenfv)
#define glTexGeni		MANGLE(TexGeni)
#define glTexGeniv		MANGLE(TexGeniv)
#define glTexImage1D		MANGLE(TexImage1D)
#define glTexImage2D		MANGLE(TexImage2D)
#define glTexImage2DMultisample		MANGLE(TexImage2DMultisample)
#define glTexImage3DEXT		MANGLE(TexImage3DEXT)
#define glTexImage3D		MANGLE(TexImage3D)
#define glTexImage3DMultisample		MANGLE(TexImage3DMultisample)
#define glTexImage4DSGIS		MANGLE(TexImage4DSGIS)
#define glTexParameterf		MANGLE(TexParameterf)
#define glTexParameterfv		MANGLE(TexParameterfv)
#define glTexParameterIivEXT		MANGLE(TexParameterIivEXT)
#define glTexParameterIiv		MANGLE(TexParameterIiv)
#define glTexParameteri		MANGLE(TexParameteri)
#define glTexParameterIuivEXT		MANGLE(TexParameterIuivEXT)
#define glTexParameterIuiv		MANGLE(TexParameterIuiv)
#define glTexParameteriv		MANGLE(TexParameteriv)
#define glTexRenderbufferNV		MANGLE(TexRenderbufferNV)
#define glTexSubImage1DEXT		MANGLE(TexSubImage1DEXT)
#define glTexSubImage1D		MANGLE(TexSubImage1D)
#define glTexSubImage2DEXT		MANGLE(TexSubImage2DEXT)
#define glTexSubImage2D		MANGLE(TexSubImage2D)
#define glTexSubImage3DEXT		MANGLE(TexSubImage3DEXT)
#define glTexSubImage3D		MANGLE(TexSubImage3D)
#define glTexSubImage4DSGIS		MANGLE(TexSubImage4DSGIS)
#define glTextureBarrierNV		MANGLE(TextureBarrierNV)
#define glTextureBufferEXT		MANGLE(TextureBufferEXT)
#define glTextureColorMaskSGIS		MANGLE(TextureColorMaskSGIS)
#define glTextureImage1DEXT		MANGLE(TextureImage1DEXT)
#define glTextureImage2DEXT		MANGLE(TextureImage2DEXT)
#define glTextureImage3DEXT		MANGLE(TextureImage3DEXT)
#define glTextureLightEXT		MANGLE(TextureLightEXT)
#define glTextureMaterialEXT		MANGLE(TextureMaterialEXT)
#define glTextureNormalEXT		MANGLE(TextureNormalEXT)
#define glTextureParameterfEXT		MANGLE(TextureParameterfEXT)
#define glTextureParameterfvEXT		MANGLE(TextureParameterfvEXT)
#define glTextureParameteriEXT		MANGLE(TextureParameteriEXT)
#define glTextureParameterIivEXT		MANGLE(TextureParameterIivEXT)
#define glTextureParameterIuivEXT		MANGLE(TextureParameterIuivEXT)
#define glTextureParameterivEXT		MANGLE(TextureParameterivEXT)
#define glTextureRangeAPPLE		MANGLE(TextureRangeAPPLE)
#define glTextureRenderbufferEXT		MANGLE(TextureRenderbufferEXT)
#define glTextureSubImage1DEXT		MANGLE(TextureSubImage1DEXT)
#define glTextureSubImage2DEXT		MANGLE(TextureSubImage2DEXT)
#define glTextureSubImage3DEXT		MANGLE(TextureSubImage3DEXT)
#define glTrackMatrixNV		MANGLE(TrackMatrixNV)
#define glTransformFeedbackAttribsNV		MANGLE(TransformFeedbackAttribsNV)
#define glTransformFeedbackVaryingsEXT		MANGLE(TransformFeedbackVaryingsEXT)
#define glTransformFeedbackVaryings		MANGLE(TransformFeedbackVaryings)
#define glTransformFeedbackVaryingsNV		MANGLE(TransformFeedbackVaryingsNV)
#define glTranslated		MANGLE(Translated)
#define glTranslatef		MANGLE(Translatef)
#define glUniform1fARB		MANGLE(Uniform1fARB)
#define glUniform1f		MANGLE(Uniform1f)
#define glUniform1fvARB		MANGLE(Uniform1fvARB)
#define glUniform1fv		MANGLE(Uniform1fv)
#define glUniform1iARB		MANGLE(Uniform1iARB)
#define glUniform1i		MANGLE(Uniform1i)
#define glUniform1ivARB		MANGLE(Uniform1ivARB)
#define glUniform1iv		MANGLE(Uniform1iv)
#define glUniform1uiEXT		MANGLE(Uniform1uiEXT)
#define glUniform1ui		MANGLE(Uniform1ui)
#define glUniform1uivEXT		MANGLE(Uniform1uivEXT)
#define glUniform1uiv		MANGLE(Uniform1uiv)
#define glUniform2fARB		MANGLE(Uniform2fARB)
#define glUniform2f		MANGLE(Uniform2f)
#define glUniform2fvARB		MANGLE(Uniform2fvARB)
#define glUniform2fv		MANGLE(Uniform2fv)
#define glUniform2iARB		MANGLE(Uniform2iARB)
#define glUniform2i		MANGLE(Uniform2i)
#define glUniform2ivARB		MANGLE(Uniform2ivARB)
#define glUniform2iv		MANGLE(Uniform2iv)
#define glUniform2uiEXT		MANGLE(Uniform2uiEXT)
#define glUniform2ui		MANGLE(Uniform2ui)
#define glUniform2uivEXT		MANGLE(Uniform2uivEXT)
#define glUniform2uiv		MANGLE(Uniform2uiv)
#define glUniform3fARB		MANGLE(Uniform3fARB)
#define glUniform3f		MANGLE(Uniform3f)
#define glUniform3fvARB		MANGLE(Uniform3fvARB)
#define glUniform3fv		MANGLE(Uniform3fv)
#define glUniform3iARB		MANGLE(Uniform3iARB)
#define glUniform3i		MANGLE(Uniform3i)
#define glUniform3ivARB		MANGLE(Uniform3ivARB)
#define glUniform3iv		MANGLE(Uniform3iv)
#define glUniform3uiEXT		MANGLE(Uniform3uiEXT)
#define glUniform3ui		MANGLE(Uniform3ui)
#define glUniform3uivEXT		MANGLE(Uniform3uivEXT)
#define glUniform3uiv		MANGLE(Uniform3uiv)
#define glUniform4fARB		MANGLE(Uniform4fARB)
#define glUniform4f		MANGLE(Uniform4f)
#define glUniform4fvARB		MANGLE(Uniform4fvARB)
#define glUniform4fv		MANGLE(Uniform4fv)
#define glUniform4iARB		MANGLE(Uniform4iARB)
#define glUniform4i		MANGLE(Uniform4i)
#define glUniform4ivARB		MANGLE(Uniform4ivARB)
#define glUniform4iv		MANGLE(Uniform4iv)
#define glUniform4uiEXT		MANGLE(Uniform4uiEXT)
#define glUniform4ui		MANGLE(Uniform4ui)
#define glUniform4uivEXT		MANGLE(Uniform4uivEXT)
#define glUniform4uiv		MANGLE(Uniform4uiv)
#define glUniformBlockBinding		MANGLE(UniformBlockBinding)
#define glUniformBufferEXT		MANGLE(UniformBufferEXT)
#define glUniformMatrix2fvARB		MANGLE(UniformMatrix2fvARB)
#define glUniformMatrix2fv		MANGLE(UniformMatrix2fv)
#define glUniformMatrix2x3fv		MANGLE(UniformMatrix2x3fv)
#define glUniformMatrix2x4fv		MANGLE(UniformMatrix2x4fv)
#define glUniformMatrix3fvARB		MANGLE(UniformMatrix3fvARB)
#define glUniformMatrix3fv		MANGLE(UniformMatrix3fv)
#define glUniformMatrix3x2fv		MANGLE(UniformMatrix3x2fv)
#define glUniformMatrix3x4fv		MANGLE(UniformMatrix3x4fv)
#define glUniformMatrix4fvARB		MANGLE(UniformMatrix4fvARB)
#define glUniformMatrix4fv		MANGLE(UniformMatrix4fv)
#define glUniformMatrix4x2fv		MANGLE(UniformMatrix4x2fv)
#define glUniformMatrix4x3fv		MANGLE(UniformMatrix4x3fv)
#define glUniformui64NV		MANGLE(Uniformui64NV)
#define glUniformui64vNV		MANGLE(Uniformui64vNV)
#define glUnlockArraysEXT		MANGLE(UnlockArraysEXT)
#define glUnmapBufferARB		MANGLE(UnmapBufferARB)
#define glUnmapBuffer		MANGLE(UnmapBuffer)
#define glUnmapNamedBufferEXT		MANGLE(UnmapNamedBufferEXT)
#define glUnmapObjectBufferATI		MANGLE(UnmapObjectBufferATI)
#define glUpdateObjectBufferATI		MANGLE(UpdateObjectBufferATI)
#define glUseProgram		MANGLE(UseProgram)
#define glUseProgramObjectARB		MANGLE(UseProgramObjectARB)
#define glUseShaderProgramEXT		MANGLE(UseShaderProgramEXT)
#define glValidateProgramARB		MANGLE(ValidateProgramARB)
#define glValidateProgram		MANGLE(ValidateProgram)
#define glVariantArrayObjectATI		MANGLE(VariantArrayObjectATI)
#define glVariantbvEXT		MANGLE(VariantbvEXT)
#define glVariantdvEXT		MANGLE(VariantdvEXT)
#define glVariantfvEXT		MANGLE(VariantfvEXT)
#define glVariantivEXT		MANGLE(VariantivEXT)
#define glVariantPointerEXT		MANGLE(VariantPointerEXT)
#define glVariantsvEXT		MANGLE(VariantsvEXT)
#define glVariantubvEXT		MANGLE(VariantubvEXT)
#define glVariantuivEXT		MANGLE(VariantuivEXT)
#define glVariantusvEXT		MANGLE(VariantusvEXT)
#define glVertex2d		MANGLE(Vertex2d)
#define glVertex2dv		MANGLE(Vertex2dv)
#define glVertex2f		MANGLE(Vertex2f)
#define glVertex2fv		MANGLE(Vertex2fv)
#define glVertex2hNV		MANGLE(Vertex2hNV)
#define glVertex2hvNV		MANGLE(Vertex2hvNV)
#define glVertex2i		MANGLE(Vertex2i)
#define glVertex2iv		MANGLE(Vertex2iv)
#define glVertex2s		MANGLE(Vertex2s)
#define glVertex2sv		MANGLE(Vertex2sv)
#define glVertex3d		MANGLE(Vertex3d)
#define glVertex3dv		MANGLE(Vertex3dv)
#define glVertex3f		MANGLE(Vertex3f)
#define glVertex3fv		MANGLE(Vertex3fv)
#define glVertex3hNV		MANGLE(Vertex3hNV)
#define glVertex3hvNV		MANGLE(Vertex3hvNV)
#define glVertex3i		MANGLE(Vertex3i)
#define glVertex3iv		MANGLE(Vertex3iv)
#define glVertex3s		MANGLE(Vertex3s)
#define glVertex3sv		MANGLE(Vertex3sv)
#define glVertex4d		MANGLE(Vertex4d)
#define glVertex4dv		MANGLE(Vertex4dv)
#define glVertex4f		MANGLE(Vertex4f)
#define glVertex4fv		MANGLE(Vertex4fv)
#define glVertex4hNV		MANGLE(Vertex4hNV)
#define glVertex4hvNV		MANGLE(Vertex4hvNV)
#define glVertex4i		MANGLE(Vertex4i)
#define glVertex4iv		MANGLE(Vertex4iv)
#define glVertex4s		MANGLE(Vertex4s)
#define glVertex4sv		MANGLE(Vertex4sv)
#define glVertexArrayParameteriAPPLE		MANGLE(VertexArrayParameteriAPPLE)
#define glVertexArrayRangeAPPLE		MANGLE(VertexArrayRangeAPPLE)
#define glVertexArrayRangeNV		MANGLE(VertexArrayRangeNV)
#define glVertexAttrib1dARB		MANGLE(VertexAttrib1dARB)
#define glVertexAttrib1d		MANGLE(VertexAttrib1d)
#define glVertexAttrib1dNV		MANGLE(VertexAttrib1dNV)
#define glVertexAttrib1dvARB		MANGLE(VertexAttrib1dvARB)
#define glVertexAttrib1dv		MANGLE(VertexAttrib1dv)
#define glVertexAttrib1dvNV		MANGLE(VertexAttrib1dvNV)
#define glVertexAttrib1fARB		MANGLE(VertexAttrib1fARB)
#define glVertexAttrib1f		MANGLE(VertexAttrib1f)
#define glVertexAttrib1fNV		MANGLE(VertexAttrib1fNV)
#define glVertexAttrib1fvARB		MANGLE(VertexAttrib1fvARB)
#define glVertexAttrib1fv		MANGLE(VertexAttrib1fv)
#define glVertexAttrib1fvNV		MANGLE(VertexAttrib1fvNV)
#define glVertexAttrib1hNV		MANGLE(VertexAttrib1hNV)
#define glVertexAttrib1hvNV		MANGLE(VertexAttrib1hvNV)
#define glVertexAttrib1sARB		MANGLE(VertexAttrib1sARB)
#define glVertexAttrib1s		MANGLE(VertexAttrib1s)
#define glVertexAttrib1sNV		MANGLE(VertexAttrib1sNV)
#define glVertexAttrib1svARB		MANGLE(VertexAttrib1svARB)
#define glVertexAttrib1sv		MANGLE(VertexAttrib1sv)
#define glVertexAttrib1svNV		MANGLE(VertexAttrib1svNV)
#define glVertexAttrib2dARB		MANGLE(VertexAttrib2dARB)
#define glVertexAttrib2d		MANGLE(VertexAttrib2d)
#define glVertexAttrib2dNV		MANGLE(VertexAttrib2dNV)
#define glVertexAttrib2dvARB		MANGLE(VertexAttrib2dvARB)
#define glVertexAttrib2dv		MANGLE(VertexAttrib2dv)
#define glVertexAttrib2dvNV		MANGLE(VertexAttrib2dvNV)
#define glVertexAttrib2fARB		MANGLE(VertexAttrib2fARB)
#define glVertexAttrib2f		MANGLE(VertexAttrib2f)
#define glVertexAttrib2fNV		MANGLE(VertexAttrib2fNV)
#define glVertexAttrib2fvARB		MANGLE(VertexAttrib2fvARB)
#define glVertexAttrib2fv		MANGLE(VertexAttrib2fv)
#define glVertexAttrib2fvNV		MANGLE(VertexAttrib2fvNV)
#define glVertexAttrib2hNV		MANGLE(VertexAttrib2hNV)
#define glVertexAttrib2hvNV		MANGLE(VertexAttrib2hvNV)
#define glVertexAttrib2sARB		MANGLE(VertexAttrib2sARB)
#define glVertexAttrib2s		MANGLE(VertexAttrib2s)
#define glVertexAttrib2sNV		MANGLE(VertexAttrib2sNV)
#define glVertexAttrib2svARB		MANGLE(VertexAttrib2svARB)
#define glVertexAttrib2sv		MANGLE(VertexAttrib2sv)
#define glVertexAttrib2svNV		MANGLE(VertexAttrib2svNV)
#define glVertexAttrib3dARB		MANGLE(VertexAttrib3dARB)
#define glVertexAttrib3d		MANGLE(VertexAttrib3d)
#define glVertexAttrib3dNV		MANGLE(VertexAttrib3dNV)
#define glVertexAttrib3dvARB		MANGLE(VertexAttrib3dvARB)
#define glVertexAttrib3dv		MANGLE(VertexAttrib3dv)
#define glVertexAttrib3dvNV		MANGLE(VertexAttrib3dvNV)
#define glVertexAttrib3fARB		MANGLE(VertexAttrib3fARB)
#define glVertexAttrib3f		MANGLE(VertexAttrib3f)
#define glVertexAttrib3fNV		MANGLE(VertexAttrib3fNV)
#define glVertexAttrib3fvARB		MANGLE(VertexAttrib3fvARB)
#define glVertexAttrib3fv		MANGLE(VertexAttrib3fv)
#define glVertexAttrib3fvNV		MANGLE(VertexAttrib3fvNV)
#define glVertexAttrib3hNV		MANGLE(VertexAttrib3hNV)
#define glVertexAttrib3hvNV		MANGLE(VertexAttrib3hvNV)
#define glVertexAttrib3sARB		MANGLE(VertexAttrib3sARB)
#define glVertexAttrib3s		MANGLE(VertexAttrib3s)
#define glVertexAttrib3sNV		MANGLE(VertexAttrib3sNV)
#define glVertexAttrib3svARB		MANGLE(VertexAttrib3svARB)
#define glVertexAttrib3sv		MANGLE(VertexAttrib3sv)
#define glVertexAttrib3svNV		MANGLE(VertexAttrib3svNV)
#define glVertexAttrib4bvARB		MANGLE(VertexAttrib4bvARB)
#define glVertexAttrib4bv		MANGLE(VertexAttrib4bv)
#define glVertexAttrib4dARB		MANGLE(VertexAttrib4dARB)
#define glVertexAttrib4d		MANGLE(VertexAttrib4d)
#define glVertexAttrib4dNV		MANGLE(VertexAttrib4dNV)
#define glVertexAttrib4dvARB		MANGLE(VertexAttrib4dvARB)
#define glVertexAttrib4dv		MANGLE(VertexAttrib4dv)
#define glVertexAttrib4dvNV		MANGLE(VertexAttrib4dvNV)
#define glVertexAttrib4fARB		MANGLE(VertexAttrib4fARB)
#define glVertexAttrib4f		MANGLE(VertexAttrib4f)
#define glVertexAttrib4fNV		MANGLE(VertexAttrib4fNV)
#define glVertexAttrib4fvARB		MANGLE(VertexAttrib4fvARB)
#define glVertexAttrib4fv		MANGLE(VertexAttrib4fv)
#define glVertexAttrib4fvNV		MANGLE(VertexAttrib4fvNV)
#define glVertexAttrib4hNV		MANGLE(VertexAttrib4hNV)
#define glVertexAttrib4hvNV		MANGLE(VertexAttrib4hvNV)
#define glVertexAttrib4ivARB		MANGLE(VertexAttrib4ivARB)
#define glVertexAttrib4iv		MANGLE(VertexAttrib4iv)
#define glVertexAttrib4NbvARB		MANGLE(VertexAttrib4NbvARB)
#define glVertexAttrib4Nbv		MANGLE(VertexAttrib4Nbv)
#define glVertexAttrib4NivARB		MANGLE(VertexAttrib4NivARB)
#define glVertexAttrib4Niv		MANGLE(VertexAttrib4Niv)
#define glVertexAttrib4NsvARB		MANGLE(VertexAttrib4NsvARB)
#define glVertexAttrib4Nsv		MANGLE(VertexAttrib4Nsv)
#define glVertexAttrib4NubARB		MANGLE(VertexAttrib4NubARB)
#define glVertexAttrib4Nub		MANGLE(VertexAttrib4Nub)
#define glVertexAttrib4NubvARB		MANGLE(VertexAttrib4NubvARB)
#define glVertexAttrib4Nubv		MANGLE(VertexAttrib4Nubv)
#define glVertexAttrib4NuivARB		MANGLE(VertexAttrib4NuivARB)
#define glVertexAttrib4Nuiv		MANGLE(VertexAttrib4Nuiv)
#define glVertexAttrib4NusvARB		MANGLE(VertexAttrib4NusvARB)
#define glVertexAttrib4Nusv		MANGLE(VertexAttrib4Nusv)
#define glVertexAttrib4sARB		MANGLE(VertexAttrib4sARB)
#define glVertexAttrib4s		MANGLE(VertexAttrib4s)
#define glVertexAttrib4sNV		MANGLE(VertexAttrib4sNV)
#define glVertexAttrib4svARB		MANGLE(VertexAttrib4svARB)
#define glVertexAttrib4sv		MANGLE(VertexAttrib4sv)
#define glVertexAttrib4svNV		MANGLE(VertexAttrib4svNV)
#define glVertexAttrib4ubNV		MANGLE(VertexAttrib4ubNV)
#define glVertexAttrib4ubvARB		MANGLE(VertexAttrib4ubvARB)
#define glVertexAttrib4ubv		MANGLE(VertexAttrib4ubv)
#define glVertexAttrib4ubvNV		MANGLE(VertexAttrib4ubvNV)
#define glVertexAttrib4uivARB		MANGLE(VertexAttrib4uivARB)
#define glVertexAttrib4uiv		MANGLE(VertexAttrib4uiv)
#define glVertexAttrib4usvARB		MANGLE(VertexAttrib4usvARB)
#define glVertexAttrib4usv		MANGLE(VertexAttrib4usv)
#define glVertexAttribArrayObjectATI		MANGLE(VertexAttribArrayObjectATI)
#define glVertexAttribDivisorARB		MANGLE(VertexAttribDivisorARB)
#define glVertexAttribFormatNV		MANGLE(VertexAttribFormatNV)
#define glVertexAttribI1iEXT		MANGLE(VertexAttribI1iEXT)
#define glVertexAttribI1i		MANGLE(VertexAttribI1i)
#define glVertexAttribI1ivEXT		MANGLE(VertexAttribI1ivEXT)
#define glVertexAttribI1iv		MANGLE(VertexAttribI1iv)
#define glVertexAttribI1uiEXT		MANGLE(VertexAttribI1uiEXT)
#define glVertexAttribI1ui		MANGLE(VertexAttribI1ui)
#define glVertexAttribI1uivEXT		MANGLE(VertexAttribI1uivEXT)
#define glVertexAttribI1uiv		MANGLE(VertexAttribI1uiv)
#define glVertexAttribI2iEXT		MANGLE(VertexAttribI2iEXT)
#define glVertexAttribI2i		MANGLE(VertexAttribI2i)
#define glVertexAttribI2ivEXT		MANGLE(VertexAttribI2ivEXT)
#define glVertexAttribI2iv		MANGLE(VertexAttribI2iv)
#define glVertexAttribI2uiEXT		MANGLE(VertexAttribI2uiEXT)
#define glVertexAttribI2ui		MANGLE(VertexAttribI2ui)
#define glVertexAttribI2uivEXT		MANGLE(VertexAttribI2uivEXT)
#define glVertexAttribI2uiv		MANGLE(VertexAttribI2uiv)
#define glVertexAttribI3iEXT		MANGLE(VertexAttribI3iEXT)
#define glVertexAttribI3i		MANGLE(VertexAttribI3i)
#define glVertexAttribI3ivEXT		MANGLE(VertexAttribI3ivEXT)
#define glVertexAttribI3iv		MANGLE(VertexAttribI3iv)
#define glVertexAttribI3uiEXT		MANGLE(VertexAttribI3uiEXT)
#define glVertexAttribI3ui		MANGLE(VertexAttribI3ui)
#define glVertexAttribI3uivEXT		MANGLE(VertexAttribI3uivEXT)
#define glVertexAttribI3uiv		MANGLE(VertexAttribI3uiv)
#define glVertexAttribI4bvEXT		MANGLE(VertexAttribI4bvEXT)
#define glVertexAttribI4bv		MANGLE(VertexAttribI4bv)
#define glVertexAttribI4iEXT		MANGLE(VertexAttribI4iEXT)
#define glVertexAttribI4i		MANGLE(VertexAttribI4i)
#define glVertexAttribI4ivEXT		MANGLE(VertexAttribI4ivEXT)
#define glVertexAttribI4iv		MANGLE(VertexAttribI4iv)
#define glVertexAttribI4svEXT		MANGLE(VertexAttribI4svEXT)
#define glVertexAttribI4sv		MANGLE(VertexAttribI4sv)
#define glVertexAttribI4ubvEXT		MANGLE(VertexAttribI4ubvEXT)
#define glVertexAttribI4ubv		MANGLE(VertexAttribI4ubv)
#define glVertexAttribI4uiEXT		MANGLE(VertexAttribI4uiEXT)
#define glVertexAttribI4ui		MANGLE(VertexAttribI4ui)
#define glVertexAttribI4uivEXT		MANGLE(VertexAttribI4uivEXT)
#define glVertexAttribI4uiv		MANGLE(VertexAttribI4uiv)
#define glVertexAttribI4usvEXT		MANGLE(VertexAttribI4usvEXT)
#define glVertexAttribI4usv		MANGLE(VertexAttribI4usv)
#define glVertexAttribIFormatNV		MANGLE(VertexAttribIFormatNV)
#define glVertexAttribIPointerEXT		MANGLE(VertexAttribIPointerEXT)
#define glVertexAttribIPointer		MANGLE(VertexAttribIPointer)
#define glVertexAttribPointerARB		MANGLE(VertexAttribPointerARB)
#define glVertexAttribPointer		MANGLE(VertexAttribPointer)
#define glVertexAttribPointerNV		MANGLE(VertexAttribPointerNV)
#define glVertexAttribs1dvNV		MANGLE(VertexAttribs1dvNV)
#define glVertexAttribs1fvNV		MANGLE(VertexAttribs1fvNV)
#define glVertexAttribs1hvNV		MANGLE(VertexAttribs1hvNV)
#define glVertexAttribs1svNV		MANGLE(VertexAttribs1svNV)
#define glVertexAttribs2dvNV		MANGLE(VertexAttribs2dvNV)
#define glVertexAttribs2fvNV		MANGLE(VertexAttribs2fvNV)
#define glVertexAttribs2hvNV		MANGLE(VertexAttribs2hvNV)
#define glVertexAttribs2svNV		MANGLE(VertexAttribs2svNV)
#define glVertexAttribs3dvNV		MANGLE(VertexAttribs3dvNV)
#define glVertexAttribs3fvNV		MANGLE(VertexAttribs3fvNV)
#define glVertexAttribs3hvNV		MANGLE(VertexAttribs3hvNV)
#define glVertexAttribs3svNV		MANGLE(VertexAttribs3svNV)
#define glVertexAttribs4dvNV		MANGLE(VertexAttribs4dvNV)
#define glVertexAttribs4fvNV		MANGLE(VertexAttribs4fvNV)
#define glVertexAttribs4hvNV		MANGLE(VertexAttribs4hvNV)
#define glVertexAttribs4svNV		MANGLE(VertexAttribs4svNV)
#define glVertexAttribs4ubvNV		MANGLE(VertexAttribs4ubvNV)
#define glVertexBlendARB		MANGLE(VertexBlendARB)
#define glVertexBlendEnvfATI		MANGLE(VertexBlendEnvfATI)
#define glVertexBlendEnviATI		MANGLE(VertexBlendEnviATI)
#define glVertexFormatNV		MANGLE(VertexFormatNV)
#define glVertexPointerEXT		MANGLE(VertexPointerEXT)
#define glVertexPointerListIBM		MANGLE(VertexPointerListIBM)
#define glVertexPointer		MANGLE(VertexPointer)
#define glVertexPointervINTEL		MANGLE(VertexPointervINTEL)
#define glVertexStream1dATI		MANGLE(VertexStream1dATI)
#define glVertexStream1dvATI		MANGLE(VertexStream1dvATI)
#define glVertexStream1fATI		MANGLE(VertexStream1fATI)
#define glVertexStream1fvATI		MANGLE(VertexStream1fvATI)
#define glVertexStream1iATI		MANGLE(VertexStream1iATI)
#define glVertexStream1ivATI		MANGLE(VertexStream1ivATI)
#define glVertexStream1sATI		MANGLE(VertexStream1sATI)
#define glVertexStream1svATI		MANGLE(VertexStream1svATI)
#define glVertexStream2dATI		MANGLE(VertexStream2dATI)
#define glVertexStream2dvATI		MANGLE(VertexStream2dvATI)
#define glVertexStream2fATI		MANGLE(VertexStream2fATI)
#define glVertexStream2fvATI		MANGLE(VertexStream2fvATI)
#define glVertexStream2iATI		MANGLE(VertexStream2iATI)
#define glVertexStream2ivATI		MANGLE(VertexStream2ivATI)
#define glVertexStream2sATI		MANGLE(VertexStream2sATI)
#define glVertexStream2svATI		MANGLE(VertexStream2svATI)
#define glVertexStream3dATI		MANGLE(VertexStream3dATI)
#define glVertexStream3dvATI		MANGLE(VertexStream3dvATI)
#define glVertexStream3fATI		MANGLE(VertexStream3fATI)
#define glVertexStream3fvATI		MANGLE(VertexStream3fvATI)
#define glVertexStream3iATI		MANGLE(VertexStream3iATI)
#define glVertexStream3ivATI		MANGLE(VertexStream3ivATI)
#define glVertexStream3sATI		MANGLE(VertexStream3sATI)
#define glVertexStream3svATI		MANGLE(VertexStream3svATI)
#define glVertexStream4dATI		MANGLE(VertexStream4dATI)
#define glVertexStream4dvATI		MANGLE(VertexStream4dvATI)
#define glVertexStream4fATI		MANGLE(VertexStream4fATI)
#define glVertexStream4fvATI		MANGLE(VertexStream4fvATI)
#define glVertexStream4iATI		MANGLE(VertexStream4iATI)
#define glVertexStream4ivATI		MANGLE(VertexStream4ivATI)
#define glVertexStream4sATI		MANGLE(VertexStream4sATI)
#define glVertexStream4svATI		MANGLE(VertexStream4svATI)
#define glVertexWeightfEXT		MANGLE(VertexWeightfEXT)
#define glVertexWeightfvEXT		MANGLE(VertexWeightfvEXT)
#define glVertexWeighthNV		MANGLE(VertexWeighthNV)
#define glVertexWeighthvNV		MANGLE(VertexWeighthvNV)
#define glVertexWeightPointerEXT		MANGLE(VertexWeightPointerEXT)
#define glVideoCaptureNV		MANGLE(VideoCaptureNV)
#define glVideoCaptureStreamParameterdvNV		MANGLE(VideoCaptureStreamParameterdvNV)
#define glVideoCaptureStreamParameterfvNV		MANGLE(VideoCaptureStreamParameterfvNV)
#define glVideoCaptureStreamParameterivNV		MANGLE(VideoCaptureStreamParameterivNV)
#define glViewport		MANGLE(Viewport)
#define glWaitSync		MANGLE(WaitSync)
#define glWeightbvARB		MANGLE(WeightbvARB)
#define glWeightdvARB		MANGLE(WeightdvARB)
#define glWeightfvARB		MANGLE(WeightfvARB)
#define glWeightivARB		MANGLE(WeightivARB)
#define glWeightPointerARB		MANGLE(WeightPointerARB)
#define glWeightsvARB		MANGLE(WeightsvARB)
#define glWeightubvARB		MANGLE(WeightubvARB)
#define glWeightuivARB		MANGLE(WeightuivARB)
#define glWeightusvARB		MANGLE(WeightusvARB)
#define glWindowPos2dARB		MANGLE(WindowPos2dARB)
#define glWindowPos2d		MANGLE(WindowPos2d)
#define glWindowPos2dMESA		MANGLE(WindowPos2dMESA)
#define glWindowPos2dvARB		MANGLE(WindowPos2dvARB)
#define glWindowPos2dv		MANGLE(WindowPos2dv)
#define glWindowPos2dvMESA		MANGLE(WindowPos2dvMESA)
#define glWindowPos2fARB		MANGLE(WindowPos2fARB)
#define glWindowPos2f		MANGLE(WindowPos2f)
#define glWindowPos2fMESA		MANGLE(WindowPos2fMESA)
#define glWindowPos2fvARB		MANGLE(WindowPos2fvARB)
#define glWindowPos2fv		MANGLE(WindowPos2fv)
#define glWindowPos2fvMESA		MANGLE(WindowPos2fvMESA)
#define glWindowPos2iARB		MANGLE(WindowPos2iARB)
#define glWindowPos2i		MANGLE(WindowPos2i)
#define glWindowPos2iMESA		MANGLE(WindowPos2iMESA)
#define glWindowPos2ivARB		MANGLE(WindowPos2ivARB)
#define glWindowPos2iv		MANGLE(WindowPos2iv)
#define glWindowPos2ivMESA		MANGLE(WindowPos2ivMESA)
#define glWindowPos2sARB		MANGLE(WindowPos2sARB)
#define glWindowPos2s		MANGLE(WindowPos2s)
#define glWindowPos2sMESA		MANGLE(WindowPos2sMESA)
#define glWindowPos2svARB		MANGLE(WindowPos2svARB)
#define glWindowPos2sv		MANGLE(WindowPos2sv)
#define glWindowPos2svMESA		MANGLE(WindowPos2svMESA)
#define glWindowPos3dARB		MANGLE(WindowPos3dARB)
#define glWindowPos3d		MANGLE(WindowPos3d)
#define glWindowPos3dMESA		MANGLE(WindowPos3dMESA)
#define glWindowPos3dvARB		MANGLE(WindowPos3dvARB)
#define glWindowPos3dv		MANGLE(WindowPos3dv)
#define glWindowPos3dvMESA		MANGLE(WindowPos3dvMESA)
#define glWindowPos3fARB		MANGLE(WindowPos3fARB)
#define glWindowPos3f		MANGLE(WindowPos3f)
#define glWindowPos3fMESA		MANGLE(WindowPos3fMESA)
#define glWindowPos3fvARB		MANGLE(WindowPos3fvARB)
#define glWindowPos3fv		MANGLE(WindowPos3fv)
#define glWindowPos3fvMESA		MANGLE(WindowPos3fvMESA)
#define glWindowPos3iARB		MANGLE(WindowPos3iARB)
#define glWindowPos3i		MANGLE(WindowPos3i)
#define glWindowPos3iMESA		MANGLE(WindowPos3iMESA)
#define glWindowPos3ivARB		MANGLE(WindowPos3ivARB)
#define glWindowPos3iv		MANGLE(WindowPos3iv)
#define glWindowPos3ivMESA		MANGLE(WindowPos3ivMESA)
#define glWindowPos3sARB		MANGLE(WindowPos3sARB)
#define glWindowPos3s		MANGLE(WindowPos3s)
#define glWindowPos3sMESA		MANGLE(WindowPos3sMESA)
#define glWindowPos3svARB		MANGLE(WindowPos3svARB)
#define glWindowPos3sv		MANGLE(WindowPos3sv)
#define glWindowPos3svMESA		MANGLE(WindowPos3svMESA)
#define glWindowPos4dMESA		MANGLE(WindowPos4dMESA)
#define glWindowPos4dvMESA		MANGLE(WindowPos4dvMESA)
#define glWindowPos4fMESA		MANGLE(WindowPos4fMESA)
#define glWindowPos4fvMESA		MANGLE(WindowPos4fvMESA)
#define glWindowPos4iMESA		MANGLE(WindowPos4iMESA)
#define glWindowPos4ivMESA		MANGLE(WindowPos4ivMESA)
#define glWindowPos4sMESA		MANGLE(WindowPos4sMESA)
#define glWindowPos4svMESA		MANGLE(WindowPos4svMESA)
#define glWriteMaskEXT		MANGLE(WriteMaskEXT)

#endif /* GL_MANGLE_H */

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hi, Geoff

On Wed, Dec 21, 2011 at 09:33:09PM +0800, Geoff Gole wrote:
> If another data point will help, I've also noticed *very* slow c-mode
> fontification in a script generated header,
> /usr/include/GL/gl_mangle.h. In case you don't have this header, a
> copy is attached.

> The file is basically several thousand #defines.

Thanks for the report.

The problem here is that CC Mode normally steps back and forth through a
source code using brace positions as "ladder rungs".  A sequence of
#defines is, sadly, a "brace desert".

If you're running GNU Emacs, an optimisation was introduced in Emacs
23.3 which gave a considerable speed-up to such code.  This optimisation
found its way into the XEmacs CC Mode package in September.  I _hope_
your version of Emacs is prior to one of these, in which case upgrading
will give you this benefit.

Otherwise, I'll be asking you if you're prepared to give me some
timings.

Here's hoping.....

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Geoff Gole]

> If you're running GNU Emacs, an optimisation was introduced in Emacs
> 23.3 which gave a considerable speed-up to such code.  This optimisation
> found its way into the XEmacs CC Mode package in September.  I _hope_
> your version of Emacs is prior to one of these, in which case upgrading
> will give you this benefit.
>
> Otherwise, I'll be asking you if you're prepared to give me some
> timings.

Well, M-x version gives me GNU Emacs 24.0.91.1 (i686-pc-linux-gnu,
GTK+ Version 2.12.12) of 2011-11-18, and cc-defs.el has c-version at
5.32.2.

I'd be happy to produce timings. What do you need?

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hi, Geoff.

On Thu, Dec 22, 2011 at 12:48:53AM +0800, Geoff Gole wrote:
> > If you're running GNU Emacs, an optimisation was introduced in Emacs
> > 23.3 which gave a considerable speed-up to such code.  This optimisation
> > found its way into the XEmacs CC Mode package in September.  I _hope_
> > your version of Emacs is prior to one of these, in which case upgrading
> > will give you this benefit.

> > Otherwise, I'll be asking you if you're prepared to give me some
> > timings.

> Well, M-x version gives me GNU Emacs 24.0.91.1 (i686-pc-linux-gnu,
> GTK+ Version 2.12.12) of 2011-11-18, and cc-defs.el has c-version at
> 5.32.2.

> I'd be happy to produce timings. What do you need?

Let's just agree on what we mean by "very slow".  I've just loaded
gl_mangle.h into an Emacs 24 pretest.  I've got a 2.6 GHz Athlon II
processor.  On doing M->, followed by scrolling a up a page at a time,
each operation is taking me less than 1 second.  Of course, once a page
gets fontified, scrolling over it then becomes instantaneous.

How fast/slow is this scrolling on your hardware/software?

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Eli Zaretskii]

> Date: Wed, 21 Dec 2011 21:33:09 +0800
> From: Geoff Gole <geoffgole@gmail.com>
> Cc: Kan-Ru Chen <kanru@kanru.info>, emacs-devel@gnu.org
> 
> If another data point will help, I've also noticed *very* slow c-mode
> fontification in a script generated header,
> /usr/include/GL/gl_mangle.h. In case you don't have this header, a
> copy is attached.
> 
> The file is basically several thousand #defines.

FWIW, it's not particularly slow on my 6.5-year old hardware.  Much
faster than the previous data point.

Re: Slow fontification in C mode buffers

[Geoff Gole]

> How fast/slow is this scrolling on your hardware/software?

If I start an emacs -q, open the header in question, M->, M-v, emacs
takes a bit more than 2 minutes to respond. Scrolling in the fontified
area is smooth after this initial work. I see similar timings for
emacs -q -nw.

After M-x font-lock-mode scrolling is essentially instantaneous in
both those configurations.

I suspect hardware doesn't have much to do with this issue, but for
what it's worth I'm running on a core 2 duo.

> FWIW, it's not particularly slow on my 6.5-year old hardware. Much
faster than the previous data point.

Interesting. What version of emacs and cc-mode are you using?

Re: Slow fontification in C mode buffers

[Eli Zaretskii]

> Date: Thu, 22 Dec 2011 02:32:08 +0800
> From: Geoff Gole <geoffgole@gmail.com>
> Cc: acm@muc.de, kanru@kanru.info, emacs-devel@gnu.org
> 
> > FWIW, it's not particularly slow on my 6.5-year old hardware. Much
> faster than the previous data point.
> 
> Interesting. What version of emacs and cc-mode are you using?

The latest trunk.

I now tried with 24.0.91, and there indeed M-> is much slower, more
than 2 minutes on my machine.

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Alan Mackenzie <acm@muc.de> writes:

> It looks like my latest change is saving ~25% of the runtime.  That is
> not enough, not nearly enough.  Also, your hardware is _much_ faster than
> mine.  ;-)

In front of this file, the speed of the hardware seems less important
;-)

> This is going to be a lot of work, and I'm not going to be able to get it
> finished this year.  Sorry.  But I'm sure the bug can be fixed.  
>
> In the meantime, I suggest turning font-lock off for this file.

Thanks. Please take you time. I will blacklist this file.

-- 
Kanru

Re: Slow fontification in C mode buffers

[Kentaro NAKAZAWA]

[-- Attachment #1: Type: text/plain, Size: 431 bytes --]

Hello. (sorry for my poor english ;)

Other pattern attached.
The file is very heavy at edit and undo.


Geoff Gole <geoffgole@gmail.com> writes:

> If another data point will help, I've also noticed *very* slow c-mode
> fontification in a script generated header,
> /usr/include/GL/gl_mangle.h. In case you don't have this header, a
> copy is attached.
>
> The file is basically several thousand #defines.
>

-- 
Kentaro Nakazawa

[-- Attachment #2: attribute.h --]
[-- Type: text/plain, Size: 13524 bytes --]

// -*- mode: c++ -*-

namespace NameSpace1 {
  namespace NameSpace2 {

    enum {
      kFooBarBazType_Attribute0000	= 0x0000,	// Comment0000
      kFooBarBazType_Attribute0001	= 0x0001,	// Comment0001
      kFooBarBazType_Attribute0002	= 0x0002,	// Comment0002
      kFooBarBazType_Attribute0003	= 0x0003,	// Comment0003
      kFooBarBazType_Attribute0004	= 0x0004,	// Comment0004
      kFooBarBazType_Attribute0005	= 0x0005,	// Comment0005
      kFooBarBazType_Attribute0006	= 0x0006,	// Comment0006
      kFooBarBazType_Attribute0007	= 0x0007,	// Comment0007
      kFooBarBazType_Attribute0008	= 0x0008,	// Comment0008
      kFooBarBazType_Attribute0009	= 0x0009,	// Comment0009
      kFooBarBazType_Attribute0010	= 0x000a,	// Comment0010
      kFooBarBazType_Attribute0011	= 0x000b,	// Comment0011
      kFooBarBazType_Attribute0012	= 0x000c,	// Comment0012
      kFooBarBazType_Attribute0013	= 0x000d,	// Comment0013
      kFooBarBazType_Attribute0014	= 0x000e,	// Comment0014
      kFooBarBazType_Attribute0015	= 0x000f,	// Comment0015
      kFooBarBazType_Attribute0016	= 0x0010,	// Comment0016
      kFooBarBazType_Attribute0017	= 0x0011,	// Comment0017
      kFooBarBazType_Attribute0018	= 0x0012,	// Comment0018
      kFooBarBazType_Attribute0019	= 0x0013,	// Comment0019
      kFooBarBazType_Attribute0020	= 0x0014,	// Comment0020
      kFooBarBazType_Attribute0021	= 0x0015,	// Comment0021
      kFooBarBazType_Attribute0022	= 0x0016,	// Comment0022
      kFooBarBazType_Attribute0023	= 0x0017,	// Comment0023
      kFooBarBazType_Attribute0024	= 0x0018,	// Comment0024
      kFooBarBazType_Attribute0025	= 0x0019,	// Comment0025
      kFooBarBazType_Attribute0026	= 0x001a,	// Comment0026
      kFooBarBazType_Attribute0027	= 0x001b,	// Comment0027
      kFooBarBazType_Attribute0028	= 0x001c,	// Comment0028
      kFooBarBazType_Attribute0029	= 0x001d,	// Comment0029
      kFooBarBazType_Attribute0030	= 0x001e,	// Comment0030
      kFooBarBazType_Attribute0031	= 0x001f,	// Comment0031
      kFooBarBazType_Attribute0032	= 0x0020,	// Comment0032
      kFooBarBazType_Attribute0033	= 0x0021,	// Comment0033
      kFooBarBazType_Attribute0034	= 0x0022,	// Comment0034
      kFooBarBazType_Attribute0035	= 0x0023,	// Comment0035
      kFooBarBazType_Attribute0036	= 0x0024,	// Comment0036
      kFooBarBazType_Attribute0037	= 0x0025,	// Comment0037
      kFooBarBazType_Attribute0038	= 0x0026,	// Comment0038
      kFooBarBazType_Attribute0039	= 0x0027,	// Comment0039
      kFooBarBazType_Attribute0040	= 0x0028,	// Comment0040
      kFooBarBazType_Attribute0041	= 0x0029,	// Comment0041
      kFooBarBazType_Attribute0042	= 0x002a,	// Comment0042
      kFooBarBazType_Attribute0043	= 0x002b,	// Comment0043
      kFooBarBazType_Attribute0044	= 0x002c,	// Comment0044
      kFooBarBazType_Attribute0045	= 0x002d,	// Comment0045
      kFooBarBazType_Attribute0046	= 0x002e,	// Comment0046
      kFooBarBazType_Attribute0047	= 0x002f,	// Comment0047
      kFooBarBazType_Attribute0048	= 0x0030,	// Comment0048
      kFooBarBazType_Attribute0049	= 0x0031,	// Comment0049
      kFooBarBazType_Attribute0050	= 0x0032,	// Comment0050
      kFooBarBazType_Attribute0051	= 0x0033,	// Comment0051
      kFooBarBazType_Attribute0052	= 0x0034,	// Comment0052
      kFooBarBazType_Attribute0053	= 0x0035,	// Comment0053
      kFooBarBazType_Attribute0054	= 0x0036,	// Comment0054
      kFooBarBazType_Attribute0055	= 0x0037,	// Comment0055
      kFooBarBazType_Attribute0056	= 0x0038,	// Comment0056
      kFooBarBazType_Attribute0057	= 0x0039,	// Comment0057
      kFooBarBazType_Attribute0058	= 0x003a,	// Comment0058
      kFooBarBazType_Attribute0059	= 0x003b,	// Comment0059
      kFooBarBazType_Attribute0060	= 0x003c,	// Comment0060
      kFooBarBazType_Attribute0061	= 0x003d,	// Comment0061
      kFooBarBazType_Attribute0062	= 0x003e,	// Comment0062
      kFooBarBazType_Attribute0063	= 0x003f,	// Comment0063
      kFooBarBazType_Attribute0064	= 0x0040,	// Comment0064
      kFooBarBazType_Attribute0065	= 0x0041,	// Comment0065
      kFooBarBazType_Attribute0066	= 0x0042,	// Comment0066
      kFooBarBazType_Attribute0067	= 0x0043,	// Comment0067
      kFooBarBazType_Attribute0068	= 0x0044,	// Comment0068
      kFooBarBazType_Attribute0069	= 0x0045,	// Comment0069
      kFooBarBazType_Attribute0070	= 0x0046,	// Comment0070
      kFooBarBazType_Attribute0071	= 0x0047,	// Comment0071
      kFooBarBazType_Attribute0072	= 0x0048,	// Comment0072
      kFooBarBazType_Attribute0073	= 0x0049,	// Comment0073
      kFooBarBazType_Attribute0074	= 0x004a,	// Comment0074
      kFooBarBazType_Attribute0075	= 0x004b,	// Comment0075
      kFooBarBazType_Attribute0076	= 0x004c,	// Comment0076
      kFooBarBazType_Attribute0077	= 0x004d,	// Comment0077
      kFooBarBazType_Attribute0078	= 0x004e,	// Comment0078
      kFooBarBazType_Attribute0079	= 0x004f,	// Comment0079
      kFooBarBazType_Attribute0080	= 0x0050,	// Comment0080
      kFooBarBazType_Attribute0081	= 0x0051,	// Comment0081
      kFooBarBazType_Attribute0082	= 0x0052,	// Comment0082
      kFooBarBazType_Attribute0083	= 0x0053,	// Comment0083
      kFooBarBazType_Attribute0084	= 0x0054,	// Comment0084
      kFooBarBazType_Attribute0085	= 0x0055,	// Comment0085
      kFooBarBazType_Attribute0086	= 0x0056,	// Comment0086
      kFooBarBazType_Attribute0087	= 0x0057,	// Comment0087
      kFooBarBazType_Attribute0088	= 0x0058,	// Comment0088
      kFooBarBazType_Attribute0089	= 0x0059,	// Comment0089
      kFooBarBazType_Attribute0090	= 0x005a,	// Comment0090
      kFooBarBazType_Attribute0091	= 0x005b,	// Comment0091
      kFooBarBazType_Attribute0092	= 0x005c,	// Comment0092
      kFooBarBazType_Attribute0093	= 0x005d,	// Comment0093
      kFooBarBazType_Attribute0094	= 0x005e,	// Comment0094
      kFooBarBazType_Attribute0095	= 0x005f,	// Comment0095
      kFooBarBazType_Attribute0096	= 0x0060,	// Comment0096
      kFooBarBazType_Attribute0097	= 0x0061,	// Comment0097
      kFooBarBazType_Attribute0098	= 0x0062,	// Comment0098
      kFooBarBazType_Attribute0099	= 0x0063,	// Comment0099
      kFooBarBazType_Attribute0100	= 0x0064,	// Comment0100
      kFooBarBazType_Attribute0101	= 0x0065,	// Comment0101
      kFooBarBazType_Attribute0102	= 0x0066,	// Comment0102
      kFooBarBazType_Attribute0103	= 0x0067,	// Comment0103
      kFooBarBazType_Attribute0104	= 0x0068,	// Comment0104
      kFooBarBazType_Attribute0105	= 0x0069,	// Comment0105
      kFooBarBazType_Attribute0106	= 0x006a,	// Comment0106
      kFooBarBazType_Attribute0107	= 0x006b,	// Comment0107
      kFooBarBazType_Attribute0108	= 0x006c,	// Comment0108
      kFooBarBazType_Attribute0109	= 0x006d,	// Comment0109
      kFooBarBazType_Attribute0110	= 0x006e,	// Comment0110
      kFooBarBazType_Attribute0111	= 0x006f,	// Comment0111
      kFooBarBazType_Attribute0112	= 0x0070,	// Comment0112
      kFooBarBazType_Attribute0113	= 0x0071,	// Comment0113
      kFooBarBazType_Attribute0114	= 0x0072,	// Comment0114
      kFooBarBazType_Attribute0115	= 0x0073,	// Comment0115
      kFooBarBazType_Attribute0116	= 0x0074,	// Comment0116
      kFooBarBazType_Attribute0117	= 0x0075,	// Comment0117
      kFooBarBazType_Attribute0118	= 0x0076,	// Comment0118
      kFooBarBazType_Attribute0119	= 0x0077,	// Comment0119
      kFooBarBazType_Attribute0120	= 0x0078,	// Comment0120
      kFooBarBazType_Attribute0121	= 0x0079,	// Comment0121
      kFooBarBazType_Attribute0122	= 0x007a,	// Comment0122
      kFooBarBazType_Attribute0123	= 0x007b,	// Comment0123
      kFooBarBazType_Attribute0124	= 0x007c,	// Comment0124
      kFooBarBazType_Attribute0125	= 0x007d,	// Comment0125
      kFooBarBazType_Attribute0126	= 0x007e,	// Comment0126
      kFooBarBazType_Attribute0127	= 0x007f,	// Comment0127
      kFooBarBazType_Attribute0128	= 0x0080,	// Comment0128
      kFooBarBazType_Attribute0129	= 0x0081,	// Comment0129
      kFooBarBazType_Attribute0130	= 0x0082,	// Comment0130
      kFooBarBazType_Attribute0131	= 0x0083,	// Comment0131
      kFooBarBazType_Attribute0132	= 0x0084,	// Comment0132
      kFooBarBazType_Attribute0133	= 0x0085,	// Comment0133
      kFooBarBazType_Attribute0134	= 0x0086,	// Comment0134
      kFooBarBazType_Attribute0135	= 0x0087,	// Comment0135
      kFooBarBazType_Attribute0136	= 0x0088,	// Comment0136
      kFooBarBazType_Attribute0137	= 0x0089,	// Comment0137
      kFooBarBazType_Attribute0138	= 0x008a,	// Comment0138
      kFooBarBazType_Attribute0139	= 0x008b,	// Comment0139
      kFooBarBazType_Attribute0140	= 0x008c,	// Comment0140
      kFooBarBazType_Attribute0141	= 0x008d,	// Comment0141
      kFooBarBazType_Attribute0142	= 0x008e,	// Comment0142
      kFooBarBazType_Attribute0143	= 0x008f,	// Comment0143
      kFooBarBazType_Attribute0144	= 0x0090,	// Comment0144
      kFooBarBazType_Attribute0145	= 0x0091,	// Comment0145
      kFooBarBazType_Attribute0146	= 0x0092,	// Comment0146
      kFooBarBazType_Attribute0147	= 0x0093,	// Comment0147
      kFooBarBazType_Attribute0148	= 0x0094,	// Comment0148
      kFooBarBazType_Attribute0149	= 0x0095,	// Comment0149
      kFooBarBazType_Attribute0150	= 0x0096,	// Comment0150
      kFooBarBazType_Attribute0151	= 0x0097,	// Comment0151
      kFooBarBazType_Attribute0152	= 0x0098,	// Comment0152
      kFooBarBazType_Attribute0153	= 0x0099,	// Comment0153
      kFooBarBazType_Attribute0154	= 0x009a,	// Comment0154
      kFooBarBazType_Attribute0155	= 0x009b,	// Comment0155
      kFooBarBazType_Attribute0156	= 0x009c,	// Comment0156
      kFooBarBazType_Attribute0157	= 0x009d,	// Comment0157
      kFooBarBazType_Attribute0158	= 0x009e,	// Comment0158
      kFooBarBazType_Attribute0159	= 0x009f,	// Comment0159
      kFooBarBazType_Attribute0160	= 0x00a0,	// Comment0160
      kFooBarBazType_Attribute0161	= 0x00a1,	// Comment0161
      kFooBarBazType_Attribute0162	= 0x00a2,	// Comment0162
      kFooBarBazType_Attribute0163	= 0x00a3,	// Comment0163
      kFooBarBazType_Attribute0164	= 0x00a4,	// Comment0164
      kFooBarBazType_Attribute0165	= 0x00a5,	// Comment0165
      kFooBarBazType_Attribute0166	= 0x00a6,	// Comment0166
      kFooBarBazType_Attribute0167	= 0x00a7,	// Comment0167
      kFooBarBazType_Attribute0168	= 0x00a8,	// Comment0168
      kFooBarBazType_Attribute0169	= 0x00a9,	// Comment0169
      kFooBarBazType_Attribute0170	= 0x00aa,	// Comment0170
      kFooBarBazType_Attribute0171	= 0x00ab,	// Comment0171
      kFooBarBazType_Attribute0172	= 0x00ac,	// Comment0172
      kFooBarBazType_Attribute0173	= 0x00ad,	// Comment0173
      kFooBarBazType_Attribute0174	= 0x00ae,	// Comment0174
      kFooBarBazType_Attribute0175	= 0x00af,	// Comment0175
      kFooBarBazType_Attribute0176	= 0x00b0,	// Comment0176
      kFooBarBazType_Attribute0177	= 0x00b1,	// Comment0177
      kFooBarBazType_Attribute0178	= 0x00b2,	// Comment0178
      kFooBarBazType_Attribute0179	= 0x00b3,	// Comment0179
      kFooBarBazType_Attribute0180	= 0x00b4,	// Comment0180
      kFooBarBazType_Attribute0181	= 0x00b5,	// Comment0181
      kFooBarBazType_Attribute0182	= 0x00b6,	// Comment0182
      kFooBarBazType_Attribute0183	= 0x00b7,	// Comment0183
      kFooBarBazType_Attribute0184	= 0x00b8,	// Comment0184
      kFooBarBazType_Attribute0185	= 0x00b9,	// Comment0185
      kFooBarBazType_Attribute0186	= 0x00ba,	// Comment0186
      kFooBarBazType_Attribute0187	= 0x00bb,	// Comment0187
      kFooBarBazType_Attribute0188	= 0x00bc,	// Comment0188
      kFooBarBazType_Attribute0189	= 0x00bd,	// Comment0189
      kFooBarBazType_Attribute0190	= 0x00be,	// Comment0190
      kFooBarBazType_Attribute0191	= 0x00bf,	// Comment0191
      kFooBarBazType_Attribute0192	= 0x00c0,	// Comment0192
      kFooBarBazType_Attribute0193	= 0x00c1,	// Comment0193
      kFooBarBazType_Attribute0194	= 0x00c2,	// Comment0194
      kFooBarBazType_Attribute0195	= 0x00c3,	// Comment0195
      kFooBarBazType_Attribute0196	= 0x00c4,	// Comment0196
      kFooBarBazType_Attribute0197	= 0x00c5,	// Comment0197
      kFooBarBazType_Attribute0198	= 0x00c6,	// Comment0198
      kFooBarBazType_Attribute0199	= 0x00c7,	// Comment0199
      kFooBarBazType_Attribute0200	= 0x00c8,	// Comment0200
      kFooBarBazType_Attribute0201	= 0x00c9,	// Comment0201
      kFooBarBazType_Attribute0202	= 0x00ca,	// Comment0202
      kFooBarBazType_Attribute0203	= 0x00cb,	// Comment0203
      kFooBarBazType_Attribute0204	= 0x00cc,	// Comment0204
      kFooBarBazType_Attribute0205	= 0x00cd,	// Comment0205
      kFooBarBazType_Attribute0206	= 0x00ce,	// Comment0206
      kFooBarBazType_Attribute0207	= 0x00cf,	// Comment0207
      kFooBarBazType_Attribute0208	= 0x00d0,	// Comment0208
      kFooBarBazType_Attribute0209	= 0x00d1,	// Comment0209
      kFooBarBazType_Attribute0210	= 0x00d2,	// Comment0210
      kFooBarBazType_Attribute0211	= 0x00d3,	// Comment0211
      kFooBarBazType_Attribute0212	= 0x00d4,	// Comment0212
      kFooBarBazType_Attribute0213	= 0x00d5,	// Comment0213
      kFooBarBazType_Attribute0214	= 0x00d6,	// Comment0214
      kFooBarBazType_Attribute0215	= 0x00d7,	// Comment0215
      kFooBarBazType_Attribute0216	= 0x00d8,	// Comment0216
      kFooBarBazType_Attribute0217	= 0x00d9,	// Comment0217
      kFooBarBazType_Attribute0218	= 0x00da,	// Comment0218
      kFooBarBazType_Attribute0219	= 0x00db,	// Comment0219
      kFooBarBazType_Attribute0220	= 0x00dc,	// Comment0220
      kFooBarBazType_Attribute0221	= 0x00dd,	// Comment0221
      kFooBarBazType_Attribute0222	= 0x00de,	// Comment0222
    };

  } // namespace Namespace2
} // namespace Namespace1

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kentaro.

On Fri, Dec 23, 2011 at 10:56:15AM +0900, Kentaro NAKAZAWA wrote:
> Hello. (sorry for my poor english ;)

> Other pattern attached.
> The file is very heavy at edit and undo.


> Geoff Gole <geoffgole@gmail.com> writes:

> > If another data point will help, I've also noticed *very* slow c-mode
> > fontification in a script generated header,
> > /usr/include/GL/gl_mangle.h. In case you don't have this header, a
> > copy is attached.

> > The file is basically several thousand #defines.

Thanks for reporting this problem.  I think I can see where the code
needs fixing.  I should be able to get this done early next year.

> -- 
> Kentaro Nakazawa

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kentaro.

On Fri, Dec 23, 2011 at 10:56:15AM +0900, Kentaro NAKAZAWA wrote:
> Hello. (sorry for my poor english ;)

> Other pattern attached.
> The file is very heavy at edit and undo.


> Geoff Gole <geoffgole@gmail.com> writes:

> > If another data point will help, I've also noticed *very* slow c-mode
> > fontification in a script generated header,
> > /usr/include/GL/gl_mangle.h. In case you don't have this header, a
> > copy is attached.

> > The file is basically several thousand #defines.


> // -*- mode: c++ -*-

> namespace NameSpace1 {
>   namespace NameSpace2 {

>     enum {
>       kFooBarBazType_Attribute0000	= 0x0000,	// Comment0000
>       kFooBarBazType_Attribute0001	= 0x0001,	// Comment0001
>       kFooBarBazType_Attribute0002	= 0x0002,	// Comment0002
>       kFooBarBazType_Attribute0003	= 0x0003,	// Comment0003
>
> [....]
>
>       kFooBarBazType_Attribute0220	= 0x00dc,	// Comment0220
>       kFooBarBazType_Attribute0221	= 0x00dd,	// Comment0221
>       kFooBarBazType_Attribute0222	= 0x00de,	// Comment0222
>     };

>   } // namespace Namespace2
> } // namespace Namespace1

Would you try this patch and let me know how it goes, please.


*** orig/cc-fonts.el	2012-01-06 12:27:14.000000000 +0000
--- cc-fonts.el	2012-01-06 21:48:54.000000000 +0000
***************
*** 1394,1399 ****
--- 1394,1414 ----
  	      (c-fontify-recorded-types-and-refs)
  	      nil)
  
+ 	     ((and (not c-enums-contain-decls)
+ 		   ;; An optimisation quickly to eliminate scans of long enum
+ 		   ;; declarations in the next cond arm.
+ 		   (let ((paren-state (c-parse-state)))
+ 		     (and
+ 		      (numberp (car paren-state))
+ 		      (save-excursion
+ 			(goto-char (car paren-state))
+ 			(c-backward-token-2)
+ 			(or (looking-at c-brace-list-key))
+ 			(progn
+ 			  (c-backward-token-2)
+ 			  (looking-at c-brace-list-key))))))
+ 	      t)
+ 
  	     (t
  	      ;; Are we at a declarator?  Try to go back to the declaration
  	      ;; to check this.  If we get there, check whether a "typedef"
*** orig/cc-langs.el	2012-01-06 12:27:14.000000000 +0000
--- cc-langs.el	2012-01-06 12:54:00.000000000 +0000
***************
*** 2930,2935 ****
--- 2930,2941 ----
  		    ; generics is not yet coded in CC Mode.
  (c-lang-defvar c-recognize-<>-arglists (c-lang-const c-recognize-<>-arglists))
  
+ (c-lang-defconst c-enums-contain-decls
+   "Non-nil means that an enum structure can contain declarations."
+   t nil
+   java t)
+ (c-lang-defvar c-enums-contain-decls (c-lang-const c-enums-contain-decls))
+ 
  (c-lang-defconst c-recognize-paren-inits
    "Non-nil means that parenthesis style initializers exist,
  i.e. constructs like



> -- 
> Kentaro Nakazawa

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kentaro NAKAZAWA]

Hello, Alan.

Alan Mackenzie <acm@muc.de> writes:

> Would you try this patch and let me know how it goes, please.
>
>
> *** orig/cc-fonts.el	2012-01-06 12:27:14.000000000 +0000
> --- cc-fonts.el	2012-01-06 21:48:54.000000000 +0000
> ***************
> *** 1394,1399 ****
> --- 1394,1414 ----
>   	      (c-fontify-recorded-types-and-refs)
>   	      nil)
>   
> + 	     ((and (not c-enums-contain-decls)
> + 		   ;; An optimisation quickly to eliminate scans of long enum
> + 		   ;; declarations in the next cond arm.
> + 		   (let ((paren-state (c-parse-state)))
> + 		     (and
> + 		      (numberp (car paren-state))
> + 		      (save-excursion
> + 			(goto-char (car paren-state))
> + 			(c-backward-token-2)
> + 			(or (looking-at c-brace-list-key))
> + 			(progn
> + 			  (c-backward-token-2)
> + 			  (looking-at c-brace-list-key))))))
> + 	      t)
> + 
>   	     (t
>   	      ;; Are we at a declarator?  Try to go back to the declaration
>   	      ;; to check this.  If we get there, check whether a "typedef"
> *** orig/cc-langs.el	2012-01-06 12:27:14.000000000 +0000
> --- cc-langs.el	2012-01-06 12:54:00.000000000 +0000
> ***************
> *** 2930,2935 ****
> --- 2930,2941 ----
>   		    ; generics is not yet coded in CC Mode.
>   (c-lang-defvar c-recognize-<>-arglists (c-lang-const c-recognize-<>-arglists))
>   
> + (c-lang-defconst c-enums-contain-decls
> +   "Non-nil means that an enum structure can contain declarations."
> +   t nil
> +   java t)
> + (c-lang-defvar c-enums-contain-decls (c-lang-const c-enums-contain-decls))
> + 
>   (c-lang-defconst c-recognize-paren-inits
>     "Non-nil means that parenthesis style initializers exist,
>   i.e. constructs like
>

Thank you for the patch.
I applied a patch, it came to be able to edit the attribute.h comfortably.
The original file with the problem is comfortable too.
However, some key words were not colored.

-- 
Kentaro Nakazawa

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hi, Kentaro,

On Sat, Jan 07, 2012 at 09:09:01AM +0900, Kentaro NAKAZAWA wrote:
> Hello, Alan.

> Alan Mackenzie <acm@muc.de> writes:

> > Would you try this patch and let me know how it goes, please.

[ .... ]

> Thank you for the patch.
> I applied a patch, it came to be able to edit the attribute.h comfortably.
> The original file with the problem is comfortable too.
> However, some key words were not colored.

Could you be more specific, please - tell me which keywords weren't
fontified, and exactly what you did for this to happen.

Thanks!

> -- 
> Kentaro Nakazawa

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kentaro NAKAZAWA]

[-- Attachment #1: Type: text/plain, Size: 413 bytes --]

Hello, Alan.

> Could you be more specific, please - tell me which keywords weren't
> fontified, and exactly what you did for this to happen.

The screen shot was appended. (emacs -Q)

action.cc.png:
http://ftp.gnome.org/pub/GNOME/sources/gtkmm/3.0/gtkmm-3.0.1.tar.bz2
gtkmm-3.0.1/gtk/gtkmm/action.cc

The method name is not fontified.
But I execute M-oM-o in function, fontified correctly.

-- 
Kentaro Nakazawa

[-- Attachment #2: attribute.h.png --]
[-- Type: image/png, Size: 232079 bytes --]

[-- Attachment #3: attribute.h.patched.png --]
[-- Type: image/png, Size: 211056 bytes --]

[-- Attachment #4: action.cc.png --]
[-- Type: image/png, Size: 105839 bytes --]

[-- Attachment #5: action.cc.patched.png --]
[-- Type: image/png, Size: 106373 bytes --]

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hi, Kentaro.

On Sun, Jan 08, 2012 at 10:26:10AM +0900, Kentaro NAKAZAWA wrote:
> Hello, Alan.

> > Could you be more specific, please - tell me which keywords weren't
> > fontified, and exactly what you did for this to happen.

> The screen shot was appended. (emacs -Q)

> action.cc.png:
> http://ftp.gnome.org/pub/GNOME/sources/gtkmm/3.0/gtkmm-3.0.1.tar.bz2
> gtkmm-3.0.1/gtk/gtkmm/action.cc

> The method name is not fontified.
> But I execute M-oM-o in function, fontified correctly.

OK.  I think that's a separate bug.  I'll commit the patch I sent you to
the Emacs trunk.  I'll look at the new bug afterwards.

> -- 
> Kentaro Nakazawa

-- 
Alan Mackenzie (Nuremberg, Germany)

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kanru.

On Sun, Dec 18, 2011 at 12:06:00AM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> Please forgive me for using the other files, it is closer to the real
> case. You can get the file from

> https://hg.mozilla.org/mozilla-central/raw-file/tip/dom/base/nsDOMClassInfo.cpp

That's some file.  ;-)

> (i) Loaded elp and instrumented the c- package.
> (ii) Loaded nsDOMClassInfo.cpp
> (iii) Done M-x c++-mode
> (iv) Done M-x elp-results (to clear the accumulated times)
> (v) C-s battery until failing to find 
> (vi) M-x elp-results.

> Before:

> c-beginning-of-decl-1                          201         13.065947999  0.0650047164
> c-beginning-of-statement-1                     229         13.061191     0.0570357685
> c-crosses-statement-barrier-p                  35466       11.622212999  0.0003277001
> c-font-lock-declarations                       16          9.4090929999  0.5880683124
> c-find-decl-spots                              16          9.4089879999  0.5880617499

> c-at-macro-vsemi-p                             46569       6.6139159999  0.0001420240
> c-in-literal                                   46569       5.4569670000  0.0001171802
> c-literal-limits                               51666       3.1393819999  6.076...e-05
> c-backward-sws                                 176682      1.6644079999  9.420...e-06
> c-beginning-of-macro                           104078      0.5568430000  5.350...e-06

> c-state-safe-place                             72459       0.3154430000  4.353...e-06
> c-parse-state                                  225         0.1421229999  0.0006316577
> c-parse-state-1                                225         0.1385559999  0.0006158044
> c-font-lock-enclosing-decls                    16          0.1365140000  0.0085321250
> c-append-to-state-cache                        196         0.0641449999  0.0003272704

> After:

> c-beginning-of-decl-1                          137         9.6732900000  0.0706079562
> c-beginning-of-statement-1                     165         9.6693369999  0.0586020424
> c-crosses-statement-barrier-p                  25584       8.5505400000  0.0003342143
> c-font-lock-declarations                       16          6.059768      0.3787355
> c-find-decl-spots                              16          6.059666      0.378729125

> c-at-macro-vsemi-p                             35149       4.7420429999  0.0001349126
> c-in-literal                                   35149       4.0154739999  0.0001142414
> c-literal-limits                               38962       2.5425719999  6.525...e-05
> c-backward-sws                                 128214      1.1421259999  8.907...e-06
> c-beginning-of-macro                           78145       0.3845660000  4.921...e-06

> c-state-safe-place                             54703       0.2419970000  4.423...e-06
> c-parse-state                                  317         0.1464209999  0.0004618958
> c-font-lock-enclosing-decls                    16          0.137945      0.0086215625
> c-parse-state-1                                317         0.1331939999  0.0004201703
> c-font-lock-declarators                        24          0.065522      0.0027300833

I've inserted some code which checks for macro invocation by looking for
an identifier followed by '('.  More or less.

Would you please try out the following patch.  It improves things
considerably, although it might not be quite the version which gets
committed.



*** orig/cc-engine.el	2011-12-15 09:06:28.000000000 +0000
--- cc-engine.el	2011-12-15 13:41:25.000000000 +0000
***************
*** 8073,8078 ****
--- 8073,8094 ----
  	    next-open-brace (c-pull-open-brace paren-state)))
      open-brace))
  
+ (defun c-cheap-inside-bracelist-p (paren-state)
+   ;; Return the position of the L-brace if point is inside a brace list
+   ;; initialization of an array, etc.  This is an approximate function,
+   ;; designed for speed over accuracy.  We simply search for "= {" (naturally
+   ;; with syntactic whitespace allowed).  PAREN-STATE is the normal thing that
+   ;; it is everywhere else.
+   (let (b-pos)
+     (save-excursion
+       (while
+ 	  (and (setq b-pos (c-pull-open-brace paren-state))
+ 	       (progn (goto-char b-pos)
+ 		      (c-backward-sws)
+ 		      (c-backward-token-2)
+ 		      (not (looking-at "=")))))
+       b-pos)))
+ 
  (defun c-inside-bracelist-p (containing-sexp paren-state)
    ;; return the buffer position of the beginning of the brace list
    ;; statement if we're inside a brace list, otherwise return nil.
*** orig/cc-fonts.el	2011-12-15 09:06:28.000000000 +0000
--- cc-fonts.el	2012-01-13 18:50:02.000000000 +0000
***************
*** 407,416 ****
  	      ;; `parse-sexp-lookup-properties' (when it exists).
  	      (parse-sexp-lookup-properties
  	       (cc-eval-when-compile
! 		 (boundp 'parse-sexp-lookup-properties))))
  	  (goto-char
  	   (let ((here (point)))
! 	     (if (eq (car (c-beginning-of-decl-1)) 'same)
  		 (point)
  	       here)))
  	  ,(c-make-font-lock-search-form regexp highlights))
--- 407,417 ----
  	      ;; `parse-sexp-lookup-properties' (when it exists).
  	      (parse-sexp-lookup-properties
  	       (cc-eval-when-compile
! 		 (boundp 'parse-sexp-lookup-properties)))
! 	      (BOD-limit (max (point-min) (- (point) 2000))))
  	  (goto-char
  	   (let ((here (point)))
! 	     (if (eq (car (c-beginning-of-decl-1 BOD-limit)) 'same)
  		 (point)
  	       here)))
  	  ,(c-make-font-lock-search-form regexp highlights))
***************
*** 1317,1323 ****
  	      (or (looking-at c-typedef-key)
  		  (goto-char start-pos)))
  
- 	    ;; Now analyze the construct.
  	    ;; In QT, "more" is an irritating keyword that expands to nothing.
  	    ;; We skip over it to prevent recognition of "more slots: <symbol>"
  	    ;; as a bitfield declaration.
--- 1318,1323 ----
***************
*** 1326,1331 ****
--- 1326,1333 ----
  			(concat "\\(more\\)\\([^" c-symbol-chars "]\\|$\\)")))
  	      (goto-char (match-end 1))
  	      (c-forward-syntactic-ws))
+ 
+ 	    ;; Now analyze the construct.
  	    (setq decl-or-cast (c-forward-decl-or-cast-1
  				match-pos context last-cast-end))
  
***************
*** 1394,1399 ****
--- 1396,1428 ----
  	      (c-fontify-recorded-types-and-refs)
  	      nil)
  
+ 	     ;; Restore point, since at this point in the code it has been
+ 	     ;; left undefined by c-forward-decl-or-cast-1 above.
+ 	     ((progn (goto-char start-pos) nil))
+ 
+ 	     ;; If point is inside a bracelist, there's no point checking it
+ 	     ;; being at a declarator.
+ 	     ((let ((paren-state (c-parse-state)))
+ 		(c-cheap-inside-bracelist-p paren-state))
+ 	      nil)
+ 
+ 	     ;; If point is just after a ")" which is followed by an
+ 	     ;; identifier which isn't a label, or at the matching "(", we're
+ 	     ;; at either a macro invocation, a cast, or a
+ 	     ;; for/while/etc. statement.  The cast case is handled above.
+ 	     ;; None of these cases can contain a declarator.
+ 	     ((or (and (eq (char-before match-pos) ?\))
+ 	     	       (c-on-identifier)
+ 	     	       (save-excursion (not (c-forward-label))))
+ 	     	  (and (eq (char-after) ?\()
+ 	     	       (save-excursion
+ 	     		 (and
+ 	     		  (progn (c-backward-token-2) (c-on-identifier))
+ 	     		  (save-excursion (not (c-forward-label)))
+ 	     		  (progn (c-backward-token-2)
+ 	     			 (eq (char-after) ?\())))))
+ 	      nil)
+ 
  	     (t
  	      ;; Are we at a declarator?  Try to go back to the declaration
  	      ;; to check this.  If we get there, check whether a "typedef"
***************
*** 1403,1408 ****
--- 1432,1440 ----
  		    c-recognize-knr-p) ; Strictly speaking, bogus, but it
  				       ; speeds up lisp.h tremendously.
  		(save-excursion
+ 		  (unless (or (eobp)
+ 			      (looking-at "\\s(\\|\\s)"))
+ 		    (forward-char))
  		  (setq bod-res (car (c-beginning-of-decl-1 decl-search-lim)))
  		  (if (and (eq bod-res 'same)
  			   (progn

> -- 
> Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Hi!

Alan Mackenzie <acm@muc.de> writes:

> I've inserted some code which checks for macro invocation by looking for
> an identifier followed by '('.  More or less.
>
> Would you please try out the following patch.  It improves things
> considerably, although it might not be quite the version which gets
> committed.

Thanks! Now the speed is very acceptable after applied the patch :)

-- 
Kanru

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kanru!

On Sun, Dec 18, 2011 at 12:06:00AM +0800, Kan-Ru Chen wrote:
> Alan Mackenzie <acm@muc.de> writes:

> Please forgive me for using the other files, it is closer to the real
> case. You can get the file from

> https://hg.mozilla.org/mozilla-central/raw-file/tip/dom/base/nsDOMClassInfo.cpp

Ah yes, this wonderful file!

Here's another patch which contains more optimisations than my last
patch.  Could you apply it _instead_ of the previous patch, and let me
know how it goes, please.  The more serious editing you can do with it,
particularly on C++ files, the better.

Anyhow, here's the patch:


*** orig/cc-engine.el	2011-12-15 09:06:28.000000000 +0000
--- cc-engine.el	2012-01-15 19:20:01.000000000 +0000
***************
*** 2075,2081 ****
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; We maintain a simple cache of positions which aren't in a literal, so as to
  ;; speed up testing for non-literality.
! (defconst c-state-nonlit-pos-interval 10000)
  ;; The approximate interval between entries in `c-state-nonlit-pos-cache'.
  
  (defvar c-state-nonlit-pos-cache nil)
--- 2075,2081 ----
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; We maintain a simple cache of positions which aren't in a literal, so as to
  ;; speed up testing for non-literality.
! (defconst c-state-nonlit-pos-interval 3000)
  ;; The approximate interval between entries in `c-state-nonlit-pos-cache'.
  
  (defvar c-state-nonlit-pos-cache nil)
***************
*** 2130,2136 ****
      (widen)
      (save-excursion
        (let ((c c-state-nonlit-pos-cache)
! 	    pos npos lit)
  	;; Trim the cache to take account of buffer changes.
  	(while (and c (> (car c) c-state-nonlit-pos-cache-limit))
  	  (setq c (cdr c)))
--- 2130,2136 ----
      (widen)
      (save-excursion
        (let ((c c-state-nonlit-pos-cache)
! 	    pos npos lit macro-beg)
  	;; Trim the cache to take account of buffer changes.
  	(while (and c (> (car c) c-state-nonlit-pos-cache-limit))
  	  (setq c (cdr c)))
***************
*** 2140,2160 ****
  	  (setq c (cdr c)))
  	(setq pos (or (car c) (point-min)))
  
! 	(while (<= (setq npos (+ pos c-state-nonlit-pos-interval))
! 		   here)
! 	  (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
! 	  (setq pos (or (cdr lit) npos)) ; end of literal containing npos.
  	  (goto-char pos)
  	  (when (and (c-beginning-of-macro) (/= (point) pos))
! 	    (c-syntactic-end-of-macro)
! 	    (or (eobp) (forward-char))
! 	    (setq pos (point)))
! 	  (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
  
  	(if (> pos c-state-nonlit-pos-cache-limit)
  	    (setq c-state-nonlit-pos-cache-limit pos))
  	pos))))
! 	
  (defun c-state-literal-at (here)
    ;; If position HERE is inside a literal, return (START . END), the
    ;; boundaries of the literal (which may be outside the accessible bit of the
--- 2140,2177 ----
  	  (setq c (cdr c)))
  	(setq pos (or (car c) (point-min)))
  
! 	(while
! 	    ;; Add an element to `c-state-nonlit-pos-cache' each iteration.
! 	    (and
! 	     (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
! 	     (progn
! 	       (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
! 	       (cond
! 		((null lit)
! 		 (setq pos npos)
! 		 t)
! 		((<= (cdr lit) here)
! 		 (setq pos (cdr lit))
! 		 t)
! 		(t
! 		 (setq pos (car lit))
! 		 nil))))
! 
  	  (goto-char pos)
  	  (when (and (c-beginning-of-macro) (/= (point) pos))
! 	      (setq macro-beg (point))
! 	      (c-syntactic-end-of-macro)
! 	      (or (eobp) (forward-char))
! 	      (setq pos (if (<= (point) here)
! 			    (point)
! 			  macro-beg)))
! 	    (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
  
  	(if (> pos c-state-nonlit-pos-cache-limit)
  	    (setq c-state-nonlit-pos-cache-limit pos))
  	pos))))
! ;;;; END OF NEW STOUGH, 2012-01-14
! 
  (defun c-state-literal-at (here)
    ;; If position HERE is inside a literal, return (START . END), the
    ;; boundaries of the literal (which may be outside the accessible bit of the
***************
*** 4362,4367 ****
--- 4379,4456 ----
  	      (t 'c)))			; Assuming the range is valid.
      range))
  
+ (defsubst c-determine-limit-get-base (start try-size)
+   ;; Get a "safe place" approximately TRY-SIZE characters before START.
+   ;; This doesn't preserve point.
+   (let* ((pos (max (- start try-size) (point-min)))
+ 	 (base (c-state-safe-place pos))
+ 	 (s (parse-partial-sexp base pos)))
+     (if (or (nth 4 s) (nth 3 s))	; comment or string
+ 	(nth 8 s)
+       (point))))
+ 
+ (defun c-determine-limit (how-far-back &optional start try-size)
+   ;; Return a buffer position HOW-FAR-BACK non-literal characters from START
+   ;; (default point).  This is done by going back further in the buffer then
+   ;; searching forward for literals.  The position found won't be in a
+   ;; literal.  We start searching for the sought position TRY-SIZE (default
+   ;; twice HOW-FAR-BACK) bytes back from START.  This function must be fast.
+   ;; :-)
+   (save-excursion
+     (let* ((start (or start (point)))
+ 	   (try-size (or try-size (* 2 how-far-back)))
+ 	   (base (c-determine-limit-get-base start try-size))
+ 	   (pos base)
+ 
+ 	   (s (parse-partial-sexp pos pos)) ; null state.
+ 	   stack elt size
+ 	   (count 0))
+       (while (< pos start)
+ 	;; Move forward one literal each time round this loop.
+ 	;; Move forward to the start of a comment or string.
+ 	(setq s (parse-partial-sexp
+ 		 pos
+ 		 start
+ 		 nil			; target-depth
+ 		 nil			; stop-before
+ 		 s			; state
+ 		 'syntax-table))	; stop-comment
+ 
+ 	;; Gather details of the non-literal-bit - starting pos and size.
+ 	(setq size (- (if (or (nth 4 s) (nth 3 s))
+ 			  (nth 8 s)
+ 			(point))
+ 		      pos))
+ 	(if (> size 0)
+ 	    (setq stack (cons (cons pos size) stack)))
+ 
+ 	;; Move forward to the end of the comment/string.
+ 	(if (or (nth 4 s) (nth 3 s))
+ 	    (setq s (parse-partial-sexp
+ 		     (point)
+ 		     start
+ 		     nil		; target-depth
+ 		     nil		; stop-before
+ 		     s			; state
+ 		     'syntax-table)))	; stop-comment
+ 	(setq pos (point)))
+     
+       ;; Now try and find enough non-literal characters recorded on the stack.
+       ;; Go back one recorded literal each time round this loop.
+       (while (and (< count how-far-back)
+ 		  stack)
+ 	(setq elt (car stack)
+ 	      stack (cdr stack))
+ 	(setq count (+ count (cdr elt))))
+ 
+       ;; Have we found enough yet?
+       (cond
+        ((>= count how-far-back)
+ 	(+ (car elt) (- count how-far-back)))
+        ((eq base (point-min))
+ 	(point-min))
+        (t
+ 	(c-determine-limit (- how-far-back count) base try-size))))))
  \f
  ;; `c-find-decl-spots' and accompanying stuff.
  
***************
*** 4498,4510 ****
    ;; Call CFD-FUN for each possible spot for a declaration, cast or
    ;; label from the point to CFD-LIMIT.
    ;;
!   ;; CFD-FUN is called with point at the start of the spot.  It's
!   ;; passed two arguments: The first is the end position of the token
!   ;; preceding the spot, or 0 for the implicit match at bob.  The
!   ;; second is a flag that is t when the match is inside a macro.  If
!   ;; CFD-FUN adds `c-decl-end' properties somewhere below the current
!   ;; spot, it should return non-nil to ensure that the next search
!   ;; will find them.
    ;;
    ;; Such a spot is:
    ;; o	The first token after bob.
--- 4587,4600 ----
    ;; Call CFD-FUN for each possible spot for a declaration, cast or
    ;; label from the point to CFD-LIMIT.
    ;;
!   ;; CFD-FUN is called with point at the start of the spot.  It's passed two
!   ;; arguments: The first is the end position of the token preceding the spot,
!   ;; or 0 for the implicit match at bob.  The second is a flag that is t when
!   ;; the match is inside a macro.  Point should be moved forward by at least
!   ;; one token.
!   ;;
!   ;; If CFD-FUN adds `c-decl-end' properties somewhere below the current spot,
!   ;; it should return non-nil to ensure that the next search will find them.
    ;;
    ;; Such a spot is:
    ;; o	The first token after bob.
***************
*** 4903,4909 ****
        (goto-char cfd-continue-pos)
        (if (= cfd-continue-pos cfd-limit)
  	  (setq cfd-match-pos cfd-limit)
! 	(c-find-decl-prefix-search)))))
  
  \f
  ;; A cache for found types.
--- 4993,5000 ----
        (goto-char cfd-continue-pos)
        (if (= cfd-continue-pos cfd-limit)
  	  (setq cfd-match-pos cfd-limit)
! 	(c-find-decl-prefix-search))))) ; Moves point, sets cfd-continue-pos,
! 					; cfd-match-pos, etc.
  
  \f
  ;; A cache for found types.
***************
*** 8073,8078 ****
--- 8164,8186 ----
  	    next-open-brace (c-pull-open-brace paren-state)))
      open-brace))
  
+ (defun c-cheap-inside-bracelist-p (paren-state)
+   ;; Return the position of the L-brace if point is inside a brace list
+   ;; initialization of an array, etc.  This is an approximate function,
+   ;; designed for speed over accuracy.  It will not find every bracelist, but
+   ;; a non-nil result is reliable.  We simply search for "= {" (naturally with
+   ;; syntactic whitespace allowed).  PAREN-STATE is the normal thing that it
+   ;; is everywhere else.
+   (let (b-pos)
+     (save-excursion
+       (while
+ 	  (and (setq b-pos (c-pull-open-brace paren-state))
+ 	       (progn (goto-char b-pos)
+ 		      (c-backward-sws)
+ 		      (c-backward-token-2)
+ 		      (not (looking-at "=")))))
+       b-pos)))
+ 
  (defun c-inside-bracelist-p (containing-sexp paren-state)
    ;; return the buffer position of the beginning of the brace list
    ;; statement if we're inside a brace list, otherwise return nil.
*** orig/cc-fonts.el	2011-12-15 09:06:28.000000000 +0000
--- cc-fonts.el	2012-01-15 18:41:00.000000000 +0000
***************
*** 407,416 ****
  	      ;; `parse-sexp-lookup-properties' (when it exists).
  	      (parse-sexp-lookup-properties
  	       (cc-eval-when-compile
! 		 (boundp 'parse-sexp-lookup-properties))))
  	  (goto-char
  	   (let ((here (point)))
! 	     (if (eq (car (c-beginning-of-decl-1)) 'same)
  		 (point)
  	       here)))
  	  ,(c-make-font-lock-search-form regexp highlights))
--- 407,418 ----
  	      ;; `parse-sexp-lookup-properties' (when it exists).
  	      (parse-sexp-lookup-properties
  	       (cc-eval-when-compile
! 		 (boundp 'parse-sexp-lookup-properties)))
! 	      (BOD-limit
! 	       (c-determine-limit 1000)))
  	  (goto-char
  	   (let ((here (point)))
! 	     (if (eq (car (c-beginning-of-decl-1 BOD-limit)) 'same)
  		 (point)
  	       here)))
  	  ,(c-make-font-lock-search-form regexp highlights))
***************
*** 1206,1211 ****
--- 1208,1214 ----
  	  ;; it finds any.  That's necessary so that we later will
  	  ;; stop inside them to fontify types there.
  	  (c-parse-and-markup-<>-arglists t)
+ 	  lbrace ; position of some {.
  	  ;; The font-lock package in Emacs is known to clobber
  	  ;; `parse-sexp-lookup-properties' (when it exists).
  	  (parse-sexp-lookup-properties
***************
*** 1317,1323 ****
  	      (or (looking-at c-typedef-key)
  		  (goto-char start-pos)))
  
- 	    ;; Now analyze the construct.
  	    ;; In QT, "more" is an irritating keyword that expands to nothing.
  	    ;; We skip over it to prevent recognition of "more slots: <symbol>"
  	    ;; as a bitfield declaration.
--- 1320,1325 ----
***************
*** 1326,1331 ****
--- 1328,1335 ----
  			(concat "\\(more\\)\\([^" c-symbol-chars "]\\|$\\)")))
  	      (goto-char (match-end 1))
  	      (c-forward-syntactic-ws))
+ 
+ 	    ;; Now analyze the construct.
  	    (setq decl-or-cast (c-forward-decl-or-cast-1
  				match-pos context last-cast-end))
  
***************
*** 1394,1408 ****
  	      (c-fontify-recorded-types-and-refs)
  	      nil)
  
  	     (t
  	      ;; Are we at a declarator?  Try to go back to the declaration
  	      ;; to check this.  If we get there, check whether a "typedef"
  	      ;; is there, then fontify the declarators accordingly.
! 	      (let ((decl-search-lim (max (- (point) 50000) (point-min)))
  		    paren-state bod-res encl-pos is-typedef 
  		    c-recognize-knr-p) ; Strictly speaking, bogus, but it
  				       ; speeds up lisp.h tremendously.
  		(save-excursion
  		  (setq bod-res (car (c-beginning-of-decl-1 decl-search-lim)))
  		  (if (and (eq bod-res 'same)
  			   (progn
--- 1398,1449 ----
  	      (c-fontify-recorded-types-and-refs)
  	      nil)
  
+ 	     ;; Restore point, since at this point in the code it has been
+ 	     ;; left undefined by c-forward-decl-or-cast-1 above.
+ 	     ((progn (goto-char start-pos) nil))
+ 
+ 	     ;; If point is inside a bracelist, there's no point checking it
+ 	     ;; being at a declarator.
+ 	     ((let ((paren-state (c-parse-state)))
+ 		(setq lbrace (c-cheap-inside-bracelist-p paren-state)))
+ 	      ;; Move past this bracelist to prevent an endless loop.
+ 	      (goto-char lbrace)
+ 	      (unless (c-safe (progn (forward-list) t))
+ 		(goto-char start-point)
+ 		(c-forward-token-2))
+ 	      nil)
+ 
+ 	     ;; If point is just after a ")" which is followed by an
+ 	     ;; identifier which isn't a label, or at the matching "(", we're
+ 	     ;; at either a macro invocation, a cast, or a
+ 	     ;; for/while/etc. statement.  The cast case is handled above.
+ 	     ;; None of these cases can contain a declarator.
+ 	     ((or (and (eq (char-before match-pos) ?\))
+ 	     	       (c-on-identifier)
+ 	     	       (save-excursion (not (c-forward-label))))
+ 	     	  (and (eq (char-after) ?\()
+ 	     	       (save-excursion
+ 	     		 (and
+ 	     		  (progn (c-backward-token-2) (c-on-identifier))
+ 	     		  (save-excursion (not (c-forward-label)))
+ 	     		  (progn (c-backward-token-2)
+ 	     			 (eq (char-after) ?\())))))
+ 	      (c-forward-token-2)	; Must prevent looping.
+ 	      nil)
+ 
  	     (t
  	      ;; Are we at a declarator?  Try to go back to the declaration
  	      ;; to check this.  If we get there, check whether a "typedef"
  	      ;; is there, then fontify the declarators accordingly.
! 	      (let ((decl-search-lim ;; (max (- (point) 50000) (point-min))
! 		     (c-determine-limit 1000))
  		    paren-state bod-res encl-pos is-typedef 
  		    c-recognize-knr-p) ; Strictly speaking, bogus, but it
  				       ; speeds up lisp.h tremendously.
  		(save-excursion
+ 		  (unless (or (eobp)
+ 			      (looking-at "\\s(\\|\\s)"))
+ 		    (forward-char))
  		  (setq bod-res (car (c-beginning-of-decl-1 decl-search-lim)))
  		  (if (and (eq bod-res 'same)
  			   (progn
***************
*** 1865,1873 ****
  	    `((,(c-make-font-lock-BO-decl-search-function
  		 (concat "\\<\\("
  			 (c-make-keywords-re nil
! 			   (append (c-lang-const c-type-list-kwds)
! 				   (c-lang-const c-ref-list-kwds)
! 				   (c-lang-const c-colon-type-list-kwds)))
  			 "\\)\\>")
  		 '((c-fontify-types-and-refs ((c-promote-possible-types t))
  		     (c-forward-keyword-clause 1)
--- 1906,1915 ----
  	    `((,(c-make-font-lock-BO-decl-search-function
  		 (concat "\\<\\("
  			 (c-make-keywords-re nil
! 			   (append (c-lang-const c-type-list-kwds) ; operator (C++).  import, implements, etc. (Java).
! 				   (c-lang-const c-ref-list-kwds)  ; namespace (C++).  package (Java).
! 				   (c-lang-const c-colon-type-list-kwds))) ; class, struct (C++).  The colon is what
! 			                                                   ; introduces an inheritance list.
  			 "\\)\\>")
  		 '((c-fontify-types-and-refs ((c-promote-possible-types t))
  		     (c-forward-keyword-clause 1)

> -- 
> Kanru

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Alan Mackenzie]

Hello, Kentaro.

On Sun, Jan 08, 2012 at 10:26:10AM +0900, Kentaro NAKAZAWA wrote:
> Hello, Alan.

> > Could you be more specific, please - tell me which keywords weren't
> > fontified, and exactly what you did for this to happen.

> The screen shot was appended. (emacs -Q)

OK, I got that.

> action.cc.png:
> http://ftp.gnome.org/pub/GNOME/sources/gtkmm/3.0/gtkmm-3.0.1.tar.bz2
> gtkmm-3.0.1/gtk/gtkmm/action.cc

> The method name is not fontified.
> But I execute M-oM-o in function, fontified correctly.

I don't see this problem, with the latest version of CC Mode (which has
been committed to savannah).  Maybe recent changes have solved it.

Could you please try again with the latest CC Mode version.  Thanks!

> -- 
> Kentaro Nakazawa

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Slow fontification in C mode buffers

[Kan-Ru Chen]

Hi!

Alan Mackenzie <acm@muc.de> writes:

> Hello, Kanru!
>
> On Sun, Dec 18, 2011 at 12:06:00AM +0800, Kan-Ru Chen wrote:
>> Alan Mackenzie <acm@muc.de> writes:
>
>> Please forgive me for using the other files, it is closer to the real
>> case. You can get the file from
>
>> https://hg.mozilla.org/mozilla-central/raw-file/tip/dom/base/nsDOMClassInfo.cpp
>
> Ah yes, this wonderful file!
>
> Here's another patch which contains more optimisations than my last
> patch.  Could you apply it _instead_ of the previous patch, and let me
> know how it goes, please.  The more serious editing you can do with it,
> particularly on C++ files, the better.

Thanks!

This version works as well as previous one. It seems slightly faster
than previous one, though I didn't do any serious profiling.

-- 
Kanru

Re: Slow fontification in C mode buffers

[Kentaro NAKAZAWA]

[-- Attachment #1: Type: text/plain, Size: 1217 bytes --]

Hello, Alan.

Thank you for the modified.
I try pretest 24.0.93 at my job on Windows7.
(ftp://alpha.gnu.org/gnu/emacs/pretest/windows/emacs-24.0.93-bin-i386.zip)

Unfortunately it is still slow... But very comfortable on linux (x11 and
console).
NTEmacs's font-lock is very very slow(?)

I attached other slow pattern.
it is a bit slow on linux, but is terribly slow on windows7.

Alan Mackenzie <acm@muc.de> writes:

> Hello, Kentaro.
>
> On Sun, Jan 08, 2012 at 10:26:10AM +0900, Kentaro NAKAZAWA wrote:
>> Hello, Alan.
>
>> > Could you be more specific, please - tell me which keywords weren't
>> > fontified, and exactly what you did for this to happen.
>
>> The screen shot was appended. (emacs -Q)
>
> OK, I got that.
>
>> action.cc.png:
>> http://ftp.gnome.org/pub/GNOME/sources/gtkmm/3.0/gtkmm-3.0.1.tar.bz2
>> gtkmm-3.0.1/gtk/gtkmm/action.cc
>
>> The method name is not fontified.
>> But I execute M-oM-o in function, fontified correctly.
>
> I don't see this problem, with the latest version of CC Mode (which has
> been committed to savannah).  Maybe recent changes have solved it.
>
> Could you please try again with the latest CC Mode version.  Thanks!
>
>> -- 
>> Kentaro Nakazawa

-- 
Kentaro Nakazawa

[-- Attachment #2: test.cc --]
[-- Type: text/plain, Size: 1547 bytes --]

class Test {
public:
	Test();
private:
	int m_test00;
	int m_test01;
	int m_test02;
	int m_test03;
	int m_test04;
	int m_test05;
	int m_test06;
	int m_test07;
	int m_test08;
	int m_test09;
	int m_test10;
	int m_test11;
	int m_test12;
	int m_test13;
	int m_test14;
	int m_test15;
	int m_test16;
	int m_test17;
	int m_test18;
	int m_test19;
	int m_test20;
	int m_test21;
	int m_test22;
	int m_test23;
	int m_test24;
	int m_test25;
	int m_test26;
	int m_test27;
	int m_test28;
	int m_test29;
	int m_test30;
	int m_test31;
	int m_test32;
	int m_test33;
	int m_test34;
	int m_test35;
	int m_test36;
	int m_test37;
	int m_test38;
	int m_test39;
	int m_test40;
	int m_test41;
	int m_test42;
	int m_test43;
	int m_test44;
	int m_test45;
	int m_test46;
	int m_test47;
};

Test::Test()
	: m_test00(0),
	  m_test01(0),
	  m_test02(0),
	  m_test03(0),
	  m_test04(0),
	  m_test05(0),
	  m_test06(0),
	  m_test07(0),
	  m_test08(0),
	  m_test09(0),
	  m_test10(0),
	  m_test11(0),
	  m_test12(0),
	  m_test13(0),
	  m_test14(0),
	  m_test15(0),
	  m_test16(0),
	  m_test17(0),
	  m_test18(0),
	  m_test19(0),
	  m_test20(0),
	  m_test21(0),
	  m_test22(0),
	  m_test23(0),
	  m_test24(0),
	  m_test25(0),
	  m_test26(0),
	  m_test27(0),
	  m_test28(0),
	  m_test29(0),
	  m_test30(0),
	  m_test31(0),
	  m_test32(0),
	  m_test33(0),
	  m_test34(0),
	  m_test35(0),
	  m_test36(0),
	  m_test37(0),
	  m_test38(0),
	  m_test39(0),
	  m_test40(0),
	  m_test41(0),
	  m_test42(0),
	  m_test43(0),
	  m_test44(0),
	  m_test45(0),
	  m_test46(0),
	  m_test47(0)
{
}