+2010-01-12 Juanma Barranquero <lekktu@gmail.com>
+
+ * cedet/semantic/analyze.el (semantic-analyze-push-error)
+ (semantic-analyze-context, semantic-analyze-context-assignment)
+ (semantic-analyze-find-tag-sequence, semantic-analyze-find-tag):
+ * cedet/semantic/java.el (java-mode, semantic-tag-include-filename)
+ (semantic-java-doc-keywords-map):
+ * cedet/semantic/bovine/c.el (c-mode, semantic-c-member-of-autocast)
+ (semantic-lex-c-nested-namespace-ignore-second, semantic-parse-region)
+ (semantic-c-parse-lexical-token, semantic-c-debug-mode-init-pch)
+ (semantic-c-classname, semantic-format-tag-uml-prototype)
+ (semantic-c-dereference-namespace, semantic-analyze-type-constants):
+ * cedet/semantic/bovine/el.el (semantic-elisp-form-to-doc-string)
+ (semantic-emacs-lisp-obsoleted-doc, semantic-up-context)
+ (semantic-get-local-variables, semantic-end-of-command)
+ (semantic-beginning-of-command, semantic-ctxt-current-class-list)
+ (lisp-mode):
+ * cedet/semantic/bovine/make.el (makefile-mode):
+ * cedet/semantic/wisent/python.el (wisent-python-string-re)
+ (wisent-python-implicit-line-joining-p, wisent-python-forward-string)
+ (wisent-python-lex-beginning-of-line, wisent-python-lex-end-of-line)
+ (semantic-lex, semantic-get-local-variables, python-mode):
+ * cedet/semantic/wisent/python-wy.el (wisent-python-wy--keyword-table):
+ * cedet/srecode/extract.el (srecode-extract-state-set)
+ (srecode-extract-method): Fix typos in docstrings.
+
2010-01-11 Sam Steingold <sds@gnu.org>
* imenu.el (imenu-default-create-index-function): Detect infinite
;; tag - A single entity
;; prefix - The beginning of a symbol, usually used to look up something
;; incomplete.
-;; type - The name of a datatype in the langauge.
+;; type - The name of a datatype in the language.
;; metatype - If a type is named in a declaration like:
;; struct moose somevariable;
;; that name "moose" can be turned into a concrete type.
(defun semantic-analyze-push-error (err)
"Push the error in ERR-DATA onto the error stack.
-Argument ERR"
+Argument ERR."
(push err semantic-analyze-error-stack))
;;; Analysis Classes
(errors :initarg :errors
:documentation "Any errors thrown an caught during analysis.")
)
- "Base analysis data for a any context.")
+ "Base analysis data for any context.")
(defclass semantic-analyze-context-assignment (semantic-analyze-context)
((assignee :initarg :assignee
:documentation "A sequence of tags for an assignee.
This is a variable into which some value is being placed. The last
item in the list is the variable accepting the value. Earlier
-tags represent the variables being derefernece to get to the
+tags represent the variables being dereferenced to get to the
assignee."))
"Analysis class for a value in an assignment.")
it is not found in the global set of tables.
Optional argument SCOPE are additional terminals to search which are currently
scoped. These are not local variables, but symbols available in a structure
-which doesn't need to be dereferneced.
+which doesn't need to be dereferenced.
Optional argument TYPERETURN is a symbol in which the types of all found
will be stored. If nil, that data is thrown away.
Optional argument THROWSYM specifies a symbol the throw on non-recoverable error.")
(defun semantic-analyze-find-tag (name &optional tagclass scope)
"Return the first tag found with NAME or nil if not found.
-Optional argument TAGCLASS specifies the class of tag to return, such
-as 'function or 'variable.
+Optional argument TAGCLASS specifies the class of tag to return,
+such as 'function or 'variable.
Optional argument SCOPE specifies a scope object which has
additional tags which are in SCOPE and do not need prefixing to
find.
(defcustom-mode-local-semantic-dependency-system-include-path
c-mode semantic-c-dependency-system-include-path
'("/usr/include")
- "The system include path used by the C langauge.")
+ "The system include path used by the C language.")
(defcustom semantic-default-c-path nil
"Default set of include paths for C code.
)
(defcustom semantic-c-member-of-autocast 't
- "Non-nil means classes with a '->' operator will cast to it's return type.
+ "Non-nil means classes with a '->' operator will cast to its return type.
For Examples:
the second namespace in use, then it should not be included.
If you are having problems with smart completion and STL templates,
-it may that this is set incorrectly. After changing the value
+it may be that this is set incorrectly. After changing the value
of this flag, you will need to delete any semanticdb cache files
that may have been incorrectly parsed."
:group 'semantic
(define-mode-local-override semantic-parse-region c-mode
(start end &optional nonterminal depth returnonerror)
- "Calls 'semantic-parse-region-default', except in a macro expansion.
+ "Calls `semantic-parse-region-default', except in a macro expansion.
MACRO expansion mode is handled through the nature of Emacs's non-lexical
binding of variables.
START, END, NONTERMINAL, DEPTH, and RETURNONERRORS are the same
(funcall mode)
(error
(if (y-or-n-p
- (format "There was an error initializing %s in buffer \"%s\". Debug your hooks? "
+ (format "There was an error initializing %s in buffer \"%s\". Debug your hooks? "
mode (buffer-name)))
(semantic-c-debug-mode-init mode)
(message "Macro parsing state may be broken...")
(switch-to-buffer-other-window
(get-buffer-create "*MODE HACK TEST*"))
(erase-buffer)
- (insert "A failure occured while parsing your buffers.
+ (insert "A failure occurred while parsing your buffers.
-The failure occured while attempting to initialize " (symbol-name mm) " in a
+The failure occurred while attempting to initialize " (symbol-name mm) " in a
buffer not associated with a file. To debug this problem, type
M-x semantic-c-debug-mode-init
"At parse time, assign a class or struct name text here.
It is picked up by `semantic-c-reconstitute-token' to determine
if something is a constructor. Value should be:
- ( TYPENAME . TYPEOFTYPE)
+ (TYPENAME . TYPEOFTYPE)
where typename is the name of the type, and typeoftype is \"class\"
or \"struct\".")
(define-mode-local-override semantic-format-tag-uml-prototype
c-mode (token &optional parent color)
- "Return an uml string describing TOKEN for C and C++.
+ "Return an UML string describing TOKEN for C and C++.
Optional PARENT and COLOR as specified with
`semantic-abbreviate-tag-default'."
;; If we have special template things, append.
(defun semantic-c-dereference-namespace (type scope &optional type-declaration)
"Dereference namespace which might hold an 'alias' for TYPE.
Such an alias can be created through 'using' statements in a
-namespace declaration. This function checks the namespaces in
+namespace declaration. This function checks the namespaces in
SCOPE for such statements."
(let ((scopetypes (oref scope scopetypes))
typename currentns tmp usingname result namespaces)
(list type type-declaration))
(define-mode-local-override semantic-analyze-type-constants c-mode (type)
- "When TYPE is a tag for an enum, return it's parts.
+ "When TYPE is a tag for an enum, return its parts.
These are constants which are of type TYPE."
(if (and (eq (semantic-tag-class type) 'type)
(string= (semantic-tag-type type) "enum"))
(semantic-idle-summary-current-symbol-info-default))))
(defvar-mode-local c-mode semantic-orphaned-member-metaparent-type "struct"
- "When lost memberes are found in the class hierarchy generator, use a struct.")
+ "When lost members are found in the class hierarchy generator, use a struct.")
(defvar-mode-local c-mode semantic-symbol->name-assoc-list
'((type . "Types")
"Separator characters between something of a given type, and a field.")
(defvar-mode-local c-mode semantic-command-separation-character ";"
- "Commen separation character for C")
+ "Command separation character for C.")
(defvar-mode-local c-mode senator-step-at-tag-classes '(function variable)
"Tag classes where senator will stop at the end.")
(nreverse vars)))
(defun semantic-elisp-form-to-doc-string (form)
- "After reading a form FORM, covert it to a doc string.
+ "After reading a form FORM, convert it to a doc string.
For Emacs Lisp, sometimes that string is non-existent.
Sometimes it is a form which is evaluated at compile time, permitting
compound strings."
""))
(defun semantic-emacs-lisp-obsoleted-doc (tag)
- "Indicate that TAG is a new name that has obsoleted some old name.
+ "Indicate that TAG is a new name that has obsoleted some old name.
Unfortunately, this requires that the tag in question has been loaded
into Emacs Lisp's memory."
(let ((obsoletethis (intern-soft (semantic-tag-name tag)))
(define-mode-local-override semantic-up-context emacs-lisp-mode
(&optional point bounds-type)
"Move up one context in an Emacs Lisp function.
-A Context in many languages is a block with it's own local variables.
+A Context in many languages is a block with its own local variables.
In Emacs, we will move up lists and stop when one starts with one of
the following context specifiers:
`let', `let*', `defun', `with-slots'
(define-mode-local-override semantic-get-local-variables emacs-lisp-mode
(&optional point)
"Return a list of local variables for POINT.
-Scan backwards from point at each successive function. For all occurances
+Scan backwards from point at each successive function. For all occurrences
of `let' or `let*', grab those variable names."
(let* ((vars nil)
(fn nil))
(define-mode-local-override semantic-end-of-command emacs-lisp-mode
()
"Move cursor to the end of the current command.
-In emacs lisp this is easilly defined by parenthisis bounding."
+In Emacs Lisp this is easily defined by parenthesis bounding."
(condition-case nil
(up-list 1)
(error nil)))
(define-mode-local-override semantic-beginning-of-command emacs-lisp-mode
()
"Move cursor to the beginning of the current command.
-In emacs lisp this is easilly defined by parenthisis bounding."
+In Emacs Lisp this is easily defined by parenthesis bounding."
(condition-case nil
(progn
(up-list -1)
(&optional point)
"Return a list of tag classes allowed at POINT.
Emacs Lisp knows much more about the class of the tag needed to perform
-completion than some langauges. We distincly know if we are to be
-a function name, variable name, or any type of symbol. We could identify
+completion than some languages. We distincly know if we are to be a
+function name, variable name, or any type of symbol. We could identify
fields and such to, but that is for some other day."
(save-excursion
(if point (goto-char point))
ELisp variables can be pretty long, so track this one too.")
(define-child-mode lisp-mode emacs-lisp-mode
- "Make `lisp-mode' inherits mode local behavior from `emacs-lisp-mode'.")
+ "Make `lisp-mode' inherit mode local behavior from `emacs-lisp-mode'.")
(defun semantic-default-elisp-setup ()
"Setup hook function for Emacs Lisp files and Semantic."
(defcustom-mode-local-semantic-dependency-system-include-path
makefile-mode semantic-makefile-dependency-system-include-path
nil
- "The system include path used by Makefiles langauge.")
+ "The system include path used by Makefiles language.")
;;;###autoload
(defun semantic-default-make-setup ()
java-mode semantic-java-dependency-system-include-path
;; @todo - Use JDEE to get at the include path, or something else?
nil
- "The system include path used by Java langauge.")
+ "The system include path used by Java language.")
;; Local context
;;
;; Thanks Bruce Stephens
(define-mode-local-override semantic-tag-include-filename java-mode (tag)
- "Return a suitable path for (some) Java imports"
+ "Return a suitable path for (some) Java imports."
(let ((name (semantic-tag-name tag)))
(concat (mapconcat 'identity (split-string name "\\.") "/") ".java")))
(defun semantic-java-doc-keywords-map (fun &optional property)
"Run function FUN for each javadoc keyword.
Return the list of FUN results. If optional PROPERTY is non nil only
-call FUN for javadoc keyword which have a value for PROPERTY. FUN
+call FUN for javadoc keywords which have a value for PROPERTY. FUN
receives two arguments: the javadoc keyword and its associated
-'javadoc property list. It can return any value. Nil values are
+'javadoc property list. It can return any value. All nil values are
removed from the result list."
(delq nil
(mapcar
("global" summary "Declare one or more symbols as global symbols")
("from" summary "Modify behavior of 'import' statement")
("for" summary "Start a 'for' loop")
- ("finally" summary "Specify code to be executed after 'try' statements whether or not an exception occured")
- ("exec" summary "Dynamically execute python code")
+ ("finally" summary "Specify code to be executed after 'try' statements whether or not an exception occurred")
+ ("exec" summary "Dynamically execute Python code")
("except" summary "Specify exception handlers along with 'try' keyword")
("else" summary "Start the 'else' clause following an 'if' statement")
("elif" summary "Shorthand for 'else if' following an 'if' statement")
("del" summary "Delete specified objects, i.e., undo what assignment did")
("def" summary "Define a new function")
- ("continue" summary "Skip to the next interation of enclosing for or whilte loop")
+ ("continue" summary "Skip to the next interation of enclosing 'for' or 'while' loop")
("class" summary "Define a new class")
- ("break" summary "Terminate 'for' or 'while loop")
+ ("break" summary "Terminate 'for' or 'while' loop")
("assert" summary "Raise AssertionError exception if <expr> is false")
("and" summary "Logical AND binary operator ... ")))
"Table of language keywords.")
(defconst wisent-python-string-re
(concat (regexp-opt '("r" "u" "ur" "R" "U" "UR" "Ur" "uR") t)
"?['\"]")
- "Regexp matching beginning of a python string.")
+ "Regexp matching beginning of a Python string.")
(defvar wisent-python-EXPANDING-block nil
"Non-nil when expanding a paren block for Python lexical analyzer.")
(defun wisent-python-implicit-line-joining-p ()
"Return non-nil if implicit line joining is active.
-That is, if inside an expressions in parentheses, square brackets or
+That is, if inside an expression in parentheses, square brackets or
curly braces."
wisent-python-EXPANDING-block)
(defsubst wisent-python-forward-string ()
- "Move point at the end of the python string at point."
+ "Move point at the end of the Python string at point."
(when (looking-at wisent-python-string-re)
;; skip the prefix
(and (match-end 1) (goto-char (match-end 1)))
(defvar wisent-python-indent-stack)
(define-lex-analyzer wisent-python-lex-beginning-of-line
- "Detect and create python indentation tokens at beginning of line."
+ "Detect and create Python indentation tokens at beginning of line."
(and
(bolp) (not (wisent-python-implicit-line-joining-p))
(let ((last-indent (car wisent-python-indent-stack))
)
(define-lex-regex-analyzer wisent-python-lex-end-of-line
- "Detect and create python newline tokens.
+ "Detect and create Python newline tokens.
Just skip the newline character if the following line is an implicit
continuation of current line."
"\\(\n\\|\\s>\\)"
;;
(define-mode-local-override semantic-lex python-mode
(start end &optional depth length)
- "Lexically analyze python code in current buffer.
+ "Lexically analyze Python code in current buffer.
See the function `semantic-lex' for the meaning of the START, END,
DEPTH and LENGTH arguments.
This function calls `wisent-python-lexer' to actually perform the
-lexical analysis, then emits the necessary python DEDENT tokens from
+lexical analysis, then emits the necessary Python DEDENT tokens from
what remains in the `wisent-python-indent-stack'."
(let* ((wisent-python-indent-stack (list 0))
(stream (wisent-python-lexer start end depth length))
(define-mode-local-override semantic-get-local-variables python-mode ()
"Get the local variables based on point's context.
-To be implemented for python! For now just return nil."
+To be implemented for Python! For now just return nil."
nil)
(defcustom-mode-local-semantic-dependency-system-include-path
python-mode semantic-python-dependency-system-include-path
nil
- "The system include path used by Python langauge.")
+ "The system include path used by Python language.")
;;; Enable Semantic in `python-mode'.
;;
"The current extraction state.")
(defmethod srecode-extract-state-set ((st srecode-extract-state) ins dict)
- "Set onto the extract state ST a new inserter INS and dictinary DICT."
+ "Set onto the extract state ST a new inserter INS and dictionary DICT."
(oset st lastinserter ins)
(oset st lastdict dict))
state)
"Extract template ST and store extracted text in DICTIONARY.
Optional STARTRETURN is a symbol in which the start of the first
-plain-text match occured."
+plain-text match occurred."
(srecode-extract-code-stream (oref st code) dictionary state))
(defun srecode-extract-code-stream (code dictionary state)
projects / emacs.git / commitdiff