* cedet/ede/cpp-root.el (initialize-instance):
* cedet/ede/autoconf-edit.el (autoconf-find-last-macro)
(autoconf-parameter-strip, autoconf-insert-new-macro):
+ * cedet/semantic/wisent.el (wisent-lex-eoi):
+ * cedet/semantic/util-modes.el (global-semantic-show-parser-state-mode)
+ (semantic-show-parser-state-mode):
+ * cedet/semantic/texi.el (semantic-texi-environment-regexp):
+ * cedet/semantic/tag.el (semantic-tag-new-variable)
+ (semantic-tag-class, semantic-tag-new-variable, semantic-tag-copy)
+ (semantic--tag-deep-copy-attributes, semantic--tag-deep-copy-value)
+ (semantic--tag-deep-copy-tag-list)
+ (semantic-tag-components-with-overlays-default):
+ * cedet/semantic/symref.el (semantic-symref-find-text):
+ * cedet/semantic/senator.el (senator-yank-tag)
+ (senator-transpose-tags-up):
+ * cedet/semantic/scope.el (semantic-analyze-scoped-tags-default)
+ (semantic-analyze-scoped-inherited-tags, semantic-scope-find):
+ * cedet/semantic/sb.el (semantic-sb-autoexpand-length):
+ * cedet/semantic/lex.el (semantic-lex-comment-regex)
+ (semantic-lex-maximum-depth, define-lex, semantic-lex-token)
+ (semantic-lex-unterminated-syntax-protection, define-lex-analyzer):
+ * cedet/semantic/lex-spp.el
+ (semantic-lex-spp-dynamic-macro-symbol-obarray-stack)
+ (semantic-lex-spp-symbol, semantic-lex-spp-one-token-to-txt):
+ * cedet/semantic/idle.el
+ (semantic-idle-summary-current-symbol-info-brutish)
+ (semantic-idle-summary-current-symbol-info-default):
+ * cedet/semantic/grammar.el (semantic-grammar-recreate-package)
+ (semantic--grammar-macro-compl-dict):
+ * cedet/semantic/grammar-wy.el (semantic-grammar-wy--parse-table):
+ * cedet/semantic/format.el (semantic-format-tag-custom-list)
+ (semantic-format-tag-canonical-name-default):
+ * cedet/semantic/find.el (semantic-find-tag-by-overlay-in-region)
+ (semantic-find-tags-for-completion)
+ (semantic-find-tags-by-scope-protection-default)
+ (semantic-deep-find-tags-for-completion):
+ * cedet/semantic/edit.el
+ (semantic-edits-incremental-reparse-failed-hook)
+ (semantic-edits-verbose-flag, semantic-edits-assert-valid-region)
+ (semantic-edits-splice-remove, semantic-edits-splice-replace):
+ * cedet/semantic/doc.el (semantic-documentation-comment-preceeding-tag):
+ * cedet/semantic/dep.el (semantic-dependency-include-path):
+ * cedet/semantic/db.el (semanticdb-default-find-index-class)
+ (semanticdb-match-any-mode, semanticdb-with-match-any-mode)
+ (semanticdb-project-roots):
+ * cedet/semantic/db-find.el (semanticdb-implied-include-tags)
+ (semanticdb-find-adebug-insert-scanned-tag-cons)
+ (semanticdb-find-log-buffer-name, semanticdb-find-result-mapc)
+ (semanticdb-brute-deep-find-tags-for-completion):
+ * cedet/semantic/db-ebrowse.el (semanticdb-ebrowse-add-tree-to-table):
+ * cedet/semantic/ctxt.el (semantic-beginning-of-context-default)
+ (semantic-end-of-context-default)
+ (semantic-ctxt-current-function-default)
+ (semantic-ctxt-scoped-types-default):
+ * cedet/semantic/complete.el (semantic-complete-read-tag-engine)
+ (semantic-complete-inline-tag-engine)
+ (semantic-complete-inline-custom-type)
+ (semantic-complete-read-tag-analyzer):
+ * cedet/semantic/chart.el (semantic-chart-tags-by-class)
+ (semantic-chart-database-size):
+ * cedet/semantic/analyze.el (semantic-analyze-current-symbol)
+ (semantic-analyze-current-context):
+ * cedet/semantic/symref/list.el (semantic-symref)
+ (semantic-symref-hide-buffer, semantic-symref-symbol):
+ * cedet/semantic/symref/grep.el (semantic-symref-grep-use-template):
+ * cedet/semantic/symref/filter.el (semantic-symref-hits-in-region):
+ * cedet/semantic/bovine/el.el (semantic-elisp-form-to-doc-string):
+ * cedet/semantic/bovine/c.el (semantic-lex-c-preprocessor-symbol-map)
+ (semantic-c-parse-token-hack-depth, semantic-c--template-name-1)
+ (semantic-c-dereference-template):
+ * cedet/semantic/analyze/refs.el (semantic--analyze-refs-full-lookup)
+ (semantic--analyze-refs-full-lookup-with-parents)
+ (semantic--analyze-refs-full-lookup-simple):
+ * cedet/semantic/analyze/complete.el
+ (semantic-analyze-possible-completions):
* cedet/srecode/table.el (srecode-mode-table-new):
* cedet/srecode/srt.el (srecode-read-variable-name):
* cedet/srecode/srt-mode.el (srecode-macro-help, srecode-in-macro-p):
;;; semantic/analyze.el --- Analyze semantic tags against local context
-;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
to provide a large number of non-cached analysis for filtering symbols."
;; Only do this in a Semantic enabled buffer.
(when (not (semantic-active-p))
- (error "Cannot analyze buffers not supported by Semantic."))
+ (error "Cannot analyze buffers not supported by Semantic"))
;; Always refresh out tags in a safe way before doing the
;; context.
(semantic-refresh-tags-safe)
(interactive "d")
;; Only do this in a Semantic enabled buffer.
(when (not (semantic-active-p))
- (error "Cannot analyze buffers not supported by Semantic."))
+ (error "Cannot analyze buffers not supported by Semantic"))
;; Always refresh out tags in a safe way before doing the
;; context.
(semantic-refresh-tags-safe)
;;; semantic/analyze/complete.el --- Smart Completions
-;;; Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;;; Commentary:
;;
-;; Caclulate smart completions.
+;; Calculate smart completions.
;;
;; Uses the analyzer context routine to determine the best possible
;; list of completions.
context
(semantic-analyze-current-context context)))
(ans (if (not context)
- (error "Nothing to Complete.")
+ (error "Nothing to complete")
(:override))))
;; If interactive, display them.
(when (interactive-p)
;;; LOOKUP
;;
(defun semantic--analyze-refs-full-lookup (tag scope)
- "Perform a full lookup for all occurances of TAG in the current project.
+ "Perform a full lookup for all occurrences of TAG in the current project.
TAG should be the tag currently under point.
PARENT is the list of tags that are parents to TAG by
containment, as opposed to reference."
ans))
(defun semantic--analyze-refs-full-lookup-with-parents (tag scope)
- "Perform a lookup for all occurances of TAG based on TAG's SCOPE.
+ "Perform a lookup for all occurrences of TAG based on TAG's SCOPE.
TAG should be the tag currently under point."
(let* ((classmatch (semantic-tag-class tag))
(plist (mapcar (lambda (T) (semantic-tag-name T)) (oref scope parents)))
answer))
(defun semantic--analyze-refs-full-lookup-simple (tag &optional noerror)
- "Perform a simple lookup for occurances of TAG in the current project.
+ "Perform a simple lookup for occurrences of TAG in the current project.
TAG should be the tag currently under point.
Optional NOERROR means don't throw errors on failure to find something.
This only compares the tag name, and does not infer any matches in namespaces,
;;; semantic/bovine/c.el --- Semantic details for C
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-;;; 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+;; 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
second position is the text that makes up the replacement. This is
the way to have multiple lexical symbols in a replacement. Using the
first way to specify text like \"foo::bar\" would not work, because :
-is a sepearate lexical symbol.
+is a separate lexical symbol.
A quick way to see what you would need to insert is to place a
definition such as:
))
(defvar semantic-c-parse-token-hack-depth 0
- "Current depth of recursive calls to `semantic-c-parse-lexical-token'")
+ "Current depth of recursive calls to `semantic-c-parse-lexical-token'.")
(defun semantic-c-parse-lexical-token (lexicaltoken nonterminal depth
returnonerror)
(semantic-c--instantiate-template tag (cdr def-list) (cdr spec-list))))
(defun semantic-c--template-name-1 (spec-list)
- "return a string used to compute template class name based on SPEC-LIST
-for ref<Foo,Bar> it will return 'Foo,Bar'."
+ "Return a string used to compute template class name.
+Based on SPEC-LIST, for ref<Foo,Bar> it will return 'Foo,Bar'."
(when (car spec-list)
(let* ((endpart (semantic-c--template-name-1 (cdr spec-list)))
(separator (and endpart ",")))
"<" (semantic-c--template-name-1 (cdr spec-list)) ">"))
(defun semantic-c-dereference-template (type scope &optional type-declaration)
- "Dereference any template specifieres in TYPE within SCOPE.
+ "Dereference any template specifiers in TYPE within SCOPE.
If TYPE is a template, return a TYPE copy with the templates types
instantiated as specified in TYPE-DECLARATION."
(when (semantic-tag-p type-declaration)
;;; semantic/bovine/el.el --- Semantic details for Emacs Lisp
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
-;;; 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
+;; 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
(defun semantic-elisp-form-to-doc-string (form)
"After reading a form FORM, covert it to a doc string.
-For Emacs Lisp, sometimes that string is non-existant.
+For Emacs Lisp, sometimes that string is non-existent.
Sometimes it is a form which is evaluated at compile time, permitting
compound strings."
(cond ((stringp form) form)
;;; semantic/chart.el --- Utilities for use with semantic tag tables
-;;; Copyright (C) 1999, 2000, 2001, 2003, 2005, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2003, 2005, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
Each bar represents how many toplevel tags in TAGTABLE
exist with a given class. See `semantic-symbol->name-assoc-list'
for tokens which will be charted.
-TAGTABLE is passedto `semantic-something-to-tag-table'."
+TAGTABLE is passed to `semantic-something-to-tag-table'."
(interactive)
(let* ((stream (semantic-something-to-tag-table
(or tagtable (current-buffer))))
"Create a bar chart representing the complexity of some tags.
Complexity is calculated for tags of CLASS. Each bar represents
the complexity of some tag in TAGTABLE. Only the most complex
-items are charted. TAGTABLE is passedto
+items are charted. TAGTABLE is passed to
`semantic-something-to-tag-table'."
(interactive)
(let* ((sym (if (not class) 'function))
;;; semantic/complete.el --- Routines for performing tag completion
-;;; Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
;; quickly without resorting to "show me every possible option now".
;;
;; In addition, some symbol names will appear in multiple locations.
-;; If it is important to distiguish, then a way to provide a choice
+;; If it is important to distinguish, then a way to provide a choice
;; over these locations is important as well.
;;
;; Beyond brute force offers for completion of plain strings,
;;
;; Here, we will treat each section separately (excluding D)
;; They can then be strung together in user-visible commands to
-;; fullfill specific needs.
+;; fulfil specific needs.
;;
;; COLLECTORS:
;;
Argument COLLECTOR is an object which can be used to to calculate
a list of possible hits. See `semantic-completion-collector-engine'
for details on COLLECTOR.
-Argumeng DISPLAYOR is an object used to display a list of possible
+Argument DISPLAYOR is an object used to display a list of possible
completions for a given prefix. See`semantic-completion-display-engine'
for details on DISPLAYOR.
PROMPT is a string to prompt with.
Argument COLLECTOR is an object which can be used to to calculate
a list of possible hits. See `semantic-completion-collector-engine'
for details on COLLECTOR.
-Argumeng DISPLAYOR is an object used to display a list of possible
+Argument DISPLAYOR is an object used to display a list of possible
completions for a given prefix. See`semantic-completion-display-engine'
for details on DISPLAYOR.
BUFFER is the buffer in which completion will take place.
C)))
(eieio-build-class-alist semantic-displayor-abstract t))
)
- "Possible options for inlince completion displayors.
+ "Possible options for inline completion displayors.
Use this to enable custom editing.")
(defcustom semantic-complete-inline-analyzer-displayor-class
PROMPT is the first part of the prompt. Additional prompt
is added based on the contexts full prefix.
CONTEXT is the semantic analyzer context to start with.
-HISTORY is a symbol representing a variable to stor the history in.
+HISTORY is a symbol representing a variable to store the history in.
usually a default-tag and initial-input are available for completion
prompts. these are calculated from the CONTEXT variable passed in."
(if (not context) (setq context (semantic-analyze-current-context (point))))
;;; semantic/ctxt.el --- Context calculations for Semantic tools.
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-;;; 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+;; 2007, 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
The default behavior uses `semantic-up-context'.")
(defun semantic-beginning-of-context-default (&optional point)
- "Move POINT to the beginning of the current context via parenthisis.
+ "Move POINT to the beginning of the current context via parenthesis.
Return non-nil if there is no upper context."
(if point (goto-char point))
(if (semantic-up-context)
block delimiters.")
(defun semantic-end-of-context-default (&optional point)
- "Move POINT to the end of the current context via parenthisis.
+ "Move POINT to the end of the current context via parenthesis.
Return non-nil if there is no upper context."
(if point (goto-char point))
(let ((start (point)))
(defun semantic-ctxt-current-function-default (&optional point)
"Return the current function call the cursor is in at POINT.
-The call will be identifed for C like langauges with the form
+The call will be identified for C like languages with the form
NAME ( args ... )"
(if point (goto-char point))
(let ((case-fold-search semantic-case-fold))
(defun semantic-ctxt-scoped-types-default (&optional point)
"Return a list of scoped types by name for the current context at POINT.
This is very different for various languages, and does nothing unless
-overriden."
+overridden."
(if point (goto-char point))
(let ((case-fold-search semantic-case-fold))
;; We need to look at TYPES within the bounds of locally parse arguments.
;;; semantic/db-ebrowse.el --- Semanticdb backend using ebrowse.
-;;; Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2005, 2006, 2007, 2008, 2009
+;; Free Software Foundation, Inc.
;; Authors: Eric M. Ludlam <zappo@gnu.org>
;; Joakim Verona
(defun semanticdb-ebrowse-add-tree-to-table (dbe tree &optional fname baseclasses)
"For database DBE, add the ebrowse TREE into the table for FNAME.
-Optional argument BASECLASSES specifyies a baseclass to the tree being provided."
+Optional argument BASECLASSES specifies a baseclass to the tree being provided."
(if (not (ebrowse-ts-p tree))
(signal 'wrong-type-argument (list 'ebrowse-ts-p tree)))
;;; semantic/db-find.el --- Searching through semantic databases.
-;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
-;;; 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+;; 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: tags
;; eldoc - popup help
;; => Requires basic search using default path. (Header files ok)
;; tag jump - jump to a named tag
-;; => Requires a brute search useing whole project. (Source files only)
+;; => Requires a brute search using whole project. (Source files only)
;; completion - Completing symbol names in a smart way
;; => Basic search (headers ok)
;; type analysis - finding type definitions for variables & fcns
Set this variable with `defvar-mode-local' for a particular mode so
that any symbols that exist for all files for that mode are included.
-Note: This could be used as a way to write a file in a langauge
+Note: This could be used as a way to write a file in a language
to declare all the built-ins for that language.")
(defun semanticdb-find-translate-path-includes--internal (path)
(defun semanticdb-find-adebug-insert-scanned-tag-cons (consdata prefix prebuttontext)
"Insert a button representing scanned include CONSDATA.
-PREFIX is the text that preceeds the button.
+PREFIX is the text that precedes the button.
PREBUTTONTEXT is some text between prefix and the overlay button."
(let* ((start (point))
(end nil)
(defun semanticdb-find-result-mapc (fcn result)
"Apply FCN to each element of find RESULT for side-effects only.
FCN takes two arguments. The first is a TAG, and the
-second is a DB from wence TAG originated.
+second is a DB from whence TAG originated.
Returns result."
(mapc (lambda (sublst)
(mapc (lambda (tag)
"The name of the logging buffer.")
(defun semanticdb-find-toggle-logging ()
- "Toggle sematnicdb logging."
+ "Toggle semanticdb logging."
(interactive)
(setq semanticdb-find-log-flag (null semanticdb-find-log-flag))
(message "Semanticdb find logging is %sabled"
See `semanticdb-find-translate-path' for details on PATH.
The argument BRUTISH will be set so that searching includes all tables
in the current project.
-FIND-FILE-MATCH indicates that any time a matchi is found, the file
+FIND-FILE-MATCH indicates that any time a match is found, the file
associated wit that tag should be loaded into a buffer."
(semanticdb-find-tags-collector
(lambda (table tags)
See `semanticdb-find-translate-path' for details on PATH.
The argument BRUTISH will be set so that searching includes all tables
in the current project.
-FIND-FILE-MATCH indicates that any time a matchi is found, the file
+FIND-FILE-MATCH indicates that any time a match is found, the file
associated wit that tag should be loaded into a buffer."
(semanticdb-find-tags-collector
(lambda (table tags)
;;; semantic/db.el --- Semantic tag database manager
-;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
-;;; 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+;; 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: tags
(defvar semanticdb-default-find-index-class 'semanticdb-find-search-index
"The default type of search index to use for a `semanticdb-table's.
-This can be changed to try out new types of search indicies.")
+This can be changed to try out new types of search indices.")
(make-variable-buffer-local 'semanticdb-default-find=index-class)
;;;###autoload
nil))
(defvar semanticdb-match-any-mode nil
- "Non-nil to temporarilly search any major mode for a tag.
+ "Non-nil to temporarily search any major mode for a tag.
If a particular major mode wants to search any mode, put the
`semantic-match-any-mode' symbol onto the symbol of that major mode.
Do not set the value of this variable permanently.")
(defmacro semanticdb-with-match-any-mode (&rest body)
- "A Semanticdb search occuring withing BODY will search tags in all modes.
-This temporarilly sets `semanticdb-match-any-mode' while executing BODY."
+ "A Semanticdb search occurring withing BODY will search tags in all modes.
+This temporarily sets `semanticdb-match-any-mode' while executing BODY."
`(let ((semanticdb-match-any-mode t))
,@body))
(put 'semanticdb-with-match-any-mode 'lisp-indent-function 0)
(defcustom semanticdb-project-roots nil
"*List of directories, where each directory is the root of some project.
All subdirectories of a root project are considered a part of one project.
-Values in this string can be overriden by project management programs
+Values in this string can be overridden by project management programs
via the `semanticdb-project-root-functions' variable."
:group 'semanticdb
:type '(repeat string))
;;; semantic/dep.el --- Methods for tracking dependencies (include files)
-;;; Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
;; EDE or even ECB can control our project dependencies, and help us
;; find file within the setting of a given project. For system
;; dependencies, we need to depend on user supplied lists, which can
-;; manifest themselves in the form of system datatabases (from
+;; manifest themselves in the form of system databases (from
;; semanticdb.)
;;
;; Provide ways to track these different files here.
If `semantic-dependency-tag-file' is overridden for a given
language, this path is most likely ignored.
-The above function, reguardless of being overriden, caches the
+The above function, regardless of being overridden, caches the
located dependency file location in the tag property
`dependency-file'. If you override this function, you do not
need to implement your own cache. Each time the buffer is fully
;;; semantic/doc.el --- Routines for documentation strings
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
;;; Commentary:
;;
-;; It is good practice to write documenation for your functions and
+;; It is good practice to write documentation for your functions and
;; variables. These core routines deal with these documentation
;; comments or strings. They can exist either as a tag property
;; (:documentation) or as a comment just before the symbol, or after
;; Not sure yet. Fill in something clever later....
nil))))))
+;; FIXME this is not how you spell "preceding".
(defun semantic-documentation-comment-preceeding-tag (&optional tag nosnarf)
- "Find a comment preceeding TAG.
+ "Find a comment preceding TAG.
If TAG is nil. use the tag under point.
-Searches the space between TAG and the preceeding tag for a comment,
+Searches the space between TAG and the preceding tag for a comment,
and converts the comment into clean documentation.
Optional argument NOSNARF with a value of 'lex means to return
just the lexical token and not the string."
;;; semantic/edit.el --- Edit Management for Semantic
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-;;; 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+;; 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; syntax instead.
;;
;; 2. Incremental parsing while a new function is being typed in
-;; somtimes gets a chance only when lists are incomplete,
+;; sometimes gets a chance only when lists are incomplete,
;; preventing correct context identification.
;;
(defvar semantic-edits-incremental-reparse-failed-hook nil
"Hook run after the incremental parser fails.
-When this happens, the buffer is marked as needing a full reprase.")
+When this happens, the buffer is marked as needing a full reparse.")
(semantic-varalias-obsolete 'semantic-edits-incremental-reparse-failed-hooks
'semantic-edits-incremental-reparse-failed-hook)
(defcustom semantic-edits-verbose-flag nil
- "Non-nil means the incremental perser is verbose.
+ "Non-nil means the incremental parser is verbose.
If nil, errors are still displayed, but informative messages are not."
:group 'semantic
:type 'boolean)
changed-tags))
(defmacro semantic-edits-assert-valid-region ()
- "Asert that parse-start and parse-end are sorted correctly."
+ "Assert that parse-start and parse-end are sorted correctly."
;;; (if (> parse-start parse-end)
;;; (error "Bug is %s !> %d! Buff min/max = [ %d %d ]"
;;; parse-start parse-end
;; list can be fiddled.
(defun semantic-edits-splice-remove (oldtags parent cachelist)
"Remove OLDTAGS from PARENT's CACHELIST.
-OLDTAGS are tags in the currenet buffer, preferably linked
+OLDTAGS are tags in the current buffer, preferably linked
together also in CACHELIST.
PARENT is the parent tag containing OLDTAGS.
CACHELIST should be the children from PARENT, but may be
(defun semantic-edits-splice-replace (oldtag newtag)
"Replace OLDTAG with NEWTAG in the current cache.
-Do this by recycling OLDTAG's first CONS cell. This effectivly
+Do this by recycling OLDTAG's first CONS cell. This effectively
causes the new tag to completely replace the old one.
Make sure that all information in the overlay is transferred.
It is presumed that OLDTAG and NEWTAG are both cooked.
;;; semantic/find.el --- Search routines for Semantic
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
;; used for compatibility with the semantic 1.x search routines.
;;
;; 1.5) semantic-brute-find-first-tag-by-*
-;; Like 1, except seraching stops on the first match for the given
+;; Like 1, except searching stops on the first match for the given
;; information.
;;
;; 2) semantic-find-tag-by-*
-;; These prefered search routines attempt to scan through lists
+;; These preferred search routines attempt to scan through lists
;; in an intelligent way based on questions asked.
;;
;; 3) semantic-find-*-overlay
;;;###autoload
(defun semantic-find-tag-by-overlay-in-region (start end &optional buffer)
"Find all tags which exist in whole or in part between START and END.
-Uses overlays to determine positin.
+Uses overlays to determine position.
Optional BUFFER argument specifies the buffer to use."
(save-excursion
(if buffer (set-buffer buffer))
,table)))
(defmacro semantic-find-tags-for-completion (prefix &optional table)
- "Find all tags whos name begins with PREFIX in TABLE.
+ "Find all tags whose name begins with PREFIX in TABLE.
PREFIX is a string.
TABLE is a tag table. See `semantic-something-to-tag-table'.
While it would be nice to use `try-completion' or `all-completions',
(defun semantic-find-tags-by-scope-protection-default
(scopeprotection parent &optional table)
- "Find all tags accessable by SCOPEPROTECTION.
+ "Find all tags accessible by SCOPEPROTECTION.
SCOPEPROTECTION is a symbol which can be returned by the method
`semantic-tag-protection'. A hard-coded order is used to determine a match.
PARENT is a tag representing the PARENT slot needed for
,name (semantic-flatten-tags-table ,table)))
(defmacro semantic-deep-find-tags-for-completion (prefix &optional table)
- "Find all tags whos name begins with PREFIX in TABLE.
+ "Find all tags whose name begins with PREFIX in TABLE.
Search in top level tags, and their components, in TABLE.
TABLE is a tag table. See `semantic-flatten-tags-table'.
See also `semantic-find-tags-for-completion'."
;;; semantic/format.el --- Routines for formatting tags
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
-;;; 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
+;; 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
(mapcar (lambda (f) (list 'const f))
semantic-format-tag-functions)
'(function))
- "A List used by customizeable variables to choose a tag to text function.
+ "A List used by customizable variables to choose a tag to text function.
Use this variable in the :type field of a customizable variable.")
(defcustom semantic-format-use-images-flag ezimage-use-images
(defun semantic-format-tag-canonical-name-default (tag &optional parent color)
"Return a canonical name for TAG.
-A canonical name includes the names of any parents or namespaces preceeding
+A canonical name includes the names of any parents or namespaces preceding
the tag with colons separating them.
Optional argument PARENT is the parent type if TAG is a detail.
Optional argument COLOR means highlight the prototype with font-lock colors."
(cond
((vectorp elt)
(if prec
- (error "duplicate %%prec in `%s:%d' rule" nterm rindx))
+ (error "Duplicate %%prec in `%s:%d' rule" nterm rindx))
(setq prec
(aref elt 0)))
((consp elt)
;;; semantic/grammar.el --- Major mode framework for Semantic grammars
-;;; Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: David Ponce <david@dponce.com>
;; Maintainer: David Ponce <david@dponce.com>
output))
(defun semantic-grammar-recreate-package ()
- "Unconditionnaly create Lisp code from grammar in current buffer.
+ "Unconditionally create Lisp code from grammar in current buffer.
Like \\[universal-argument] \\[semantic-grammar-create-package]."
(interactive)
(semantic-grammar-create-package t))
(list mac lib))))
(defun semantic--grammar-macro-compl-dict ()
- "Return a completion dictionnary of macro definitions."
+ "Return a completion dictionary of macro definitions."
(let ((defs (semantic-grammar-macros))
def dups dict)
(while defs
;;; idle.el --- Schedule parsing tasks in idle time
-;;; Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
(defun semantic-idle-summary-current-symbol-info-brutish ()
"Return a string message describing the current context.
Gets a symbol with `semantic-ctxt-current-thing' and then
-trys to find it with a deep targetted search."
+tries to find it with a deep targeted search."
;; Try the current "thing".
(let ((sym (car (semantic-ctxt-current-thing))))
(when sym
(defun semantic-idle-summary-current-symbol-info-default ()
"Return a string message describing the current context.
-This functin will disable loading of previously unloaded files
+This function will disable loading of previously unloaded files
by semanticdb as a time-saving measure."
(let (
(semanticdb-find-default-throttle
;;; lex-spp.el --- Semantic Lexical Pre-processor
-;;; Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
(make-variable-buffer-local 'semantic-lex-spp-dynamic-macro-symbol-obarray)
(defvar semantic-lex-spp-dynamic-macro-symbol-obarray-stack nil
- "A stack of obarrays for temporarilly scoped macro values.")
+ "A stack of obarrays for temporarily scoped macro values.")
(make-variable-buffer-local 'semantic-lex-spp-dynamic-macro-symbol-obarray-stack)
(defvar semantic-lex-spp-expanded-macro-stack nil
;;
(defsubst semantic-lex-spp-symbol (name)
"Return spp symbol with NAME or nil if not found.
-The searcy priority is:
+The search priority is:
1. DYNAMIC symbols
2. PROJECT specified symbols.
3. SYSTEM specified symbols."
If TOK is made of multiple tokens, convert those to text. This
conversion is needed if a macro has a merge symbol in it that
combines the text of two previously distinct symbols. For
-exampe, in c:
+example, in c:
#define (a,b) a ## b;
;;; semantic/lex.el --- Lexical Analyzer builder
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-;;; 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+;; 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; the lexical analysis.
;;
;; In the lexical analyzer created with `define-lex', each condition
-;; is tested for a given point. When the conditin is true, the forms
+;; is tested for a given point. When the condition is true, the forms
;; run.
;;
;; The forms can push a lexical token onto the token stream. The
;; analyzer forms also must move the current analyzer point. If the
-;; analyzer point is moved without pushing a token, then tne matched
+;; analyzer point is moved without pushing a token, then the matched
;; syntax is effectively ignored, or skipped.
;;
;; Thus, starting at the beginning of a region to be analyzed, each
;;
;; The `define-lex' macro accepts a list of lexical analyzers. Each
;; analyzer is created with `define-lex-analyzer', or one of the
-;; derivitive macros. A single analyzer defines a regular expression
+;; derivative macros. A single analyzer defines a regular expression
;; to match text in a buffer, and a short segment of code to create
;; one lexical token.
;;
;; Keywords are used by `semantic-lex-symbol-or-keyword'
;; to create lexical tokens based on the keyword.
;;
-;; Lexical type table - A table of symbols declared in a grammer
+;; Lexical type table - A table of symbols declared in a grammar
;; file with the %type declaration.
;; The grammar compiler uses the type table to create new
;; lexical analyzers. These analyzers are then used to when
;;
;; A lexical type defines a kind of lexical analyzer that will be
;; automatically generated from a grammar file based on some
-;; predetermined attributes. For now these two attributes are
+;; predetermined attributes. For now these two attributes are
;; recognized :
;;
-;; * matchdatatype : define the kind of lexical analyzer. That is :
+;; * matchdatatype : define the kind of lexical analyzer. That is :
;;
;; - regexp : define a regexp analyzer (see
;; `define-lex-regex-type-analyzer')
;; `define-lex-keyword-type-analyzer')
;;
;; * syntax : define the syntax that matches a syntactic
-;; expression. When syntax is matched the corresponding type
+;; expression. When syntax is matched the corresponding type
;; analyzer is entered and the resulting match data will be
;; interpreted based on the kind of analyzer (see matchdatatype
;; above).
(defvar semantic-lex-comment-regex nil
"Regular expression for identifying comment start during lexical analysis.
This may be automatically set when semantic initializes in a mode, but
-may need to be overriden for some special languages.")
+may need to be overridden for some special languages.")
(make-variable-buffer-local 'semantic-lex-comment-regex)
(defvar semantic-lex-number-expression
"The current depth as tracked through lexical functions.")
(defvar semantic-lex-maximum-depth nil
- "The maximum depth of parenthisis as tracked through lexical functions.")
+ "The maximum depth of parenthesis as tracked through lexical functions.")
(defvar semantic-lex-token-stream nil
"The current token stream we are collecting.")
Note: The order in which analyzers are listed is important.
If two analyzers can match the same text, it is important to order the
analyzers so that the one you want to match first occurs first. For
-example, it is good to put a numbe analyzer in front of a symbol
+example, it is good to put a number analyzer in front of a symbol
analyzer which might mistake a number for as a symbol."
`(defun ,name (start end &optional depth length)
,(concat doc "\nSee `semantic-lex' for more information.")
"Create a lexical token.
SYMBOL is a symbol representing the class of syntax found.
START and END define the bounds of the token in the current buffer.
-Optional STR is the string for the token iff the the bounds
+Optional STR is the string for the token only if the the bounds
in the buffer do not cover the string they represent. (As from
macro expansion.)"
;; This if statement checks the existance of a STR argument at
"For SYNTAX, execute FORMS with protection for unterminated syntax.
If FORMS throws an error, treat this as a syntax problem, and
execute the unterminated syntax code. FORMS should return a position.
-Irreguardless of an error, the cursor should be moved to the end of
+Irregardless of an error, the cursor should be moved to the end of
the desired syntax, and a position returned.
If `debug-on-error' is set, errors are not caught, so that you can
debug them.
`semantic-lex-maximum-depth' - The maximum depth of semantic-list
for the current analysis.
`semantic-lex-current-depth' - The current depth of `semantic-list' that has
- been decended.
+ been descended.
`semantic-lex-end-point' - End Point after match.
Analyzers should set this to a buffer location if their
match string does not represent the end of the matched text.
(defcustom semantic-sb-autoexpand-length 1
"*Length of a semantic bucket to autoexpand in place.
-This will replace the named bucket that would have usually occured here."
+This will replace the named bucket that would have usually occurred here."
:group 'speedbar
:type 'integer)
;; Calculate information about the current scope.
;;
;; Manages the current scope as a structure that can be cached on a
-;; per-file basis and recycled between different occurances of
+;; per-file basis and recycled between different occurrences of
;; analysis on different parts of a file.
;;
;; Pattern for Scope Calculation
implicit \"object\".")
(defun semantic-analyze-scoped-tags-default (typelist halfscope)
- "Return accessable tags when TYPELIST and HALFSCOPE is in scope.
+ "Return accessible tags when TYPELIST and HALFSCOPE is in scope.
HALFSCOPE is the current scope partially initialized.
Tags returned are not in the global name space, but are instead
scoped inside a class or namespace. Such items can be referenced
Argument SCOPE specify additional tags that are in scope
whose tags can be searched when needed, OR it may be a scope object.
ACCESS is the level of access we filter on child supplied tags.
-For langauges with protection on specific methods or slots,
-it should strip out those not accessable by methods of TYPE.
+For languages with protection on specific methods or slots,
+it should strip out those not accessible by methods of TYPE.
An ACCESS of 'public means not in a method of a subclass of type.
A value of 'private means we can access private parts of the originating
type."
scopecache))))
(defun semantic-scope-find (name &optional class scope-in)
- "Find the tag with NAME, and optinal CLASS in the current SCOPE-IN.
+ "Find the tag with NAME, and optional CLASS in the current SCOPE-IN.
Searches various elements of the scope for NAME. Return ALL the
hits in order, with the first tag being in the closest scope."
(let ((scope (or scope-in (semantic-calculate-scope)))
;;; semantic/senator.el --- SEmantic NAvigaTOR
;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-;; 2009 Free Software Foundation, Inc.
+;; 2009 Free Software Foundation, Inc.
;; Author: David Ponce <david@dponce.com>
;; Maintainer: FSF
(defvar senator-search-tag-filter-functions
'(senator-search-default-tag-filter)
"List of functions to be called to filter searched tags.
-Each function is passed a tag. If one of them returns nil, the tag is
+Each function is passed a tag. If one of them returns nil, the tag is
excluded from the search.")
(defun senator-search (searcher text &optional bound noerror count)
(error "No previous search"))))
(defun senator-nonincremental-search-forward (string)
- "Search for STRING nonincrementally."
+ "Search for STRING nonincrementally."
(interactive "sSemantic search for string: ")
(setq senator-last-search-type 'string)
(if (equal string "")
(error "Unknown result type from `semantic-up-reference'"))))))
(defun semantic-up-reference-default (tag)
- "Return a tag that is referredto by TAG.
+ "Return a tag that is referred to by TAG.
Makes C/C++ language like assumptions."
(cond ((semantic-tag-faux-p tag)
;; Faux tags should have a real tag in some other location.
;;;###autoload
(defun senator-yank-tag ()
"Yank a tag from the tag ring.
-The form the tag takes is differnet depending on where it is being
+The form the tag takes is different depending on where it is being
yanked to."
(interactive)
(or (ring-empty-p senator-tag-ring)
;;;###autoload
(defun senator-transpose-tags-up ()
- "Transpose the current tag, and the preceeding tag."
+ "Transpose the current tag, and the preceding tag."
(interactive)
(semantic-fetch-tags)
(let* ((current-tag (semantic-current-tag))
;;; semantic/symref.el --- Symbol Reference API
-;;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <eric@siege-engine.com>
;;
;; Semantic's native parsing tools do not handle symbol references.
;; Tracking such information is a task that requires a huge amount of
-;; space and processing not apropriate for an Emacs Lisp program.
+;; space and processing not appropriate for an Emacs Lisp program.
;;
;; Many desired tools used in refactoring, however, need to have
;; such references available to them. This API aims to provide a
;;
;; ADD A NEW EXTERNAL TOOL
;;
-;; To support a new external tool, sublcass `semantic-symref-tool-baseclass'
+;; To support a new external tool, subclass `semantic-symref-tool-baseclass'
;; and implement the methods. The baseclass provides support for
;; managing external processes that produce parsable output.
;;
;;;###autoload
(defun semantic-symref-find-text (text &optional scope)
- "Find a list of occurances of TEXT in the current project.
+ "Find a list of occurrences of TEXT in the current project.
TEXT is a regexp formatted for use with egrep.
Optional SCOPE specifies which file set to search. Defaults to 'project.
Refers to `semantic-symref-tool', to determine the reference tool to use
;;; semantic/symref/filter.el --- Filter symbol reference hits for accuracy.
-;;; Copyright (C) 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <eric@siege-engine.com>
;; a symref results object.
(defun semantic-symref-hits-in-region (target hookfcn start end)
- "Find all occurances of the symbol TARGET that match TARGET the tag.
+ "Find all occurrences of the symbol TARGET that match TARGET the tag.
For each match, call HOOKFCN.
HOOKFCN takes three arguments that match
-`semantic-analyze-current-symbol's use of HOOKfCN.
+`semantic-analyze-current-symbol's use of HOOKFCN.
( START END PREFIX )
Search occurs in the current buffer between START and END."
;;; semantic/symref/grep.el --- Symref implementation using find/grep
-;;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <eric@siege-engine.com>
(defun semantic-symref-grep-use-template (rootdir filepattern grepflags greppattern)
"Use the grep template expand feature to create a grep command.
ROOTDIR is the root location to run the `find' from.
-FILEPATTERN is a string represeting find flags for searching file patterns.
+FILEPATTERN is a string representing find flags for searching file patterns.
GREPFLAGS are flags passed to grep, such as -n or -l.
-GREPPATTERN is the pattren used by grep."
+GREPPATTERN is the pattern used by grep."
;; We have grep-compute-defaults. Lets use it.
(grep-compute-defaults)
(let* ((grep-expand-keywords semantic-symref-grep-expand-keywords)
;;
;; Provide a simple user facing API to finding symbol references.
;;
-;; This UI will is the base of some refactoring tools. For any
-;; refactor, the user will execture `semantic-symref' in a tag. Once
-;; that data is collected, the output will be listed in a buffer. In
-;; the output buffer, the user can then initiate different refactoring
-;; operations.
+;; This UI is the base of some refactoring tools. For any refactor,
+;; the user will execture [FIXME what?] `semantic-symref' in a tag.
+;; Once that data is collected, the output will be listed in a buffer.
+;; In the output buffer, the user can then initiate different
+;; refactoring operations.
;;
;; NOTE: Need to add some refactoring tools.
(defun semantic-symref ()
"Find references to the current tag.
This command uses the currently configured references tool within the
-current project to find references to the current tag. The
+current project to find references to the current tag. The
references are the organized by file and the name of the function
they are used in.
-Display the references in`semantic-symref-results-mode'"
+Display the references in`semantic-symref-results-mode'."
(interactive)
(semantic-fetch-tags)
(let ((ct (semantic-current-tag))
current project to find references to the input SYM. The
references are the organized by file and the name of the function
they are used in.
-Display the references in`semantic-symref-results-mode'"
+Display the references in`semantic-symref-results-mode'."
(interactive (list (semantic-tag-name (semantic-complete-read-tag-buffer-deep
"Symrefs for: "))))
(semantic-fetch-tags)
)
(defun semantic-symref-hide-buffer ()
- "Hide buffer with sematinc-symref results"
+ "Hide buffer with semantic-symref results."
(interactive)
(bury-buffer))
;;; semantic/tag.el --- tag creation and access
-;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
-;;; 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
+;; 2009 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; II. There is also an API for tag creation. Use `semantic-tag' to create
;; a new tag.
;;
-;; III. Tag Comparison. Allows explicit or comparitive tests to see
+;; III. Tag Comparison. Allows explicit or comparative tests to see
;; if two tags are the same.
;;; Code:
@item include
Statement that represents a file from which more tags can be found.
@item package
-Statement that declairs this file's package name.
+Statement that declares this file's package name.
@item code
Code that has not name or binding to any other symbol, such as in a script.
@end table
"Create a semantic tag of class 'variable.
NAME is the name of this variable.
TYPE is a string or semantic tag representing the type of this variable.
-Optional DEFAULT-VALUE is a string representing the default value of this variable.
-ATTRIBUTES is a list of additional attributes belonging to this tag."
+Optional DEFAULT-VALUE is a string representing the default value of this
+variable. ATTRIBUTES is a list of additional attributes belonging to this
+tag."
(apply 'semantic-tag name 'variable
:type type
:default-value default-value
If optional argument KEEP-FILE is non-nil, and TAG was linked to a
buffer, the originating buffer file name is kept in the `:filename'
property of the copied tag.
-If KEEP-FILE is a string, and the orginating buffer is NOT available,
+If KEEP-FILE is a string, and the originating buffer is NOT available,
then KEEP-FILE is stored on the `:filename' property.
This runs the tag hook `unlink-copy-hook`."
;; Right now, TAG is a list.
(defun semantic--tag-deep-copy-attributes (attrs &optional filter)
"Make a deep copy of ATTRS, applying FILTER to each child-tag.
-It is safe to modify ATTR, and return a permutaion of that list.
+It is safe to modify ATTR, and return a permutation of that list.
FILTER takes TAG as an argument, and should returns a semantic-tag.
It is safe for FILTER to modify the input tag and return it."
(defun semantic--tag-deep-copy-value (value &optional filter)
"Make a deep copy of VALUE, applying FILTER to each child-tag.
-It is safe to modify VALUE, and return a permutaion of that list.
+It is safe to modify VALUE, and return a permutation of that list.
FILTER takes TAG as an argument, and should returns a semantic-tag.
It is safe for FILTER to modify the input tag and return it."
(defun semantic--tag-deep-copy-tag-list (tags &optional filter)
"Make a deep copy of TAGS, applying FILTER to each child-tag.
-It is safe to modify the TAGS list, and return a permutaion of that list.
+It is safe to modify the TAGS list, and return a permutation of that list.
FILTER takes TAG as an argument, and should returns a semantic-tag.
It is safe for FILTER to modify the input tag and return it."
"Return the list of top level components belonging to TAG.
Children are any sub-tags which contain overlays.
The default action collects regular components of TAG, in addition
-to any components beloning to an anonymous type."
+to any components belonging to an anonymous type."
(let ((explicit-children (semantic-tag-components tag))
(type (semantic-tag-type tag))
(anon-type-children nil)
;;; semantic/texi.el --- Semantic details for Texinfo files
-;;; Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
+;; Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
"menu\\|"
(substring texinfo-environment-regexp
(match-beginning 0)))))
- "Regular expression for matching texinfo enviroments.
+ "Regular expression for matching texinfo environments.
uses `texinfo-environment-regexp', but makes sure that it
can handle the @menu environment.")
;;; semantic/util-modes.el --- Semantic minor modes
-;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
-;;; Free Software Foundation, Inc.
+;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
+;; Free Software Foundation, Inc.
;; Authors: Eric M. Ludlam <zappo@gnu.org>
;; David Ponce <david@dponce.com>
(defcustom global-semantic-show-parser-state-mode nil
"If non-nil enable global use of `semantic-show-parser-state-mode'.
When enabled, the current parse state of the current buffer is displayed
-in the mode line. See `semantic-show-parser-state-marker' for details
+in the mode line. See `semantic-show-parser-state-marker' for details
on what is displayed."
:group 'semantic
:type 'boolean
(defun semantic-show-parser-state-mode (&optional arg)
"Minor mode for displaying parser cache state in the modeline.
The cache can be in one of three states. They are
-Up to date, Partial reprase needed, and Full reparse needed.
+Up to date, Partial reparse needed, and Full reparse needed.
The state is indicated in the modeline with the following characters:
`-' -> The cache is up to date.
`!' -> The cache requires a full update.
(defmacro wisent-lex-eoi ()
"Return an End-Of-Input lexical token.
-The EOI token is like this: ($EOI "" POINT-MAX . POINT-MAX)."
+The EOI token is like this: ($EOI \"\" POINT-MAX . POINT-MAX)."
`(cons ',wisent-eoi-term
(cons ""
(cons (point-max) (point-max)))))
projects / emacs.git / commitdiff