mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-11-24 07:20:37 +00:00
Code Issues Releases Activity

Spelling fixes

Browse Source 
All uses changed.
* lib-src/etags.c (analyze_regex): Rename from analyse_regex.
* lisp/cedet/semantic/lex-spp.el:
(semantic-lex-spp-analyzer-do-replace):
Rename from semantic-lex-spp-anlyzer-do-replace.
* lisp/emacs-lisp/cconv.el (cconv--analyze-use):
Rename from cconv--analyse-use.
(cconv--analyze-function): Rename from cconv--analyse-function.
(cconv-analyze-form): Rename from cconv-analyse-form.
* src/regex.c (analyze_first): Rename from analyze_first.
This commit is contained in:
Paul Eggert 2014-12-13 23:40:04 -08:00
parent 2e7f6d53f3
commit 3de474e4ac
12 changed files with 68 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ChangeLog
View File

@ -1,3 +1,17 @@
2014-12-14 Paul Eggert <eggert@cs.ucla.edu>
Spelling fixes
All uses changed.
* lib-src/etags.c (analyze_regex): Rename from analyse_regex.
* lisp/cedet/semantic/lex-spp.el:
(semantic-lex-spp-analyzer-do-replace):
Rename from semantic-lex-spp-anlyzer-do-replace.
* lisp/emacs-lisp/cconv.el (cconv--analyze-use):
Rename from cconv--analyse-use.
(cconv--analyze-function): Rename from cconv--analyse-function.
(cconv-analyze-form): Rename from cconv-analyse-form.
* src/regex.c (analyze_first): Rename from analyze_first.
2014-12-14 Glenn Morris <rgm@gnu.org>
* make-dist: No more lib-src/grep-changelog.

2
etc/TERMS
View File

@ -72,7 +72,7 @@ is `cS', which I invented.
correct parameter conventions from what would make the VT-100's
`cs' string work properly. From an incorrect assumption about
%i, I reached an incorrect conclusion about `cs', but the result
worked correctly on the VT100 and ANSII terminals. In Emacs
worked correctly on the VT100 and ANSI terminals. In Emacs
version 17, both `cs' and %i work correctly.
The version 16 convention was to pass, for the second parameter,

2
etc/refcards/sk-refcard.tex
View File

@ -7,7 +7,7 @@
% Czech translation: Jan Buchal <buchal@brailcom.cz>, January 1999
% Milan Zamazal <pdm@zamazal.org>, August 1999
% Pavel Janík <Pavel@Janik.cz>, November 2000 (Emacs 21)
% Slozak translation: Miroslav Vaško <vasko@debian.cz>, March 2001
% Slovak translation: Miroslav Vaško <vasko@debian.cz>, March 2001
% This file is part of GNU Emacs.

8
lib-src/etags.c
View File

@ -314,7 +314,7 @@ static long readline_internal (linebuffer *, FILE *);
static bool nocase_tail (const char *);
static void get_tag (char *, char **);
static void analyse_regex (char *);
static void analyze_regex (char *);
static void free_regexps (void);
static void regex_tag_multiline (void);
static void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
@ -1207,7 +1207,7 @@ main (int argc, char **argv)
lang = argbuffer[i].lang;
break;
case at_regexp:
analyse_regex (argbuffer[i].what);
analyze_regex (argbuffer[i].what);
break;
case at_filename:
this_file = argbuffer[i].what;
@ -5573,7 +5573,7 @@ scan_separators (char *name)
/* Look at the argument of --regex or --no-regex and do the right
thing. Same for each line of a regexp file. */
static void
analyse_regex (char *regex_arg)
analyze_regex (char *regex_arg)
{
if (regex_arg == NULL)
{
@ -5604,7 +5604,7 @@ analyse_regex (char *regex_arg)
pfatal (regexfile);
linebuffer_init (&regexbuf);
while (readline_internal (&regexbuf, regexfp) > 0)
analyse_regex (regexbuf.buffer);
analyze_regex (regexbuf.buffer);
free (regexbuf.buffer);
fclose (regexfp);
}

5
lisp/cedet/semantic/lex-spp.el
View File

@ -823,7 +823,7 @@ ARGVALUES are values for any arg list, or nil."
;; An analyzer that will push tokens from a macro in place
;; of the macro symbol.
;;
(defun semantic-lex-spp-anlyzer-do-replace (sym val beg end)
(defun semantic-lex-spp-analyzer-do-replace (sym val beg end)
"Do the lexical replacement for SYM with VAL.
Argument BEG and END specify the bounds of SYM in the buffer."
(if (not val)
@ -863,6 +863,9 @@ Argument BEG and END specify the bounds of SYM in the buffer."
(setq semantic-lex-end-point end)
)
))
(define-obsolete-function-alias
'semantic-lex-spp-anlyzer-do-replace
'semantic-lex-spp-analyzer-do-replace "25.1")
(defvar semantic-lex-spp-replacements-enabled t
"Non-nil means do replacements when finding keywords.

2
lisp/emacs-lisp/bytecomp.el
View File

@ -417,7 +417,7 @@ specify different fields to sort on."
This list lives partly on the stack.")
(defvar byte-compile-lexical-variables nil
"List of variables that have been treated as lexical.
Filled in `cconv-analyse-form' but initialized and consulted here.")
Filled in `cconv-analyze-form' but initialized and consulted here.")
(defvar byte-compile-const-variables nil
"List of variables declared as constants during compilation of this file.")
(defvar byte-compile-free-references)

57
lisp/emacs-lisp/cconv.el
View File

@ -30,13 +30,13 @@
;; All macros should be expanded beforehand.
;;
;; Here is a brief explanation how this code works.
;; Firstly, we analyze the tree by calling cconv-analyse-form.
;; Firstly, we analyze the tree by calling cconv-analyze-form.
;; This function finds all mutated variables, all functions that are suitable
;; for lambda lifting and all variables captured by closure. It passes the tree
;; once, returning a list of three lists.
;;
;; Then we calculate the intersection of the first and third lists returned by
;; cconv-analyse form to find all mutated variables that are captured by
;; cconv-analyze form to find all mutated variables that are captured by
;; closure.
;; Armed with this data, we call cconv-closure-convert-rec, that rewrites the
@ -140,7 +140,7 @@ Returns a form where all lambdas don't have any free variables."
(cconv-lambda-candidates '())
(cconv-captured+mutated '()))
;; Analyze form - fill these variables with new information.
(cconv-analyse-form form '())
(cconv-analyze-form form '())
(setq cconv-freevars-alist (nreverse cconv-freevars-alist))
(prog1 (cconv-convert form nil nil) ; Env initially empty.
(cl-assert (null cconv-freevars-alist)))))
@ -152,7 +152,7 @@ Returns a form where all lambdas don't have any free variables."
(cconv-lambda-candidates '())
(cconv-captured+mutated '()))
;; Analyze form - fill these variables with new information.
(cconv-analyse-form form '())
(cconv-analyze-form form '())
;; But don't perform the closure conversion.
form))
@ -525,7 +525,7 @@ places where they originally did not directly appear."
(defalias 'byte-compile-not-lexical-var-p 'boundp))
(defvar byte-compile-lexical-variables)
(defun cconv--analyse-use (vardata form varkind)
(defun cconv--analyze-use (vardata form varkind)
"Analyze the use of a variable.
VARDATA should be (BINDER READ MUTATED CAPTURED CALLED).
VARKIND is the name of the kind of variable.
@ -557,7 +557,7 @@ FORM is the parent form that binds this var."
(`(,(and binder `(,_ (function (lambda . ,_)))) nil nil nil t)
(push (cons binder form) cconv-lambda-candidates))))
(defun cconv--analyse-function (args body env parentform)
(defun cconv--analyze-function (args body env parentform)
(let* ((newvars nil)
(freevars (list body))
;; We analyze the body within a new environment where all uses are
@ -582,10 +582,10 @@ FORM is the parent form that binds this var."
(push (cons (list arg) (cdr varstruct)) newvars)
(push varstruct newenv)))))
(dolist (form body) ;Analyze body forms.
(cconv-analyse-form form newenv))
(cconv-analyze-form form newenv))
;; Summarize resulting data about arguments.
(dolist (vardata newvars)
(cconv--analyse-use vardata parentform "argument"))
(cconv--analyze-use vardata parentform "argument"))
;; Transfer uses collected in `envcopy' (via `newenv') back to `env';
;; and compute free variables.
(while env
@ -601,7 +601,7 @@ FORM is the parent form that binds this var."
(setf (nth 3 (car env)) t))
(setq env (cdr env) envcopy (cdr envcopy))))))
(defun cconv-analyse-form (form env)
(defun cconv-analyze-form (form env)
"Find mutated variables and variables captured by closure.
Analyze lambdas if they are suitable for lambda lifting.
- FORM is a piece of Elisp code after macroexpansion.
@ -628,7 +628,7 @@ and updates the data stored in ENV."
(setq var (car binder))
(setq value (cadr binder))
(cconv-analyse-form value (if (eq letsym 'let*) env orig-env)))
(cconv-analyze-form value (if (eq letsym 'let*) env orig-env)))
(unless (byte-compile-not-lexical-var-p var)
(cl-pushnew var byte-compile-lexical-variables)
@ -637,13 +637,13 @@ and updates the data stored in ENV."
(push varstruct env))))
(dolist (form body-forms) ; Analyze body forms.
(cconv-analyse-form form env))
(cconv-analyze-form form env))
(dolist (vardata newvars)
(cconv--analyse-use vardata form "variable"))))
(cconv--analyze-use vardata form "variable"))))
(`(function (lambda ,vrs . ,body-forms))
(cconv--analyse-function vrs body-forms env form))
(cconv--analyze-function vrs body-forms env form))
(`(setq . ,forms)
;; If a local variable (member of env) is modified by setq then
@ -651,7 +651,7 @@ and updates the data stored in ENV."
(while forms
(let ((v (assq (car forms) env))) ; v = non nil if visible
(when v (setf (nth 2 v) t)))
(cconv-analyse-form (cadr forms) env)
(cconv-analyze-form (cadr forms) env)
(setq forms (cddr forms))))
(`((lambda . ,_) . ,_) ; First element is lambda expression.
@ -659,11 +659,11 @@ and updates the data stored in ENV."
(format "Use of deprecated ((lambda %s ...) ...) form" (nth 1 (car form)))
t :warning)
(dolist (exp `((function ,(car form)) . ,(cdr form)))
(cconv-analyse-form exp env)))
(cconv-analyze-form exp env)))
(`(cond . ,cond-forms) ; cond special form
(dolist (forms cond-forms)
(dolist (form forms) (cconv-analyse-form form env))))
(dolist (form forms) (cconv-analyze-form form env))))
(`(quote . ,_) nil) ; quote form
(`(function . ,_) nil) ; same as quote
@ -672,13 +672,13 @@ and updates the data stored in ENV."
(guard byte-compile--use-old-handlers))
;; FIXME: The bytecode for condition-case forces us to wrap the
;; form and handlers in closures.
(cconv--analyse-function () (list protected-form) env form)
(cconv--analyze-function () (list protected-form) env form)
(dolist (handler handlers)
(cconv--analyse-function (if var (list var)) (cdr handler)
(cconv--analyze-function (if var (list var)) (cdr handler)
env form)))
(`(condition-case ,var ,protected-form . ,handlers)
(cconv-analyse-form protected-form env)
(cconv-analyze-form protected-form env)
(when (and var (symbolp var) (byte-compile-not-lexical-var-p var))
(byte-compile-log-warning
(format "Lexical variable shadows the dynamic variable %S" var)))
@ -686,21 +686,21 @@ and updates the data stored in ENV."
(if var (push varstruct env))
(dolist (handler handlers)
(dolist (form (cdr handler))
(cconv-analyse-form form env)))
(if var (cconv--analyse-use (cons (list var) (cdr varstruct))
(cconv-analyze-form form env)))
(if var (cconv--analyze-use (cons (list var) (cdr varstruct))
form "variable"))))
;; FIXME: The bytecode for unwind-protect forces us to wrap the unwind.
(`(,(or (and `catch (guard byte-compile--use-old-handlers))
`unwind-protect)
,form . ,body)
(cconv-analyse-form form env)
(cconv--analyse-function () body env form))
(cconv-analyze-form form env)
(cconv--analyze-function () body env form))
(`(defvar ,var) (push var byte-compile-bound-variables))
(`(,(or `defconst `defvar) ,var ,value . ,_)
(push var byte-compile-bound-variables)
(cconv-analyse-form value env))
(cconv-analyze-form value env))
(`(,(or `funcall `apply) ,fun . ,args)
;; Here we ignore fun because funcall and apply are the only two
@ -710,8 +710,8 @@ and updates the data stored in ENV."
(let ((fdata (and (symbolp fun) (assq fun env))))
(if fdata
(setf (nth 4 fdata) t)
(cconv-analyse-form fun env)))
(dolist (form args) (cconv-analyse-form form env)))
(cconv-analyze-form fun env)))
(dolist (form args) (cconv-analyze-form form env)))
(`(interactive . ,forms)
;; These appear within the function body but they don't have access
@ -719,19 +719,20 @@ and updates the data stored in ENV."
;; We could extend this to allow interactive specs to refer to
;; variables in the function's enclosing environment, but it doesn't
;; seem worth the trouble.
(dolist (form forms) (cconv-analyse-form form nil)))
(dolist (form forms) (cconv-analyze-form form nil)))
;; `declare' should now be macro-expanded away (and if they're not, we're
;; in trouble because they *can* contain code nowadays).
;; (`(declare . ,_) nil) ;The args don't contain code.
(`(,_ . ,body-forms) ; First element is a function or whatever.
(dolist (form body-forms) (cconv-analyse-form form env)))
(dolist (form body-forms) (cconv-analyze-form form env)))
((pred symbolp)
(let ((dv (assq form env))) ; dv = declared and visible
(when dv
(setf (nth 1 dv) t))))))
(define-obsolete-function-alias 'cconv-analyse-form 'cconv-analyze-form "25.1")
(provide 'cconv)
;;; cconv.el ends here

2
lisp/gnus/gnus-bookmark.el
View File

@ -251,7 +251,7 @@ So the cdr of each bookmark is an alist too.")
(interactive)
(save-excursion
(save-window-excursion
;; Avoir warnings?
;; Avoid warnings?
;; (message "Saving Gnus bookmarks to file %s..." gnus-bookmark-default-file)
(set-buffer (get-buffer-create " *Gnus bookmarks*"))
(erase-buffer)

2
lisp/org/org-table.el
View File

@ -2351,7 +2351,7 @@ For all numbers larger than LIMIT, shift them by DELTA."
(string-match "^[a-zA-Z][_a-zA-Z0-9]*$" field))
(push (cons field v) org-table-local-parameters)
(push (list field line col) org-table-named-field-locations))))
;; Analyse the line types
;; Analyze the line types.
(goto-char beg)
(setq org-table-current-begin-line (org-current-line)
org-table-current-begin-pos (point)

4
lisp/org/org.el
View File

@ -19148,7 +19148,7 @@ BEG and END default to the buffer boundaries."
(org-defkey org-mode-map "\C-c\M-f" 'org-next-block)
(org-defkey org-mode-map "\C-c\M-b" 'org-previous-block)
(org-defkey org-mode-map "\C-c$" 'org-archive-subtree)
(org-defkey org-mode-map "\C-c\C-x\C-s" 'org-advertized-archive-subtree)
(org-defkey org-mode-map "\C-c\C-x\C-s" 'org-archive-subtree)
(org-defkey org-mode-map "\C-c\C-x\C-a" 'org-archive-subtree-default)
(org-defkey org-mode-map "\C-c\C-xd" 'org-insert-drawer)
(org-defkey org-mode-map "\C-c\C-xa" 'org-toggle-archive-tag)
@ -20943,7 +20943,7 @@ on context. See the individual commands for more information."
("Archive"
["Archive (default method)" org-archive-subtree-default (org-in-subtree-not-table-p)]
"--"
["Move Subtree to Archive file" org-advertized-archive-subtree (org-in-subtree-not-table-p)]
["Move Subtree to Archive file" org-archive-subtree (org-in-subtree-not-table-p)]
["Toggle ARCHIVE tag" org-toggle-archive-tag (org-in-subtree-not-table-p)]
["Move subtree to Archive sibling" org-archive-to-archive-sibling (org-in-subtree-not-table-p)]
)

2
lisp/progmodes/idlwave.el
View File

@ -3713,7 +3713,7 @@ expression to enter.
The lines containing S1 and S2 are reindented using `indent-region'
unless the optional second argument NOINDENT is non-nil."
(if (derived-mode-p 'idlwave-shell-mode)
;; This is a gross hack to avoit template abbrev expansion
;; This is a gross hack to avoid template abbrev expansion
;; in the shell. FIXME: This is a dirty hack.
(if (and (eq this-command 'self-insert-command)
(equal last-abbrev-location (point)))

18
src/regex.c
View File

@ -515,7 +515,7 @@ init_syntax_once (void)
#define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
#ifndef emacs
#ifndef emacs
# undef max
# undef min
# define max(a, b) ((a) > (b) ? (a) : (b))
@ -1632,7 +1632,7 @@ static boolean at_begline_loc_p (re_char *pattern, re_char *p,
static boolean at_endline_loc_p (re_char *p, re_char *pend,
reg_syntax_t syntax);
static re_char *skip_one_char (re_char *p);
static int analyse_first (re_char *p, re_char *pend,
static int analyze_first (re_char *p, re_char *pend,
char *fastmap, const int multibyte);
/* Fetch the next character in the uncompiled pattern, with no
@ -2688,7 +2688,7 @@ regex_compile (const_re_char *pattern, size_t size, reg_syntax_t syntax,
size_t startoffset = 0;
re_opcode_t ofj =
/* Check if the loop can match the empty string. */
(simple || !analyse_first (laststart, b, NULL, 0))
(simple || !analyze_first (laststart, b, NULL, 0))
? on_failure_jump : on_failure_jump_loop;
assert (skip_one_char (laststart) <= b);
@ -2735,7 +2735,7 @@ regex_compile (const_re_char *pattern, size_t size, reg_syntax_t syntax,
GET_BUFFER_SPACE (7); /* We might use less. */
if (many_times_ok)
{
boolean emptyp = analyse_first (laststart, b, NULL, 0);
boolean emptyp = analyze_first (laststart, b, NULL, 0);
/* The non-greedy multiple match looks like
a repeat..until: we only need a conditional jump
@ -3836,7 +3836,7 @@ group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
return false;
}
/* analyse_first.
/* analyze_first.
If fastmap is non-NULL, go through the pattern and fill fastmap
with all the possible leading chars. If fastmap is NULL, don't
bother filling it up (obviously) and only return whether the
@ -3847,7 +3847,7 @@ group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
Return -1 if fastmap was not updated accurately. */
static int
analyse_first (const_re_char *p, const_re_char *pend, char *fastmap,
analyze_first (const_re_char *p, const_re_char *pend, char *fastmap,
const int multibyte)
{
int j, k;
@ -4089,7 +4089,7 @@ analyse_first (const_re_char *p, const_re_char *pend, char *fastmap,
{ /* We have to look down both arms.
We first go down the "straight" path so as to minimize
stack usage when going through alternatives. */
int r = analyse_first (p, pend, fastmap, multibyte);
int r = analyze_first (p, pend, fastmap, multibyte);
if (r) return r;
p += j;
}
@ -4139,7 +4139,7 @@ analyse_first (const_re_char *p, const_re_char *pend, char *fastmap,
/* We reached the end without matching anything. */
return 1;
} /* analyse_first */
} /* analyze_first */
/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible
@ -4169,7 +4169,7 @@ re_compile_fastmap (struct re_pattern_buffer *bufp)
memset (fastmap, 0, 1 << BYTEWIDTH); /* Assume nothing's valid. */
bufp->fastmap_accurate = 1; /* It will be when we're done. */
analysis = analyse_first (bufp->buffer, bufp->buffer + bufp->used,
analysis = analyze_first (bufp->buffer, bufp->buffer + bufp->used,
fastmap, RE_MULTIBYTE_P (bufp));
bufp->can_be_null = (analysis != 0);
return 0;