Commits

Anonymous committed 9df1961

2002-08-06 Ville Skyttä <ville.skytta@xemacs.org>

* semantic.el.upstream: Removed, obsolete.

* semantic-util.el.upstream: Ditto.

Comments (0)

Files changed (3)

+2002-08-06  Ville Skyttä  <ville.skytta@xemacs.org>
+
+	* semantic.el.upstream: Removed, obsolete.
+
+	* semantic-util.el.upstream: Ditto.
+
 2002-08-05  Andy Piper  <andy@xemacs.org>
 
 	* update to semantic 1.4.

semantic-util.el.upstream

-;;; semantic-util.el --- Utilities for use with semantic token streams
-
-;;; Copyright (C) 1999, 2000, 2001 Eric M. Ludlam
-
-;; Author: Eric M. Ludlam <zappo@gnu.org>
-;; Keywords: syntax
-;; X-RCS: $Id$
-
-;; This file is not part of GNU Emacs.
-
-;; Semantic is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; This software is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
-
-;;; Commentary:
-;;
-;; API for accessing and searching nonterminal streams from the
-;; Semantic Bovinator.
-;;
-
-(require 'assoc)
-(require 'semantic)
-
-;;; Code:
-
-(defvar semantic-type-relation-separator-character '(".")
-  "Character strings used to separation a parent/child relationship.
-This list of strings are used for displaying or finding separators
-in variable field dereferencing.  The first character will be used for
-display.  In C, a type field is separated like this: \"type.field\"
-thus, the character is a \".\".  In C, and additional value of \"->\"
-would be in the list, so that \"type->field\" could be found.")
-(make-variable-buffer-local 'semantic-type-relation-separator-character)
-
-(defvar semantic-equivalent-major-modes nil
-  "List of major modes which are considered equivalent.
-Equivalent modes share a parser, and a set of override methods.
-Setup from the BNF code generator.  A value of nil means that
-the current major mode is the only one.")
-(make-variable-buffer-local 'semantic-equivalent-major-modes)
-
-;;; Utility API functions
-;;
-;; These functions use the flex and bovination engines to perform some
-;; simple tasks useful to other programs.  These are just the most
-;; critical entries.
-(defun semantic-token-type (token)
-  "Retrieve the type of TOKEN."
-  (if (member (semantic-token-token token)
-	      '(function variable type))
-      (nth 2 token)))
-
-(defmacro semantic-token-type-parts (token)
-  "Retrieve the parts of the type TOKEN."
-  `(nth 3 ,token))
-
-(defmacro semantic-token-type-parent (token)
-  "Retrieve the parent of the type TOKEN.
-The return value is a list.  A value of nil means no parents.
-The `car' of the list is either the parent class, or a list
-of parent classes.  The `cdr' of the list is the list of
-interfaces, or abstract classes which are parents of TOKEN."
-  `(nth 4 ,token))
-
-(defun semantic-token-type-parent-superclass (token)
-  "Retrieve the parent superclasses of type type TOKEN."
-  (let ((p (semantic-token-type-parent token)))
-    (cond ((stringp (car p))
-	   (list (car p)))
-	  ((listp (car p))
-	   (car p)))))
-
-(defun semantic-token-type-parent-implement (token)
-  "Retrieve the parent interfaces of type type TOKEN."
-  (cdr (semantic-token-type-parent token)))
-
-(defmacro semantic-token-type-extra-specs (token)
-  "Retrieve extra specifications for the type TOKEN."
-  `(nth 5 ,token))
-
-(defmacro semantic-token-type-extra-spec (token spec)
-  "Retrieve an extra specification for the type TOKEN.
-SPEC is the symbol whose specification value to get."
-  `(cdr (assoc ,spec (semantic-token-type-extra-specs ,token))))
-
-(defmacro semantic-token-type-modifiers (token)
-  "Retrieve modifiers for the type TOKEN."
-  `(semantic-token-type-extra-spec ,token 'typemodifiers))
-
-(defmacro semantic-token-function-args (token)
-  "Retrieve the arguments of the function TOKEN."
-  `(nth 3 ,token))
-
-(defmacro semantic-token-function-extra-specs (token)
-  "Retrieve extra specifications for the function TOKEN."
-  `(nth 4 ,token))
-
-(defmacro semantic-token-function-extra-spec (token spec)
-  "Retrieve an extra specification for the function TOKEN.
-SPEC is the symbol whose specification value to get."
-  `(cdr (assoc ,spec (semantic-token-function-extra-specs ,token))))
-
-(defmacro semantic-token-function-modifiers (token)
-  "Retrieve modifiers for the function TOKEN."
-  `(semantic-token-function-extra-spec ,token 'typemodifiers))
-
-(defmacro semantic-token-function-throws (token)
-  "The symbol string that a function can throws.
-Determines if it is available based on the length of TOKEN."
-  `(semantic-token-function-extra-spec ,token 'throws))
-
-(defmacro semantic-token-function-parent (token)
-  "The parent of the function TOKEN.
-A function has a parent if it is a method of a class, and if the
-function does not appear in body of it's parent class."
-  `(semantic-token-function-extra-spec ,token 'parent))
-
-(defmacro semantic-token-variable-default (token)
-  "Retrieve the default value of the variable TOKEN."
-  `(nth 3 ,token))
-
-(defmacro semantic-token-variable-extra-specs (token)
-  "Retrieve extra specifications for the variable TOKEN."
-  `(nth 4 ,token))
-
-(defmacro semantic-token-variable-extra-spec (token spec)
-  "Retrieve an extra specification for the variable TOKEN.
-SPEC is the symbol whose specification value to get."
-  `(cdr (assoc ,spec (semantic-token-variable-extra-specs ,token))))
-
-(defmacro semantic-token-variable-modifiers (token)
-  "Retrieve modifiers for the variable TOKEN."
-  `(semantic-token-variable-extra-spec ,token 'typemodifiers))
-
-(defmacro semantic-token-variable-const (token)
-  "Retrieve the status of constantness from the variable TOKEN."
-  `(semantic-token-variable-extra-spec ,token 'const))
-
-(defmacro semantic-token-variable-optsuffix (token)
-  "Optional details if this variable has bit fields, or array dimentions.
-Determines if it is available based on the length of TOKEN."
-  `(semantic-token-variable-extra-spec ,token 'suffix))
-
-(defmacro semantic-token-include-system (token)
- "Retrieve the flag indicating if the include TOKEN is a system include."
-  `(nth 2 ,token))
-
-(defun semantic-token-extra-spec (token spec)
-  "Retrieve an extra specification for TOKEN.
-SPEC is a symbol whose specification value to get.
-This function can get extra specifications from any type of token.
-Do not use the function if you know what type of token you are dereferencing.
-Instead, use `semantic-token-variable-extra-spec',
-`semantic-token-function-extra-spec', or  `semantic-token-type-extra-spec'."
-  (let ((tt (semantic-token-token token)))
-    (cond ((eq tt 'variable)
-	   (semantic-token-variable-extra-spec token spec))
-	  ((eq tt 'function)
-	   (semantic-token-function-extra-spec token spec))
-	  ((eq tt 'type)
-	   (semantic-token-type-extra-spec token spec))
-	  (t nil))))
-
-(defmacro semantic-token-modifiers (token)
-  "Retrieve modifiers for TOKEN.
-If TOKEN is of an unknown type, then nil is returned."
-  `(semantic-token-extra-spec ,token 'typemodifiers))
-
-;;; Misc. utilities
-;;
-(defun semantic-map-buffers (fun)
-  "Run function FUN for each Semantic enabled buffer found.
-FUN does not have arguments.  When FUN is entered `current-buffer' is
-the current Semantic enabled buffer found."
-  (let ((bl (buffer-list))
-        b)
-    (while bl
-      (setq b  (car bl)
-            bl (cdr bl))
-      (if (and (buffer-live-p b)
-               (buffer-file-name b))
-          (with-current-buffer b
-            (if (semantic-active-p)
-                (funcall fun)))))))
-
-;; These semanticdb calls will throw warnings in the byte compiler.
-;; Doing the right thing to make them available at compile time
-;; really messes up the compilation sequence.
-(defun semantic-file-token-stream (file &optional checkcache)
-  "Return a token stream for FILE.
-If it is loaded, return the stream after making sure it's ok.
-If FILE is not loaded, check to see if `semanticdb' feature exists,
-   and use it to get tokens from files not in memory.
-If FILE is not loaded, and semanticdb is not available, find the file
-   and parse it.
-Optional argument CHECKCACHE is the same as that for
-`semantic-bovinate-toplevel'."
-  (if (get-file-buffer file)
-      (save-excursion
-	(set-buffer (get-file-buffer file))
-	(semantic-bovinate-toplevel checkcache))
-    ;; File not loaded
-    (if (and (fboundp 'semanticdb-minor-mode-p)
-	     (semanticdb-minor-mode-p))
-	;; semanticdb is around, use it.
-	(semanticdb-file-stream file)
-      ;; Get the stream ourselves.
-      (save-excursion
-	(set-buffer (find-file-noselect file))
-	(semantic-bovinate-toplevel checkcache)))))
-
-;;; Searching by Position APIs
-;;
-;; These functions will find nonterminals based on a position.
-(defun semantic-find-nonterminal-by-position (position streamorbuffer
-						       &optional nomedian)
-  "Find a nonterminal covering POSITION within STREAMORBUFFER.
-POSITION is a number, or marker.  If NOMEDIAN is non-nil, don't do
-the median calculation, and return nil."
-  (save-excursion
-    (if (markerp position) (set-buffer (marker-buffer position)))
-    (let* ((stream (if (bufferp streamorbuffer)
-		       (save-excursion
-			 (set-buffer streamorbuffer)
-			 (semantic-bovinate-toplevel))
-		     streamorbuffer))
-	   (prev nil)
-	   (found nil))
-      (while (and stream (not found))
-	;; perfect fit
-	(if (and (>= position (semantic-token-start (car stream)))
-		 (<= position (semantic-token-end (car stream))))
-	    (setq found (car stream))
-	  ;; Median between to objects.
-	  (if (and prev (not nomedian)
-		   (>= position (semantic-token-end prev))
-		   (<= position (semantic-token-start (car stream))))
-	      (let ((median (/ (+ (semantic-token-end prev)
-				  (semantic-token-start (car stream)))
-			       2)))
-		(setq found
-		      (if (> position median)
-			  (car stream)
-			prev)))))
-	;; Next!!!
-	(setq prev (car stream)
-	      stream (cdr stream)))
-      found)))
-
-(defun semantic-find-innermost-nonterminal-by-position
-  (position streamorbuffer &optional nomedian)
-  "Find a list of nonterminals covering POSITION within STREAMORBUFFER.
-POSITION is a number, or marker.  If NOMEDIAN is non-nil, don't do
-the median calculation, and return nil.
-This function will find the topmost item, and recurse until no more
-details are available of findable."
-  (let* ((returnme nil)
-	 (current (semantic-find-nonterminal-by-position
-		   position streamorbuffer nomedian))
-	 (nextstream (and current
-			  (if (eq (semantic-token-token current) 'type)
-			      (semantic-token-type-parts current)
-			    nil))))
-    (while nextstream
-      (setq returnme (cons current returnme))
-      (setq current (semantic-find-nonterminal-by-position
-		     position nextstream nomedian))
-      (setq nextstream (and current
-			    (if (eq (semantic-token-token current) 'token)
-				(semantic-token-type-parts current)
-			      nil))))
-    (nreverse (cons current returnme))))
-
-(defun semantic-find-nonterminal-by-overlay (&optional positionormarker buffer)
-  "Find all nonterminals covering POSITIONORMARKER by using overlays.
-If POSITIONORMARKER is nil, use the current point.
-Optional BUFFER is used if POSITIONORMARKER is a number, otherwise the current
-buffer is used.  This finds all tokens covering the specified position
-by checking for all overlays covering the current spot.  They are then sorted
-from largest to smallest via the start location."
-  (save-excursion
-    (when positionormarker
-      (if (markerp positionormarker)
-	  (set-buffer (marker-buffer positionormarker))
-	(if (bufferp buffer)
-	    (set-buffer buffer))))
-    (let ((ol (semantic-overlays-at (or positionormarker (point))))
-	  (ret nil))
-      (while ol
-	(let ((tmp (semantic-overlay-get (car ol) 'semantic)))
-	  (when tmp
-	    (setq ret (cons tmp ret))))
-	(setq ol (cdr ol)))
-      (sort ret (lambda (a b) (< (semantic-token-start a)
-				 (semantic-token-start b)))))))
-
-(defun semantic-find-nonterminal-by-overlay-in-region (start end &optional buffer)
-  "Find all nonterminals which exist in whole or in part between START and END.
-Uses overlays to determine positin.
-Optional BUFFER argument specifies the buffer to use."
-  (save-excursion
-    (if buffer (set-buffer buffer))
-    (let ((ol (semantic-overlays-in start end))
-	  (ret nil))
-      (while ol
-	(let ((tmp (semantic-overlay-get (car ol) 'semantic)))
-	  (when tmp
-	    (setq ret (cons tmp ret))))
-	(setq ol (cdr ol)))
-      (sort ret (lambda (a b) (< (semantic-token-start a)
-				 (semantic-token-start b)))))))
-
-(defun semantic-find-nonterminal-by-overlay-next (&optional start buffer)
-  "Find the next nonterminal after START in BUFFER.
-If START is in an overlay, find the token which starts next,
-not the current token."
-  (save-excursion
-    (if buffer (set-buffer buffer))
-    (if (not start) (setq start (point)))
-    (let ((os start) (ol nil))
-      (while (and os (< os (point-max)) (not ol))
-	(setq os (semantic-overlay-next-change os))
-	(when os
-	  ;; Get overlays at position
-	  (setq ol (semantic-overlays-at os))
-	  ;; find the overlay that belongs to semantic
-	  ;; and starts at the found position.
-	  (while (and ol (listp ol))
-	    (if (and (semantic-overlay-get (car ol) 'semantic)
-		     (= (semantic-overlay-start (car ol)) os))
-		(setq ol (car ol)))
-	    (when (listp ol) (setq ol (cdr ol))))))
-      ;; convert ol to a token
-      (when ol
-	(semantic-overlay-get ol 'semantic)))))
-
-(defun semantic-find-nonterminal-by-overlay-prev (&optional start buffer)
-  "Find the next nonterminal after START in BUFFER.
-If START is in an overlay, find the token which starts next,
-not the current token."
-  (save-excursion
-    (if buffer (set-buffer buffer))
-    (if (not start) (setq start (point)))
-    (let ((os start) (ol nil))
-      (while (and os (> os (point-min)) (not ol))
-	(setq os (semantic-overlay-previous-change os))
-	(when os
-	  ;; Get overlays at position
-	  (setq ol (semantic-overlays-at os))
-	  ;; find the overlay that belongs to semantic
-	  ;; and starts at the found position.
-	  (while (and ol (listp ol))
-	    (if (and (semantic-overlay-get (car ol) 'semantic)
-		     (= (semantic-overlay-start (car ol)) os))
-		(setq ol (car ol)))
-	    (when (listp ol) (setq ol (cdr ol))))))
-      ;; convert ol to a token
-      (when ol
-	(semantic-overlay-get ol 'semantic)))))
-
-(defun semantic-current-nonterminal ()
-  "Return the current nonterminal in the current buffer.
-If there are more than one in the same location, return the
-smallest token."
-  (car (nreverse (semantic-find-nonterminal-by-overlay))))
-
-;;; Nonterminal regions and splicing
-;;
-;; This functionality is needed to take some set of dirty code,
-;; and splice in new tokens after a partial reparse.
-
-(defun semantic-change-function-mark-dirty  (start end length)
-  "Run whenever a buffer controlled by `semantic-mode' changes.
-Tracks when and how the buffer is re-parsed.
-Argument START, END, and LENGTH specify the bounds of the change."
-  (when (and (not semantic-toplevel-bovine-cache-check)
-	     (not semantic-edits-are-safe))
-    (let ((tl (condition-case nil
-		  (nreverse (semantic-find-nonterminal-by-overlay-in-region
-		   (1- start) (1+ end)))
-		(error nil))))
-      (if tl
-	  (catch 'alldone
-	    ;; Loop over the token list
-	    (while tl
-	      (cond
-	       ;; If we are completely enclosed in this overlay.
-	       ((and (> start (semantic-token-start (car tl)))
-		     (< end (semantic-token-end (car tl))))
-		(if (semantic-token-get (car tl) 'dirty)
-		    nil
-		  (add-to-list 'semantic-dirty-tokens (car tl))
-		  (semantic-token-put (car tl) 'dirty t)
-		  (condition-case nil
-		      (run-hook-with-args 'semantic-dirty-token-hooks
-					  (car tl) start end)
-		    (error (if debug-on-error (debug)))))
-		  (throw 'alldone t))
-	       ;; If we cover the beginning or end of this item, we must
-	       ;; reparse this object.  If there are more items coming, then postpone
-	       ;; this till later.
-	       ((not (cdr tl))
-		(setq semantic-toplevel-bovine-cache-check t)
-		(run-hooks 'semantic-reparse-needed-change-hook))
-	       (t nil))
-	      ;; next
-	      (setq tl (cdr tl))))
-	;; There was no hit, perhaps we need to reparse this intermediate area.
-	(setq semantic-toplevel-bovine-cache-check t)
-	)
-      )))
-;;
-;; Properties set on the tokens are:
-;;  dirty          - This token is dirty
-;;  dirty-after    - This token, and the white space after it is dirty
-;;  dirty-before   - This token, and the white space before it is dirty
-;;  dirty-children - This token has children that are dirty.
-;;
-;; EXPERIMENTAL
-(defsubst semantic-find-nearby-dirty-tokens (beg end)
-  "Make a special kind of token for dirty whitespace.
-Argument BEG and END is the region to find nearby tokens.
-EXPERIMENTAL"
-  (let ((prev (semantic-find-nonterminal-by-overlay-prev beg))
-	(next (semantic-find-nonterminal-by-overlay-next end)))
-    (if prev (semantic-token-put prev 'dirty-after t))
-    (if next (semantic-token-put next 'dirty-before t))
-    (list prev next)))
-
-(defun semantic-set-tokens-dirty-in-region (beg end)
-  "Mark the region between BEG and END as dirty.
-This is done by finding tokens overlapping the region, and marking
-them dirty.  Regions not covered by a token are then marked as
-dirty-after, meaning the space after that area is dirty.
-This function will be called in an after change hook, and must
-be very fast.
-EXPERIMENTAL"
-  (let ((tromp (semantic-find-nonterminal-by-overlay-in-region beg end))
-	(ttmp nil)
-	)
-    (if (not tromp)
-	;; No tokens hit, setup a dirty region on the screen.
-	(setq tromp nil) ;(semantic-get-dirty-token beg end))
-      ;; First, mark all fully dirty tokens.
-      (setq ttmp tromp)
-      (while ttmp
-	(and (> beg (semantic-token-start (car tromp)))
-	     (< end (semantic-token-end (car tromp))))
-
-	)
-	)))
-
-
-;;; Generalized nonterminal searching
-;;
-;; These functions will search through nonterminal lists explicity for
-;; desired information.
-
-;; The -by-name nonterminal search can use the built in fcn
-;; `assoc', which is faster than looping ourselves, so we will
-;; not use `semantic-find-nonterminal-by-function' to do this,
-;; instead erroring on the side of speed.
-(defun semantic-find-nonterminal-by-name
-  (name streamorbuffer &optional search-parts search-include)
-  "Find a nonterminal NAME within STREAMORBUFFER.  NAME is a string.
-If SEARCH-PARTS is non-nil, search children of tokens.
-If SEARCH-INCLUDE is non-nil, search include files."
-  (let* ((stream (if (bufferp streamorbuffer)
-		     (save-excursion
-		       (set-buffer streamorbuffer)
-		       (semantic-bovinate-toplevel))
-		   streamorbuffer))
-         (assoc-fun (if semantic-case-fold
-                        #'assoc-ignore-case
-                      #'assoc))
-	 (m (funcall assoc-fun name stream)))
-    (if m
-	m
-      (let ((toklst stream)
-	    (children nil))
-	(while (and (not m) toklst)
-	  (if search-parts
-	      (progn
-		(setq children (semantic-nonterminal-children (car toklst) t))
-		(if children
-		    (setq m (semantic-find-nonterminal-by-name
-			     name children search-parts search-include)))))
-	  (setq toklst (cdr toklst)))
-	(if (not m)
-	    ;; Go to dependencies, and search there.
-	    nil)
-	m))))
-
-(defmacro semantic-find-nonterminal-by-token
-  (token streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals with a token TOKEN within STREAMORBUFFER.
-TOKEN is a symbol representing the type of the tokens to find.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDE are passed to
-`semantic-find-nonterminal-by-function'."
-  `(semantic-find-nonterminal-by-function
-    (lambda (tok) (eq ,token (semantic-token-token tok)))
-    ,streamorbuffer ,search-parts ,search-includes))
-
-(defmacro semantic-find-nonterminal-standard
-  (streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals in STREAMORBUFFER which define simple token types.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDE are passed to
-`semantic-find-nonterminal-by-function'."
-  `(semantic-find-nonterminal-by-function
-    (lambda (tok) (member tok '(function variable type)))
-    ,streamorbuffer ,search-parts ,search-includes))
-
-(defvar semantic-default-built-in-types nil
-  "For a given language, a set of built-in types.")
-(make-variable-buffer-local 'semantic-default-built-in-types)
-
-(defun semantic-find-nonterminal-by-type
-  (type streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals with type TYPE within STREAMORBUFFER.
-TYPE is a string which is the name of the type of the token returned.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
-`semantic-find-nonterminal-by-function'."
-  (if (member type semantic-default-built-in-types)
-      (list (list type 'type "built in"))
-    (semantic-find-nonterminal-by-function
-     (lambda (tok)
-       (let ((ts (semantic-token-type tok)))
-	 (if (and (listp ts) (eq (semantic-token-token ts) 'type))
-	     (setq ts (semantic-token-name ts)))
-	 (equal type ts)))
-     streamorbuffer search-parts search-includes)))
-
-(defun semantic-find-nonterminal-by-type-regexp
-  (regexp streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals with type matching REGEXP within STREAMORBUFFER.
-REGEXP is a regular expression  which matches the  name of the type of the
-tokens returned.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
-`semantic-find-nonterminal-by-function'."
-  (semantic-find-nonterminal-by-function
-   (lambda (tok)
-     (let ((ts (semantic-token-type tok)))
-       (if (listp ts)
-	   (setq ts
-		 (if (eq (semantic-token-token ts) 'type)
-		     (semantic-token-name ts)
-		   (car ts))))
-       (and ts (string-match regexp ts))))
-   streamorbuffer search-parts search-includes))
-
-(defmacro semantic-find-nonterminal-by-name-regexp
-  (regex streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals whose name match REGEX in STREAMORBUFFER.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
-`semantic-find-nonterminal-by-function'."
-  `(semantic-find-nonterminal-by-function
-    (lambda (tok) (string-match ,regex (semantic-token-name tok)))
-    ,streamorbuffer ,search-parts ,search-includes)
-  )
-
-(defmacro semantic-find-nonterminal-by-property
-  (property value streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals with PROPERTY equal to VALUE in STREAMORBUFFER.
-Properties can be added with `semantic-token-put'.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
-`semantic-find-nonterminal-by-function'."
-  `(semantic-find-nonterminal-by-function
-   (lambda (tok) (equal (semantic-token-get tok ,property) ,value))
-   ,streamorbuffer ,search-parts ,search-includes)
-  )
-
-(defmacro semantic-find-nonterminal-by-extra-spec
-  (spec streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals with a given SPEC in STREAMORBUFFER.
-SPEC is a symbol key into the modifiers association list.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
-`semantic-find-nonterminal-by-function'."
-  `(semantic-find-nonterminal-by-function
-    (lambda (tok) (semantic-token-extra-spec tok ,spec))
-    ,streamorbuffer ,search-parts ,search-includes)
-  )
-
-(defmacro semantic-find-nonterminal-by-extra-spec-value
-  (spec value streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals with a given SPEC equal to VALUE in STREAMORBUFFER.
-SPEC is a symbol key into the modifiers association list.
-VALUE is the value that SPEC should match.
-Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
-`semantic-find-nonterminal-by-function'."
-  `(semantic-find-nonterminal-by-function
-    (lambda (tok) (equal (semantic-token-extra-spec tok ,spec) ,value))
-    ,streamorbuffer ,search-parts ,search-includes)
-  )
-
-(defun semantic-find-nonterminal-by-function
-  (function streamorbuffer &optional search-parts search-includes)
-  "Find all nonterminals in which FUNCTION match within STREAMORBUFFER.
-FUNCTION must return non-nil if an element of STREAM will be included
-in the new list.
-
-If optional argument SEARCH-PARTS is non-nil, all sub-parts of tokens
-are searched.  The overloadable function `semantic-nonterminal-children' is
-used for the searching child lists.  If SEARCH-PARTS is the symbol
-'positiononly, then only children that have positional information are
-searched.
-
-If SEARCH-INCLUDES is non-nil, then all include files are also
-searched for matches."
-  (let ((streamlist (list
-		     (if (bufferp streamorbuffer)
-			 (save-excursion
-			   (set-buffer streamorbuffer)
-			   (semantic-bovinate-toplevel))
-		       streamorbuffer)))
-	(includes nil)			;list of includes
-	(stream nil)			;current stream
-	(sl nil)			;list of token children
-	(nl nil)			;new list
-        (case-fold-search semantic-case-fold))
-    (if search-includes
-	(setq includes (semantic-find-nonterminal-by-token
-			'include (car streamlist))))
-    (while streamlist
-      (setq stream (car streamlist))
-      (while stream
-	(if (funcall function (car stream))
-	    (setq nl (cons (car stream) nl)))
-	(if search-parts
-	    (progn
-	      (setq sl (semantic-nonterminal-children
-			(car stream)
-			t
-			))
-	      (if sl
-		  (setq nl (append nl (semantic-find-nonterminal-by-function
-				       function sl
-				       search-parts search-includes))))))
-	;; next token
-	(setq stream (cdr stream)))
-      (setq streamlist (cdr streamlist)))
-    (setq nl (nreverse nl))
-;    (while includes
-;      (setq nl (append nl (semantic-find-nonterminal-by-function
-;			   
-;			   ))))
-    nl))
-
-(defun semantic-find-nonterminal-by-function-first-match
-  (function streamorbuffer &optional search-parts search-includes)
-  "Find the first nonterminal which FUNCTION match within STREAMORBUFFER.
-FUNCTION must return non-nil if an element of STREAM will be included
-in the new list.
-If optional argument SEARCH-PARTS, all sub-parts of tokens are searched.
-The overloadable function `semantic-nonterminal-children' is used for
-searching.
-If SEARCH-INCLUDES is non-nil, then all include files are also
-searched for matches."
-  (let ((stream (if (bufferp streamorbuffer)
-		     (save-excursion
-		       (set-buffer streamorbuffer)
-		       (semantic-bovinate-toplevel))
-		   streamorbuffer))
-	(found nil)
-        (case-fold-search semantic-case-fold))
-    (while (and (not found) stream)
-      (if (funcall function (car stream))
-	  (setq found (car stream)))
-      (setq stream (cdr stream)))
-    found))
-
-;;; Bucketizing: Take and convert the tokens based on type.
-;;
-(defun semantic-bucketize (tokens &optional filter)
-  "Sort TOKENS into a group of buckets based on token type.
-Unknown types are placed in a Misc bucket.
-The buckets will be organized into a form usable by `semantic-sb-buttons'.
-Optional argument FILTER is a filter function to be applied to each bucket.
-The filter function will take one argument, which is a list of tokens, and
-may re-organize the list with side-effects."
-  (let ((bins (make-vector (1+ (length semantic-symbol->name-assoc-list)) nil))
-	ask toktype
-	(sn semantic-symbol->name-assoc-list)
-	(nsn nil)
-	(num 1)
-	(out nil))
-    ;; Build up the bucket vector
-    (while sn
-      (setq nsn (cons (cons (car (car sn)) num) nsn)
-	    sn (cdr sn)
-	    num (1+ num)))
-    ;; Place into buckets
-    (while tokens
-      (setq toktype (semantic-token-token (car tokens))
-	    ask (assq toktype nsn)
-	    num (or (cdr ask) 0))
-      (aset bins num (cons (car tokens) (aref bins num)))
-      (setq tokens (cdr tokens)))
-    ;; Remove from buckets into a list.
-    (setq num 1)
-    (while (< num (length bins))
-      (when (aref bins num)
-	(setq out
-	      (cons (cons
-		     (cdr (nth (1- num) semantic-symbol->name-assoc-list))
-		     ;; Filtering, First hacked by David Ponce david@dponce.com
-		     (funcall (or filter 'nreverse) (aref bins num)))
-		    out)))
-      (setq num (1+ num)))
-    (if (aref bins 0)
-	(setq out (cons (cons "Misc"
-			      (funcall (or filter 'nreverse) (aref bins 0)))
-			out)))
-    (nreverse out)))
-
-;; Some sorting functions
-(defun semantic-string-lessp-ci (s1 s2)
-  "Case insensitive version of `string-lessp'."
-  ;; Use downcase instead of upcase because an average name
-  ;; has more lower case characters.
-  (string-lessp (downcase s1) (downcase s2)))
-
-(defun semantic-sort-token-type (token)
-  "Return a type string for TOKEN guaranteed to be a string."
-  (let ((ty (semantic-token-type token)))
-    (cond ((stringp ty)
-	   ty)
-	  ((listp ty)
-	   (or (car ty) ""))
-	  (t ""))))
-
-(defun semantic-sort-tokens-by-name-increasing (tokens)
-  "Sort TOKENS by name in increasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (string-lessp (semantic-token-name a)
-			       (semantic-token-name b)))))
-
-(defun semantic-sort-tokens-by-name-decreasing (tokens)
-  "Sort TOKENS by name in decreasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (string-lessp (semantic-token-name b)
-			       (semantic-token-name a)))))
-
-(defun semantic-sort-tokens-by-type-increasing (tokens)
-  "Sort TOKENS by type in increasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (string-lessp (semantic-sort-token-type a)
-			       (semantic-sort-token-type b)))))
-
-(defun semantic-sort-tokens-by-type-decreasing (tokens)
-  "Sort TOKENS by type in decreasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (string-lessp (semantic-sort-token-type b)
-			       (semantic-sort-token-type a)))))
-
-(defun semantic-sort-tokens-by-name-increasing-ci (tokens)
-  "Sort TOKENS by name in increasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (semantic-string-lessp-ci (semantic-token-name a)
-					   (semantic-token-name b)))))
-
-(defun semantic-sort-tokens-by-name-decreasing-ci (tokens)
-  "Sort TOKENS by name in decreasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (semantic-string-lessp-ci (semantic-token-name b)
-					   (semantic-token-name a)))))
-
-(defun semantic-sort-tokens-by-type-increasing-ci (tokens)
-  "Sort TOKENS by type in increasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (semantic-string-lessp-ci (semantic-sort-token-type a)
-					   (semantic-sort-token-type b)))))
-
-(defun semantic-sort-tokens-by-type-decreasing-ci (tokens)
-  "Sort TOKENS by type in decreasing order with side effects.
-Return the sorted list."
-  (sort tokens (lambda (a b)
-		 (semantic-string-lessp-ci (semantic-sort-token-type b)
-					   (semantic-sort-token-type a)))))
-
-;;; Recursive searching through dependency trees
-;;
-;; This will depend on the general searching APIS defined above.
-;; but will add full recursion through the dependencies list per
-;; stream.
-(defun semantic-recursive-find-nonterminal-by-name (name buffer)
-  "Recursivly find the first occurance of NAME.
-Start search with BUFFER.  Recurse through all dependencies till found.
-The return item is of the form (BUFFER TOKEN) where BUFFER is the buffer
-in which TOKEN (the token found to match NAME) was found."
-  (save-excursion
-    (set-buffer buffer)
-    (let* ((stream (semantic-bovinate-toplevel))
-	   (includelist (or (semantic-find-nonterminal-by-token 'include stream)
-			    "empty.silly.thing"))
-	   (found (semantic-find-nonterminal-by-name name stream))
-	   (unfound nil))
-      (while (and (not found) includelist)
-	(let ((fn (semantic-find-dependency (car includelist))))
-	  (if (and fn (not (member fn unfound)))
-	      (save-excursion
-		(set-buffer (find-file-noselect fn))
-		(message "Scanning %s" (buffer-file-name))
-		(setq stream (semantic-bovinate-toplevel))
-		(setq found (semantic-find-nonterminal-by-name name stream))
-		(if found
-		    (setq found (cons (current-buffer) (list found)))
-		  (setq includelist
-			(append includelist
-				(semantic-find-nonterminal-by-token
-				 'include stream))))
-		(setq unfound (cons fn unfound)))))
-	(setq includelist (cdr includelist)))
-      found)))
-  
-;;; Completion APIs
-;;
-;; These functions provide minibuffer reading/completion for lists of
-;; nonterminals.
-(defvar semantic-read-symbol-history nil
-  "History for a symbol read.")
-
-(defun semantic-read-symbol (prompt &optional default stream filter)
-  "Read a symbol name from the user for the current buffer.
-PROMPT is the prompt to use.
-Optional arguments:
-DEFAULT is the default choice.  If no default is given, one is read
-from under point.
-STREAM is the list of tokens to complete from.
-FILTER is provides a filter on the types of things to complete.
-FILTER must be a function to call on each element."
-  (if (not default) (setq default (thing-at-point 'symbol)))
-  (if (not stream) (setq stream (semantic-bovinate-toplevel)))
-  (setq stream
-	(if filter
-	    (semantic-find-nonterminal-by-function filter stream)
-	  (semantic-find-nonterminal-standard stream)))
-  (if (and default (string-match ":" prompt))
-      (setq prompt
-	    (concat (substring prompt 0 (match-end 0))
-		    " (default: " default ") ")))
-  (completing-read prompt stream nil t ""
-		   'semantic-read-symbol-history
-		   default))
-
-(defun semantic-read-variable (prompt &optional default stream)
-  "Read a variable name from the user for the current buffer.
-PROMPT is the prompt to use.
-Optional arguments:
-DEFAULT is the default choice.  If no default is given, one is read
-from under point.
-STREAM is the list of tokens to complete from."
-  (semantic-read-symbol
-   prompt default (semantic-find-nonterminal-by-type 'variable stream)))
-
-(defun semantic-read-function (prompt &optional default stream)
-  "Read a function name from the user for the current buffer.
-PROMPT is the prompt to use.
-Optional arguments:
-DEFAULT is the default choice.  If no default is given, one is read
-from under point.
-STREAM is the list of tokens to complete from."
-  (semantic-read-symbol
-   prompt default (semantic-find-nonterminal-by-type 'function stream)))
-
-(defun semantic-read-type (prompt &optional default stream)
-  "Read a type name from the user for the current buffer.
-PROMPT is the prompt to use.
-Optional arguments:
-DEFAULT is the default choice.  If no default is given, one is read
-from under point.
-STREAM is the list of tokens to complete from."
-  (semantic-read-symbol
-   prompt default (semantic-find-nonterminal-by-type 'type stream)))
-
-;;; Behavioral APIs
-;;
-;; Each major mode will want to support a specific set of behaviors.
-;; Usually generic behaviors that need just a little bit of local
-;; specifics.  This section permits the setting of override functions
-;; for tasks of that nature, and also provides reasonable defaults.
-
-(defvar semantic-override-table nil
-  "Buffer local semantic function overrides obarray.
-These overrides provide a hook for a `major-mode' to override specific
-behaviors with respect to generated semantic toplevel nonterminals and
-things that these non-terminals are useful for.  Use the function
-`semantic-install-function-overrides' to install overrides.
-
-Available override symbols:
-
-  SYBMOL                  PARAMETERS         DESCRIPTION
- `abbreviate-nonterminal' (tok & parent color)        Return summary string.
- `summarize-nonterminal'  (tok & parent color)        Return summary string.
- `prototype-nonterminal'  (tok & parent color)        Return a prototype string.
- `concise-prototype-nonterminal' (tok & parent color) Return a concise prototype string.
- `uml-abbreviate-nonterminal' (tok & parent color)    Return a UML standard abbreviation string.
-
- `find-dependency'        (token)            Find the dependency file
- `find-nonterminal'       (token & parent)   Find token in buffer.
- `find-documentation'     (token & nosnarf)  Find doc comments.
- `prototype-file'         (buffer)           Return a file in which
- 	                                     prototypes are placed
- `nonterminal-children'   (token)            Return first rate children.
-					     These are children which may
-					     contain overlays.
- `nonterminal-protection' (token & parent)   Protection (as a symbol)
-
-  CONTEXT FUNCTIONS:
- `beginning-of-context'   (& point)          Move to the beginning of the
-					     current context.
- `end-of-context'         (& point)          Move to the end of the
-					     current context.
- `up-context'             (& point)          Move up one context level.
- `get-local-variables'    (& point)          Get local variables.
- `get-all-local-variables'(& point)          Get all local variables.
- `get-local-arguments'    (& point)          Get arguments to this function.
-
- `end-of-command'                            Move to the end of the current
-                                             command
- `beginning-of-command'                      Move to the beginning of the
-                                             current command
- `ctxt-current-symbol'    (& point)          List of related symbols.
- `ctxt-current-assignment'(& point)          Variable being assigned to.
- `ctxt-current-function'  (& point)          Function being called at point.
- `ctxt-current-argument'  (& point)          The index to the argument of
-                                             the current function the cursor
-                                             is in.
-
-Parameters mean:
-
-  &      - Following parameters are optional
-  buffer - The buffer in which a token was found.
-  token  - The nonterminal token we are doing stuff with
-  parent - If a TOKEN is stripped (of positional infomration) then
-           this will be the parent token which should have positional
-           information in it.")
-(make-variable-buffer-local 'semantic-override-table)
-
-(defun semantic-install-function-overrides (overrides &optional transient)
-  "Install function OVERRIDES in `semantic-override-table'.
-If optional TRANSIENT is non-nil installed overrides can in turn be
-overridden by next installation.  OVERRIDES must be an alist.  Each
-element must be of the form: (SYM . FUN) where SYM is the symbol to
-override, and FUN is the function to override it with."
-  (if (not (arrayp semantic-override-table))
-      (setq semantic-override-table (make-vector 13 nil)))
-  (let (sym sym-name fun override)
-    (while overrides
-      (setq override  (car overrides)
-            overrides (cdr overrides)
-            sym-name  (symbol-name (car override))
-            fun       (cdr override))
-      (if (setq sym (intern-soft sym-name semantic-override-table))
-          (if (get sym 'override)
-              (set sym fun)
-            (or (equal (symbol-value sym) fun)
-                (message "Current `%s' function #'%s not overrode by #'%s"
-                         sym (symbol-value sym) fun)))
-        (setq sym (intern sym-name semantic-override-table))
-        (set sym fun))
-      (put sym 'override transient))))
-
-(defun semantic-fetch-overload (sym)
-  "Find and return the overload function for SYM.
-Return nil if not found."
-  (symbol-value
-   (and (arrayp semantic-override-table)
-        (intern-soft (symbol-name sym) semantic-override-table))))
-
-;;; Token to text overload functions
-;;
-;; Abbreviations, prototypes, and coloring support.
-(eval-when-compile (require 'font-lock))
-
-(defvar semantic-token->text-functions
-  '(semantic-name-nonterminal
-    semantic-abbreviate-nonterminal
-    semantic-summarize-nonterminal
-    semantic-prototype-nonterminal
-    semantic-concise-prototype-nonterminal
-    semantic-uml-abbreviate-nonterminal
-    semantic-uml-prototype-nonterminal
-    )
-  "List of functions which convert a token to text.
-Each function must take the parameters TOKEN &optional PARENT COLOR.
-TOKEN is the token to convert.
-PARENT is a parent token or name which refers to the structure
-or class which contains TOKEN.  PARENT is NOT a class which a TOKEN
-would claim as a parent.
-COLOR indicates that the generated text should be colored using
-`font-lock'.")
-
-(defvar semantic-token->text-custom-list
-  (append '(radio)
-	  (mapcar (lambda (f) (list 'const f))
-		  semantic-token->text-functions)
-	  '(function))
-  "A List used by customizeable variables to choose a token to text function.
-Use this variable in the :type field of a customizable variable.")
-
-
-(defvar semantic-face-alist
-  `( (function . font-lock-function-name-face)
-     (variable . font-lock-variable-name-face)
-     (type . font-lock-type-face)
-     ;; These are different between Emacsen.
-     (include . ,(if (featurep 'xemacs)
-		     'font-lock-preprocessor-face
-		   'font-lock-constant-face))
-     (package . ,(if (featurep 'xemacs)
-		     'font-lock-preprocessor-face
-		   'font-lock-constant-face))
-     ;; Not a token, but instead a feature of output
-     (label . font-lock-string-face)
-     (comment . font-lock-comment-face)
-     (keyword . font-lock-keyword-face)
-     )
-  "Face used to colorize tokens of different types.
-Override the value locally if a language supports other token types.
-When adding new elements, try to use symbols also returned by the parser.
-The form of an entry in this list is of the form:
- ( SYMBOL .  FACE )
-where SYMBOL is a token type symbol used with semantic.  FACE
-is a symbol representing a face.
-Faces used are generated in `font-lock' for consistency, and will not
-be used unless font lock is a feature.")
-
-;;; Coloring Functions
-(defun semantic-colorize-text (text face-class)
-  "Apply onto TEXT a color associated with FACE-CLASS.
-FACE-CLASS is a token type found in `semantic-face-alist'.  See this variable
-for details on adding new types."
-  (let ((face (cdr-safe (assoc face-class semantic-face-alist)))
-	(newtext (concat text)))
-    (put-text-property 0 (length text) 'face face newtext)
-    newtext)
-  )
-
-;;; The token->text functions
-(defun semantic-name-nonterminal (token &optional parent color)
-  "Return the name string describing TOKEN.
-The name is the shortest possible representation.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((s (semantic-fetch-overload 'name-nonterminal))
-	tt)
-    ;; No colors without font lock
-    (if (not (featurep 'font-lock)) (setq color nil))
-    (if s
-	(funcall s token parent color)
-      (semantic-name-nonterminal-default token parent color))))
-
-(defun semantic-name-nonterminal-default (token &optional parent color)
-  "Return an abbreviated string describing TOKEN.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((name (semantic-token-name token)))
-    (if color
-	(setq name (semantic-colorize-text name (semantic-token-token token))))
-    name))
-
-(defun semantic-abbreviate-nonterminal (token &optional parent color)
-  "Return an abbreviated string describing TOKEN.
-The abbreviation is to be short, with possible symbols indicating
-the type of token, or other information.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((s (semantic-fetch-overload 'abbreviate-nonterminal)))
-    ;; No colors without font lock
-    (if (not (featurep 'font-lock)) (setq color nil))
-    (if s
-	(funcall s token parent color)
-      (semantic-abbreviate-nonterminal-default token parent color))))
-
-(defun semantic-abbreviate-nonterminal-default (token &optional parent color)
-  "Return an abbreviated string describing TOKEN.
-Optional argument PARENT is a parent token in the token hierarchy.
-In this case PARENT refers to containment, not inheritance.
-Optional argument COLOR means highlight the prototype with font-lock colors.
-This is a simple C like default."
-  ;; Do lots of complex stuff here.
-  (let ((tok (semantic-token-token token))
-	(name (semantic-name-nonterminal token parent color))
-	(suffix "")
-	str)
-    (cond ((eq tok 'function)
-	   (setq suffix "()"))
-	  ((eq tok 'include)
-	   (setq suffix "<>"))
-	  ((eq tok 'variable)
-	   (setq suffix (if (semantic-token-variable-default token)
-			    "=" "")))
-	  )
-    (setq str (concat name suffix))
-    (if parent
-	(setq str
-	      (concat (semantic-name-nonterminal parent color)
-		      (car semantic-type-relation-separator-character)
-		      str)))
-    str))
-
-;; Semantic 1.2.x had this misspelling.  Keep it for backwards compatibiity.
-(defalias 'semantic-summerize-nonterminal 'semantic-summarize-nonterminal)
-
-(defun semantic-summarize-nonterminal (token &optional parent color)
-  "Summarize TOKEN in a reasonable way.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((s (semantic-fetch-overload 'summarize-nonterminal)))
-    ;; No colors without font lock
-    (if (not (featurep 'font-lock)) (setq color nil))
-    (if s
-	(funcall s token parent color)
-      (semantic-summarize-nonterminal-default token parent color)
-      )))
-
-(defun semantic-summarize-nonterminal-default (token &optional parent color)
-  "Summarize TOKEN in a reasonable way.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((proto (semantic-prototype-nonterminal token nil color))
-	(label (capitalize
-		(or (cdr-safe (assoc (semantic-token-token token)
-				     semantic-symbol->name-assoc-list))
-		    (symbol-name (semantic-token-token token))))))
-    (if color
-	(setq label (semantic-colorize-text label 'label)))
-    (concat label ": " proto))
-  )
-
-(defun semantic-prototype-nonterminal (token &optional parent color)
-  "Return a prototype for TOKEN.
-This function should be overloaded, though it need not be used.
-This is because it can be used to create code by language independent
-tools.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((s (semantic-fetch-overload 'prototype-nonterminal)))
-    ;; No colors without font lock
-    (if (not (featurep 'font-lock)) (setq color nil))
-    (if s
-	;; Prototype is non-local
-	(funcall s token parent color)
-      (semantic-prototype-nonterminal-default token parent color))))
-
-(defun semantic-prototype-nonterminal-default-args (args color)
-  "Create a list of of strings for prototypes of ARGS.
-ARGS can be a list of terminals, or a list of strings.
-COLOR specifies if these arguments should be colored or not."
-  (let ((out nil))
-    (while args
-      (cond ((stringp (car args))
-	     (let ((a (car args)))
-	       (if color
-		   (setq a (semantic-colorize-text a 'variable)))
-	       (setq out (cons a out))
-	       ))
-	    ((semantic-token-p (car args))
-	     (setq out
-		   (cons (semantic-prototype-nonterminal (car args) nil t)
-			 out))))
-      (setq args (cdr args)))
-    (nreverse out)))
-
-(defun semantic-prototype-nonterminal-default (token &optional parent color)
-  "Default method for returning a prototype for TOKEN.
-This will work for C like languages.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let* ((tok (semantic-token-token token))
-	 (name (semantic-name-nonterminal token parent color))
-	 (type (if (member tok '(function variable type))
-		   (semantic-token-type token)))
-	 (args (semantic-prototype-nonterminal-default-args
-		(cond ((eq tok 'function)
-		       (semantic-token-function-args token))
-		      ((eq tok 'type)
-		       (semantic-token-type-parts token))
-		      (t nil))
-		color))
-	 (const (semantic-token-extra-spec token 'const))
-	 (mods (append
-		(if const '("const") nil)
-		(semantic-token-extra-spec token 'typemodifiers)))
-	 (array (if (eq tok 'variable)
-		    (let ((deref
-			   (semantic-token-variable-extra-spec
-			    token 'dereference))
-			  (r ""))
-		      (while (and deref (/= deref 0))
-			(setq r (concat r "[]")
-			      deref (1- deref)))
-		      r)))
-	 (suffix (if (eq tok 'variable)
-		     (semantic-token-variable-extra-spec token 'suffix)))
-	 )
-    (if (and (listp mods) mods)
-	(setq mods (concat (mapconcat (lambda (a) a) mods " ") " ")))
-    (if (and mods color)
-	(setq mods (semantic-colorize-text mods 'type)))
-    (if args
-	(setq args
-	      (concat " "
-		      (if (eq tok 'type) "{" "(")
-		      (mapconcat (lambda (a) a) args ",")
-		      (if (eq tok 'type) "}" ")"))))
-    (if type
-	(if (semantic-token-p type)
-	    (setq type (semantic-prototype-nonterminal type nil color))
-	  (if (listp type)
-	      (setq type (car type)))
-	  (if color
-	      (setq type (semantic-colorize-text type 'type)))))
-    (concat (or mods "")
-	    (if type (concat type " "))
-	    name
-	    (or args "")
-	    (or array ""))))
-
-(defun semantic-concise-prototype-nonterminal (token &optional parent color)
-  "Return a concise prototype for TOKEN.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((s (semantic-fetch-overload 'concise-prototype-nonterminal)))
-    (if s
-	(funcall s token parent color)
-      (semantic-concise-prototype-nonterminal-default token parent color))))
-
-(defun semantic-concise-prototype-nonterminal-default (token &optional parent color)
-  "Return a concise prototype for TOKEN.
-This default function will make a cheap concise prototype using C like syntax.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((tok (semantic-token-token token)))
-    (cond
-     ((eq tok 'type)
-      (concat (semantic-name-nonterminal token parent color) "{}"))
-     ((eq tok 'function)
-      (let ((args (semantic-token-function-args token)))
-        (concat (semantic-name-nonterminal token parent color)
-                "("
-                (if args
-                    (cond ((stringp (car args))
-			   (mapconcat
-			    (if color
-				(lambda (a) (semantic-colorize-text
-					     a 'variable))
-			      'identity)
-			    args ","))
-			  ((semantic-token-p (car args))
-			   (mapconcat
-			    (lambda (a)
-			      (let ((ty (semantic-token-type a)))
-				(cond ((and (stringp ty) color)
-				       (semantic-colorize-text ty 'type))
-				      ((stringp ty)
-				       ty)
-				      ((semantic-token-p ty)
-				       (semantic-prototype-nonterminal
-					ty parent nil))
-				      ((and (consp ty) color)
-				       (semantic-colorize-text (car ty) 'type))
-				      ((consp ty)
-				       (car ty))
-				      (t (error "Concice-prototype")))))
-			    args ", "))
-			  ((consp (car args))
-			   (mapconcat
-			    (if color
-				(lambda (a)
-				  (semantic-colorize-text (car a) 'type))
-			      'car)
-			    args ","))
-			  (t (error "Concice-prototype")))
-                  "")
-                ")")))
-     ((eq tok 'variable)
-      (let* ((deref (semantic-token-variable-extra-spec
-                     token 'dereference))
-             (array "")
-             (suffix (semantic-token-variable-extra-spec
-                      token 'suffix)))
-        (while (and deref (/= deref 0))
-          (setq array (concat array "[]")
-                deref (1- deref)))
-        (concat (semantic-name-nonterminal token parent nil)
-                array)))
-     (t
-      (semantic-abbreviate-nonterminal token parent nil)))))
-
-(defun semantic-uml-protection-to-string (protection-symbol)
-  "Convert PROTECTION-SYMBOL to a string for UML."
-  (cond ((eq protection-symbol 'public)
-	 "+")
-	((eq protection-symbol 'private)
-	 "-")
-	((eq protection-symbol 'protected)
-	 "#")
-	(t " ")))
-
-(defun semantic-uml-abbreviate-nonterminal (token &optional parent color)
-  "Return a UML style abbreviation for TOKEN.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((s (semantic-fetch-overload 'uml-abbreviate-nonterminal)))
-    (if s
-	(funcall s token parent color)
-      (semantic-uml-abbreviate-nonterminal-default token parent color))))
-
-(defun semantic-uml-abbreviate-nonterminal-default (token &optional parent color)
-  "Return a UML style abbreviation for TOKEN.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let* ((tok (semantic-token-token token))
-	 (name (semantic-name-nonterminal token parent color))
-	 (type (or (semantic-token-type token) ""))
-	 (prot (semantic-nonterminal-protection token parent))
-	 )
-    (setq type
-	  (cond ((semantic-token-p type)
-		 (semantic-prototype-nonterminal type nil color))
-		((listp type)
-		 (car type))
-		((stringp type)
-		 type)
-		(t nil)))
-    (if (and type color)
-	(setq type (semantic-colorize-text type 'type)))
-    (setq prot (semantic-uml-protection-to-string prot))
-    (if type
-	(concat prot name ":" type)
-      name)
-    ))
-
-(defun semantic-uml-prototype-nonterminal (token &optional parent color)
-  "Return a UML style prototype for TOKEN.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let ((s (semantic-fetch-overload 'uml-prototype-nonterminal)))
-    (if s
-	(funcall s token parent color)
-      (semantic-uml-prototype-nonterminal-default token parent color))))
-
-(defun semantic-uml-prototype-nonterminal-default (token &optional parent color)
-  "Return a UML style abbreviation for TOKEN.
-Optional argument PARENT is the parent type if TOKEN is a detail.
-Optional argument COLOR means highlight the prototype with font-lock colors."
-  (let* ((tok (semantic-token-token token))
-	 (name (semantic-name-nonterminal token parent color))
-	 (type (or (semantic-token-type token) ""))
-	 (args (semantic-prototype-nonterminal-default-args
-		(cond ((eq tok 'function)
-		       (semantic-token-function-args token))
-		      (t nil))
-		color))
-	 (prot (semantic-nonterminal-protection token parent))
-	 )
-    (if type
-	(if (semantic-token-p type)
-	    (setq type (semantic-prototype-nonterminal type nil color))
-	  (if (listp type)
-	      (setq type (car type)))
-	  (if color
-	      (setq type (semantic-colorize-text type 'type)))))
-    (setq prot (semantic-uml-protection-to-string prot))
-    (if args
-	(setq args
-	      (concat " "
-		      (if (eq tok 'type) "{" "(")
-		      (mapconcat (lambda (a) a) args ",")
-		      (if (eq tok 'type) "}" ")"))))
-    (if type
-	(concat prot name (or args "") ":" type)
-      name)
-    ))
-
-
-
-;;; Multi-file Token information
-;;
-(defvar semantic-dependency-include-path nil
-  "Defines the include path used when searching for files.
-This should be a list of directories to search which is specific to
-the file being included.
-This variable can also be set to a single function.  If it is a
-function, it will be called with one arguments, the file to find as a
-string, and  it should return the full path to that file, or nil.")
-(make-variable-buffer-local `semantic-dependency-include-path)
-
-(defun semantic-find-dependency (&optional token)
-  "Find the filename represented from TOKEN.
-TOKEN may be a stripped element, in which case PARENT specifies a
-parent token that has positinal information.
-Depends on `semantic-dependency-include-path' for searching.  Always searches
-`.' first, then searches additional paths."
-  (if (not token)
-      (setq token (car (semantic-find-nonterminal-by-overlay nil))))
-
-  (if (not (eq (semantic-token-token token) 'include))
-      (signal 'wrong-type-argument (list token 'include)))
-
-  ;; First, see if this file exists in the current EDE projecy
-  (if (and (fboundp 'ede-expand-filename) ede-minor-mode
-	   (ede-expand-filename (ede-toplevel)
-				(semantic-token-name token)))
-      (ede-expand-filename (ede-toplevel)
-			   (semantic-token-name token))
-  
-    (let ((s (semantic-fetch-overload 'find-dependency)))
-      (if s (funcall s token)
-	(save-excursion
-	  (set-buffer (semantic-token-buffer token))
-	  (let ((name (semantic-token-name token)))
-	    (cond ((file-exists-p name)
-		   (expand-file-name name))
-		  ((and (symbolp semantic-dependency-include-path)
-			(fboundp semantic-dependency-include-path))
-		   (funcall semantic-dependency-include-path name))
-		  (t
-		   (let ((p semantic-dependency-include-path)
-			 (found nil))
-		     (while (and p (not found))
-		       (if (file-exists-p (concat (car p) "/" name))
-			   (setq found (concat (car p) "/" name)))
-		       (setq p (cdr p)))
-		     found)))))))))
-
-(defun semantic-find-nonterminal (&optional token parent)
-  "Find the location of TOKEN.
-TOKEN may be a stripped element, in which case PARENT specifies a
-parent token that has position information.
-Different behaviors are provided depending on the type of token.
-For example, dependencies (includes) will seek out the file that is
-depended on, and functions will move to the specified definition."
-  (if (not token)
-      (setq token (car (semantic-find-nonterminal-by-overlay nil))))
-  (if (and (eq (semantic-token-token token) 'include)
-	   (let ((f (semantic-find-dependency token)))
-	     (if f (find-file f))))
-      nil
-    (let ((s (semantic-fetch-overload 'find-nonterminal)))
-      (if s (funcall s token parent)
-	(if (semantic-token-buffer token)
-	    ;; If the token has no buffer, it may be deoverlayed.
-	    ;; Assume the tool doing the finding knows that we came
-	    ;; in from a database, and use the current buffer.
-	    (set-buffer (semantic-token-buffer token)))
-	(if (semantic-token-with-position-p token)
-	    ;; If it's a number, go there
-	    (goto-char (semantic-token-start token))
-	  ;; Otherwise, it's a trimmed vector, such as a parameter,
-	  ;; or a structure part.
-	  (if (not parent)
-	      nil
-	    (if (semantic-token-with-position-p parent)
-		(progn
-		  (if (semantic-token-buffer parent)
-		      ;; If this parent token has no buffer, then it
-		      ;; may be deoverlayed.
-		      (set-buffer (semantic-token-buffer parent)))
-		  (goto-char (semantic-token-start parent))
-		  ;; Here we make an assumtion that the text returned by
-		  ;; the bovinator and concocted by us actually exists
-		  ;; in the buffer.
-		  (re-search-forward (semantic-token-name token) nil t)))))))))
-
-(defun semantic-find-documentation (&optional token nosnarf)
-  "Find documentation from TOKEN and return it as a clean string.
-TOKEN might have DOCUMENTATION set in it already.  If not, there may be
-some documentation in a comment preceeding TOKEN's definition which we
-cal look for.  When appropriate, this can be overridden by a language specific
-enhancement.
-Optional argument NOSNARF means to only return the flex token for it.
-If nosnarf if 'flex, then only return the flex token."
-  (if (not token)
-      (setq token (car (semantic-find-nonterminal-by-overlay nil))))
-  (let ((s (semantic-fetch-overload 'find-documentation)))
-    (if s (funcall s token nosnarf)
-      ;; No override.  Try something simple to find documentation nearby
-      (save-excursion
-	(set-buffer (semantic-token-buffer token))
-	(semantic-find-nonterminal token)
-	(or
-	 ;; Is there doc in the token???
-	 (if (semantic-token-docstring token)
-	     (if (stringp (semantic-token-docstring token))
-		 (semantic-token-docstring token)
-	       (goto-char (semantic-token-docstring token))
-	       (semantic-find-doc-snarf-comment nosnarf)))
-	 ;; Check just before the definition.
-	 (save-excursion
-	   (re-search-backward comment-start-skip nil t)
-	   (if (not (semantic-find-nonterminal-by-position
-		     (point) (current-buffer) t))
-	       ;; We found a comment that doesn't belong to the body
-	       ;; of a function.
-	       (semantic-find-doc-snarf-comment nosnarf)))
-	 ;;  Lets look for comments either after the definition, but before code:
-	 ;; Not sure yet.  Fill in something clever later....
-	 nil
-	 )))))
-
-(defun semantic-find-doc-snarf-comment (nosnarf)
-  "Snarf up the comment at POINT for `semantic-find-documentation'.
-Attempt to strip out comment syntactic sugar.
-Argument NOSNARF means don't modify the found text.
-If NOSNARF is 'flex, then return the flex token."
-  (let ((semantic-ignore-comments nil))
-    (if (eq nosnarf 'flex)
-	(car (semantic-flex (point) (1+ (point))))
-      (let ((ct (semantic-flex-text
-		 (car (semantic-flex (point) (1+ (point)))))))
-	(if nosnarf
-	    nil
-	  ;; ok, try to clean the text up.
-	  ;; Comment start thingy
-	  (while (string-match (concat "^\\s-*" comment-start-skip) ct)
-	    (setq ct (concat (substring ct 0 (match-beginning 0))
-			     (substring ct (match-end 0)))))
-	  ;; Arbitrary punctuation at the beginning of each line.
-	  (while (string-match "^\\s-*\\s.+\\s-*" ct)
-	    (setq ct (concat (substring ct 0 (match-beginning 0))
-			     (substring ct (match-end 0)))))
-	  ;; End of a block comment.
-	  (if (and block-comment-end (string-match block-comment-end ct))
-	      (setq ct (concat (substring ct 0 (match-beginning 0))
-			       (substring ct (match-end 0)))))
-	  ;; In case it's a real string, STRIPIT.
-	  (while (string-match "\\s-*\\s\"+\\s-*" ct)
-	    (setq ct (concat (substring ct 0 (match-beginning 0))
-			     (substring ct (match-end 0))))))
-	;; Now return the text.
-	ct))))
-
-(defun semantic-prototype-file (buffer)
-  "Return a file in which prototypes belonging to BUFFER should be placed.
-Default behavior (if not overriden) looks for a token specifying the
-prototype file, or the existence of an EDE variable indicating which
-file prototypes belong in."
-  (let ((s (semantic-fetch-overload 'prototype-file)))
-    (if s
-	(funcall s buffer)
-      ;; Else, perform some default behaviors
-      (if (and (fboundp 'ede-header-file) ede-minor-mode)
-	  (save-excursion
-	    (set-buffer buffer)
-	    (ede-header-file))
-	;; No EDE options for a quick answer.  Search.
-	(save-excursion
-	  (set-buffer buffer)
-	  (if (re-search-forward "::Header:: \\([a-zA-Z0-9.]+\\)" nil t)
-	      (match-string 1)))))))
-
-
-;;;; Mode-specific Token information
-;;
-(defun semantic-nonterminal-children (token &optional positionalonly)
-  "Return the list of top level children belonging to TOKEN.
-Children are any sub-tokens which may contain overlays.
-The default behavior (if not overriden with `nonterminal-children'
-is to return type parts for a type, and arguments for a function.
-
-If optional argument POSITIONALONLY is non-nil, then only return valid
-children if they contain positions.  Some languages may choose to create
-lists of children without position/overlay information.
-
-If this function is overriden, use `semantic-nonterminal-children-default'
-to also include the default behavior, and merely extend your own.
-
-Note for language authors:
-  If a mode defines a language that has tokens in it with overlays that
-should not be considered children, you should still return them with
-this function."
-  (let* ((s (semantic-fetch-overload 'nonterminal-children))
-	 (chil (if s (funcall s token)
-		 (semantic-nonterminal-children-default token))))
-    (if (or (not positionalonly)
-	    (semantic-token-with-position-p (car chil)))
-	chil
-      nil)))
-
-(defun semantic-nonterminal-children-default (token)
-  "Return the children of TOKEN.
-For types, return the type parts.
-For functions return the argument list."
-  (cond ((eq (semantic-token-token token) 'type)
-	 (semantic-token-type-parts token))
-	((eq (semantic-token-token token) 'function)
-	 (semantic-token-function-args token))
-	(t nil)))
-
-(defun semantic-nonterminal-protection (token &optional parent)
-  "Return protection information about TOKEN with optional PARENT.
-This function returns on of the following symbols:
-   nil        - No special protection.  Language dependent.
-   'public    - Anyone can access this TOKEN.
-   'private   - Only methods in the local scope can access TOKEN.
-   'protected - Like private for outside scopes, like public for child
-                classes.
-Some languages may choose to provide additional return symbols specific
-to themselves.  Use of this function should allow for this.
-
-The default behavior (if not overriden with `nonterminal-children'
-is to return a symbol based on type modifiers."
-  (let* ((s (semantic-fetch-overload 'nonterminal-protection)))
-    (if s (funcall s token parent)
-      (semantic-nonterminal-protection-default token parent))))
-
-(defun semantic-nonterminal-protection-default (token &optional parent)
-  "Return the protection of TOKEN as a child of PARENT default action.
-See `semantic-nonterminal-protection'."
-  (let ((mods (semantic-token-modifiers token))
-	(prot nil))
-    (while (and (not prot) mods)
-      (if (stringp (car mods))
-	  (let ((s (car mods)))
-	    ;; A few silly defaults to get things started.
-	    (cond ((or (string= s "public")
-		       (string= s "extern")
-		       (string= s "export"))
-		   'public)
-		  ((or (string= s "private")
-		       (string= s "static"))
-		   'private)
-		  ((string= s "protected")
-		   'protected))))
-      (setq mods (cdr mods)))
-    prot))
-
-
-;;; Do some fancy stuff with overlays
-;;
-(defun semantic-highlight-token (token &optional face)
-  "Specify that TOKEN should be highlighted.
-Optional FACE specifies the face to use."
-  (let ((o (semantic-token-overlay token)))
-    (semantic-overlay-put o 'old-face
-			  (cons (semantic-overlay-get o 'face)
-				(semantic-overlay-get o 'old-face)))
-    (semantic-overlay-put o 'face (or face 'highlight))
-    ))
-
-(defun semantic-unhighlight-token (token)
-  "Unhighlight TOKEN, restoring it's previous face."
-  (let ((o (semantic-token-overlay token)))
-    (semantic-overlay-put o 'face (car (semantic-overlay-get o 'old-face)))
-    (semantic-overlay-put o 'old-face (cdr (semantic-overlay-get o 'old-face)))
-    ))
-
-(defun semantic-momentary-unhighlight-token (token)
-  "Unhighlight TOKEN, restoring it's previous face."
-  (semantic-unhighlight-token token)
-  (remove-hook 'pre-command-hook
-	       `(lambda () (semantic-momentary-unhighlight-token ',token))))
-
-(defun semantic-momentary-highlight-token (token &optional face)
-  "Highlight TOKEN, removing highlighting when the user hits a key.
-Optional argument FACE is the face to use for highlighting.
-If FACE is not specified, then `highlight' will be used."
-  (semantic-highlight-token token face)
-  (add-hook 'pre-command-hook
-	    `(lambda () (semantic-momentary-unhighlight-token ',token))))
-
-(defun semantic-set-token-face (token face)
-  "Specify that TOKEN should use FACE for display."
-  (semantic-overlay-put (semantic-token-overlay token) 'face face))
-
-(defun semantic-set-token-invisible (token &optional visible)
-  "Enable the text in TOKEN to be made invisible.
-If VISIBLE is non-nil, make the text visible."
-  (semantic-overlay-put (semantic-token-overlay token) 'invisible
-			(not visible)))
-
-(defun semantic-token-invisible-p (token)
-  "Return non-nil if TOKEN is invisible."
-  (semantic-overlay-get (semantic-token-overlay token) 'invisible))
-
-(defun semantic-set-token-intangible (token &optional tangible)
-  "Enable the text in TOKEN to be made intangible.
-If TANGIBLE is non-nil, make the text visible.
-This function does not have meaning in XEmacs because it seems that
-the extent 'intangible' property does not exist."
-  (semantic-overlay-put (semantic-token-overlay token) 'intangible
-			(not tangible)))
-
-(defun semantic-token-intangible-p (token)
-  "Return non-nil if TOKEN is intangible.
-This function does not have meaning in XEmacs because it seems that
-the extent 'intangible' property does not exist."
-  (semantic-overlay-get (semantic-token-overlay token) 'intangible))
-
-(defun semantic-overlay-signal-read-only
-  (overlay after start end &optional len)
-  "Hook used in modification hooks to prevent modification.
-Allows deletion of the entire text.
-Argument OVERLAY, AFTER, START, END, and LEN are passed in by the system."
-  ;; Stolen blithly from cpp.el in Emacs 21.1
-  (if (and (not after)
-	   (or (< (semantic-overlay-start overlay) start)
-	       (> (semantic-overlay-end overlay) end)))
-      (error "This text is read only")))
-
-(defun semantic-set-token-read-only (token &optional writable)
-  "Enable the text in TOKEN to be made read-only.
-Optional argument WRITABLE should be non-nil to make the text writable.
-instead of read-only."
-  (let ((o (semantic-token-overlay token))
-	(hook (if writable nil '(semantic-overlay-signal-read-only))))
-    (if (featurep 'xemacs)
-        ;; XEmacs extents have a 'read-only' property.
-        (semantic-overlay-put o 'read-only (not writable))
-      (semantic-overlay-put o 'modification-hooks hook)
-      (semantic-overlay-put o 'insert-in-front-hooks hook)
-      (semantic-overlay-put o 'insert-behind-hooks hook))))
-
-(defun semantic-token-read-only-p (token)
-  "Return non-nil if the current TOKEN is marked read only."
-  (let ((o (semantic-token-overlay token)))
-    (if (featurep 'xemacs)
-        ;; XEmacs extents have a 'read-only' property.
-        (semantic-overlay-get o 'read-only)
-      (member 'semantic-overlay-signal-read-only
-              (semantic-overlay-get o 'modification-hooks)))))
-
-(defun semantic-narrow-to-token (token)
-  "Narrow to the region specified by TOKEN."
-  (narrow-to-region (semantic-token-start token)
-		    (semantic-token-end token)))
-
-;;; Interactive Functions for bovination
-;;
-(defun semantic-describe-token (&optional token)
-  "Describe TOKEN in the minibuffer.
-If TOKEN is nil, describe the token under the cursor."
-  (interactive)
-  (if (not token) (setq token (semantic-current-nonterminal)))
-  (semantic-bovinate-toplevel t)
-  (if token (message (semantic-summarize-nonterminal token))))
-
-
-;;; Putting keys on tokens.
-;;
-(defun semantic-add-label (label value &optional token)
-  "Add a LABEL with VALUE on TOKEN.
-If TOKEN is not specified, use the token at point."
-  (interactive "sLabel: \nXValue (eval): ")
-  (if (not token)
-      (progn
-	(semantic-bovinate-toplevel t)
-	(setq token (semantic-current-nonterminal))))
-  (semantic-token-put token (intern label) value)
-  (message "Added label %s with value %S" label value))
-
-(defun semantic-show-label (label &optional token)
-  "Show the value of LABEL on TOKEN.
-If TOKEN is not specified, use the token at point."
-  (interactive "sLabel: ")
-  (if (not token)
-      (progn
-	(semantic-bovinate-toplevel t)
-	(setq token (semantic-current-nonterminal))))
-  (message "%s: %S" label (semantic-token-get token (intern label))))
-
-
-;;; Show dirty mode
-;;
-;;;###autoload
-(defcustom semantic-show-dirty-mode nil
-  "*If non-nil enable the use of `semantic-show-dirty-mode'."
-  :group 'semantic
-  :type 'boolean
-  :require 'semantic-util
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (semantic-show-dirty-mode (if val 1 -1))
-         (custom-set-default sym val)))
-
-(defface semantic-dirty-token-face  '((((class color) (background dark))
-				       (:background "gray10"))
-				      (((class color) (background light))
-				       (:background "gray90")))
-  "Face used to show dirty tokens in `semantic-show-dirty-token-mode'."
-  :group 'semantic)
-
-(defun semantic-show-dirty-token-hook-fcn (token start end)
-  "Function set into `semantic-dirty-token-hooks'.
-This will highlight TOKEN as dirty.
-START and END define the region changed, but are not used."
-  (semantic-highlight-token token 'semantic-dirty-token-face))
-
-(defun semantic-show-clean-token-hook-fcn (token)
-  "Function set into `semantic-clean-token-hooks'.
-This will unhighlight TOKEN from being dirty."
-  (semantic-unhighlight-token token))
-
-(defun semantic-show-dirty-mode (&optional arg)
-  "Enable the display of dirty tokens.
-If ARG is positive, enable, if it is negative, disable.
-If ARG is nil, then toggle."
-    (interactive "P")
-  (if (not arg)
-      (if (member #'semantic-show-dirty-token-hook-fcn
-		  semantic-dirty-token-hooks)
-	  (setq arg -1)
-	(setq arg 1)))
-  (if (< arg 0)
-      (progn
-	;; Remove hooks
-	(remove-hook 'semantic-dirty-token-hooks 'semantic-show-dirty-token-hook-fcn)
-	(remove-hook 'semantic-clean-token-hooks 'semantic-show-clean-token-hook-fcn)
-	(remove-hook 'after-save-hook 'semantic-rebovinate-quickly-hook)
-	)
-    (add-hook 'semantic-dirty-token-hooks 'semantic-show-dirty-token-hook-fcn)
-    (add-hook 'semantic-clean-token-hooks 'semantic-show-clean-token-hook-fcn)
-    (add-hook 'after-save-hook 'semantic-rebovinate-quickly-hook)
-    ))
-
-;;; Hacks
-;;
-;; Some hacks to help me test these functions
-(defun semantic-current-token (p)
-  "Display the curent token.
-Argument P is the point to search from in the current buffer."
-  (interactive "d")
-  (let ((tok (semantic-find-innermost-nonterminal-by-position
-	      p (current-buffer))))
-    (message (mapconcat 'semantic-abbreviate-nonterminal tok ","))
-    (car tok))
-  )
-
-(defun semantic-hack-search ()
-  "Disply info about something under the cursor using generic methods."
-  (interactive)
-  (let (
-	;(name (thing-at-point 'symbol))
-	(strm (cdr (semantic-bovinate-toplevel)))
-	(res nil))
-;    (if name
-	(setq res
-;	      (semantic-find-nonterminal-by-name name strm)
-;	      (semantic-find-nonterminal-by-type name strm)
-;	      (semantic-recursive-find-nonterminal-by-name name (current-buffer))
-	      (semantic-find-nonterminal-by-position (point) strm)
-	      
-	      )
-;	)
-    (if res
-	(progn
-	  (pop-to-buffer "*SEMANTIC HACK RESULTS*")
-	  (require 'pp)
-	  (erase-buffer)
-	  (insert (pp-to-string res) "\n")
-	  (goto-char (point-min))
-	  (shrink-window-if-larger-than-buffer))
-      (message "nil"))))
-
-(provide 'semantic-util)
-
-;;; semantic-util.el ends here

semantic.el.upstream

-;;; semantic.el --- Semantic buffer evaluator.
-
-;;; Copyright (C) 1999, 2000, 2001 Eric M. Ludlam
-
-;; Author: Eric M. Ludlam <zappo@gnu.org>
-;; Keywords: syntax
-;; X-RCS: $Id$
-
-(defvar semantic-version "1.4beta8"
-  "Current version of Semantic.")
-
-;; This file is not part of GNU Emacs.
-
-;; Semantic is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; This software is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
-
-;;; Commentary:
-;;
-;; API for determining semantic content of a buffer.  The mode using
-;; semantic must be a deterministic programming language.
-;;
-;; The output of a semantic bovine parse is parse tree.  While it is
-;; possible to assign actions in the bovine-table in a similar fashion
-;; to bison, this is not it's end goal.
-
-;;; History:
-;; 
-
-(require 'working)
-
-(defgroup semantic nil
-  "Parser Generator/Parser."
-  )
-
-;;; Code:
-
-;;; Compatibility
-;;
-(if (featurep 'xemacs)
-    (progn
-      (defalias 'semantic-overlay-live-p 'extent-live-p)
-      (defalias 'semantic-make-overlay 'make-extent)
-      (defalias 'semantic-overlay-put 'set-extent-property)
-      (defalias 'semantic-overlay-get 'extent-property)
-      (defalias 'semantic-overlay-delete 'delete-extent)
-      (defalias 'semantic-overlays-at
-        (lambda (pos) (extent-list nil pos pos)))
-      (defalias 'semantic-overlays-in 
-	(lambda (beg end) (extent-list nil beg end)))
-      (defalias 'semantic-overlay-buffer 'extent-buffer)
-      (defalias 'semantic-overlay-start 'extent-start-position)
-      (defalias 'semantic-overlay-end 'extent-end-position)
-      (defalias 'semantic-overlay-next-change 'next-extent-change)
-      (defalias 'semantic-overlay-previous-change 'previous-extent-change)
-      (defalias 'semantic-overlay-lists
-	(lambda () (list (extent-list))))
-      (defalias 'semantic-overlay-p 'extentp)
-      (defun semantic-read-event ()
-        (let ((event (next-command-event)))
-          (if (key-press-event-p event)
-              (let ((c (event-to-character event)))
-                (if (char-equal c (quit-char))
-                    (keyboard-quit)
-                  c)))
-          event))
-      )
-  (defalias 'semantic-overlay-live-p 'overlay-buffer)
-  (defalias 'semantic-make-overlay 'make-overlay)
-  (defalias 'semantic-overlay-put 'overlay-put)
-  (defalias 'semantic-overlay-get 'overlay-get)
-  (defalias 'semantic-overlay-delete 'delete-overlay)
-  (defalias 'semantic-overlays-at 'overlays-at)
-  (defalias 'semantic-overlays-in 'overlays-in)
-  (defalias 'semantic-overlay-buffer 'overlay-buffer)
-  (defalias 'semantic-overlay-start 'overlay-start)
-  (defalias 'semantic-overlay-end 'overlay-end)
-  (defalias 'semantic-overlay-next-change 'next-overlay-change)
-  (defalias 'semantic-overlay-previous-change 'previous-overlay-change)
-  (defalias 'semantic-overlay-lists 'overlay-lists)
-  (defalias 'semantic-overlay-p 'overlayp)
-  (defalias 'semantic-read-event 'read-event)
-  )
-
-(defvar semantic-edebug nil
-  "When non-nil, activate the interactive parsing debugger.
-Do not set this yourself.  Call `semantic-bovinate-buffer-debug'.")
-
-
-(defcustom semantic-dump-parse nil
-  "When non-nil, dump parsing information."
-  :group 'semantic
-  :type 'boolean)
-
-(defvar semantic-toplevel-bovine-table nil
-  "Variable that defines how to bovinate top level items in a buffer.
-Set this in your major mode to return function and variable semantic
-types.
-
-The format of a BOVINE-TABLE is:
-
- ( ( NONTERMINAL-SYMBOL1 MATCH-LIST1 )
-   ( NONTERMINAL-SYMBOL2 MATCH-LIST2 )
-   ...
-   ( NONTERMINAL-SYMBOLn MATCH-LISTn )
- 
-Where each NONTERMINAL-SYMBOL is an artificial symbol which can appear
-in any child state.  As a starting place, one of the NONTERMINAL-SYMBOLS
-must be `bovine-toplevel'.
-
-A MATCH-LIST is a list of possible matches of the form:
-
- ( STATE-LIST1
-   STATE-LIST2
-   ...
-   STATE-LISTN )
-
-where STATE-LIST is of the form:
-  ( TYPE1 [ \"VALUE1\" ] TYPE2 [ \"VALUE2\" ] ... LAMBDA )
-
-where TYPE is one of the returned types of the token stream.
-VALUE is a value, or range of values to match against.  For
-example, a SYMBOL might need to match \"foo\".  Some TYPES will not
-have matching criteria.
-
-LAMBDA is a lambda expression which is evaled with the text of the
-type when it is found.  It is passed the list of all buffer text
-elements found since the last lambda expression.  It should return a
-semantic element (see below.)
-
-For consistency between languages, always use the following symbol
-forms.  It is fine to create new symbols, or to exclude some if they
-do not exist, however by using these symbols, you can maximize the
-number of language-independent programs available for use with your
-language.
-
-GENERIC ENTRIES:
-
- Bovine table entry return elements are up to the table author.  It is
-recommended, however, that the following format be used.
-
- (\"NAME\" type-symbol [\"TYPE\"] ... \"DOCSTRING\" PROPERTIES OVERLAY)
-
-Where type-symbol is the type of return token found, and NAME is it's
-name.  If there is any typing information needed to describe this
-entry, make that come third.  Next, any additional information follows
-the optional type.  The last data entry can be the position in the buffer
-of DOCSTRING.  A docstring does not have to exist in the form used by
-Emacs Lisp.  It could be the text of a comment appearing just before a
-function call, or in line with a variable.
-
-PROPERTIES is a list of additional properties for this token.
-PRORPERTIES is not for details of the token.  It is used for
-additional tags needed by tools using the parse stream.  For example,
-the `dirty' property is used when a given token needs to be reparsed.
-
-PROPERTIES are automatically added to the token by the system when
-using BNF, or `semantic-lambda' in the table.
-
-The last element must be OVERLAY.  The OVERLAY is automatically
-created by the parsing system.  When programming with BNF, or using
-`semantic-lambda', no extra work needs to be done.  If you are
-building the parse table yourself, use START and END.
-
-It may seem odd to place NAME in slot 0, and the type-symbol in slot
-1, but this turns the returned elements into a list which can be used
-by alist based function.  This makes it ideal for passing into generic
-sorters, string completion functions, and list searching functions.
-
-In the below entry formats, \"NAME\" is a string which is the name of
-the object in question.  It is possible for this to be nil in some
-situations, and code dealing with entries should try to be aware of
-these situations.
-
-\"TYPE\" is a string representing the type of some objects.  For a
-variable, this could very well be another top level token representing
-a type nonterminal.
-
-TOP-LEVEL ENTRIES:
-
- (\"NAME\" variable \"TYPE\" DEFAULT-VALUE EXTRA-SPEC 
-         \"DOCSTRING\" PROPERTIES OVERLAY)
-   The definition of a variable, or constant.
-   DEFAULT-VALUE can be something apropriate such a a string,
-                 or list of parsed elements.
-   EXTRA-SPEC are details about a variable that are not covered in the TYPE.
-             See detail on EXTRA-SPEC after entries section.
-   DOCSTRING is optional.
-
- (\"NAME\" function \"TYPE\" ( ARG-LIST ) EXTRA-SPEC
-          \"DOCSTRING\" PROPERTIES OVERLAY)
-   A function/procedure definition.
-   ARG-LIST is a list of variable definitions.
-   DOCSTRING is optional.
-
- (\"NAME\" type \"TYPE\" ( PART-LIST ) ( PARENTS ) EXTRA-SPEC
-          \"DOCSTRING\" PROPERTIES OVERLAY)
-   A type definition.
-   TYPE of a type could be anything, such as (in C) struct, union, typedef,
-        or class.
-   PART-LIST is only useful for structs that have multiple individual parts.
-            (It is recommended that these be variables, functions or types).
-   PARENTS is strictly for classes where there is inheritance.
-           See `semantic-token-parent' for a description of this value.   
-
- (\"FILE\" include SYSTEM \"DOCSTRING\" PROPERTIES OVERLAY)
-   In C, an #include statement.  In elisp, a require statement.
-   Indicates additional locations of sources or definitions.
-   SYSTEM is true if this include is part of a set of system includes.
-
- (\"NAME\" package DETAIL \"DOCSTRING\" PROPERTIES OVERLAY)
-   In Emacs Lisp, a `provide' statement.  DETAIL might be an
-   associated file name.  In Java, this is a package statement.
-
-EXTRA-SPEC:
-
-  The EXTRA-SPEC section of variables, functions, and types provide a
-location to place language specific details which are not accounted
-for by the base token type.  Because there is an arbitrary number of