1994-01-08 Roland McGrath (roland@churchy.gnu.ai.mit.edu)
* configure.in (creating src/Makefile): Put code inside 2nd arg to
- AC_OUTPUT as it should be; hopefully noone will again see fit to
+ AC_OUTPUT as it should be; hopefully no one will again see fit to
gratuitously break this and not make a change log entry.
Optimized sed processing of Makefile.in and cpp output; now
preserves comments previously removed from the cpp input.
## $1 = program
## $2 = minimum version.
-## Return 0 if program is present with version >= minumum version.
+## Return 0 if program is present with version >= minimum version.
## Return 1 if program is missing.
## Return 2 if program is present but too old.
## Return 3 for unexpected error (eg failed to parse version).
use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
current notation to say that @code{x} is nonzero but not necessarily
real.) The @kbd{a e} command does ``unsafe'' simplifications,
-including cancelling @samp{x} from the equation when @samp{x} is
+including canceling @samp{x} from the equation when @samp{x} is
not known to be nonzero.
Another set of type symbols distinguish between scalars and vectors.
@end smallexample
Unselecting the sub-formula reveals that the minus sign, which would
-normally have cancelled out with the subtraction automatically, has
+normally have canceled out with the subtraction automatically, has
not been able to do so because the subtraction was not part of the
selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
any other mathematical operation on the whole formula will cause it
Quotients of products cancel only in the leading terms of the
numerator and denominator. In other words, @expr{a x b / a y b}
-is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once
+is canceled to @expr{x b / y b} but not to @expr{x / y}. Once
again this is because full cancellation can be slow; use @kbd{a s}
to cancel all terms of the quotient.
cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}.
(The terms in the denominator will then be rearranged to @expr{c d x}
as described above.) If there is any common integer or fractional
-factor in the numerator and denominator, it is cancelled out;
+factor in the numerator and denominator, it is canceled out;
for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
Non-constant common factors are not found even by @kbd{a s}. To
If the argument is multiplied by a constant, and this constant
has a common integer divisor with the modulus, then this factor is
-cancelled out. For example, @samp{12 x % 15} is changed to
+canceled out. For example, @samp{12 x % 15} is changed to
@samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
not seem ``simpler,'' they allow Calc to discover useful information
\bigskip
@end tex
-Equations and inequalities are simplified by cancelling factors
+Equations and inequalities are simplified by canceling factors
of products, quotients, or sums on both sides. Inequalities
-change sign if a negative multiplicative factor is cancelled.
+change sign if a negative multiplicative factor is canceled.
Non-constant multiplicative factors as in @expr{a b = a c} are
-cancelled from equations only if they are provably nonzero (generally
+canceled from equations only if they are provably nonzero (generally
because they were declared so; @pxref{Declarations}). Factors
-are cancelled from inequalities only if they are nonzero and their
+are canceled from inequalities only if they are nonzero and their
sign is known.
Simplification also replaces an equation or inequality with
unsafe because of problems with principal values (although these
simplifications are safe if @expr{x} is known to be real).
-Common factors are cancelled from products on both sides of an
+Common factors are canceled from products on both sides of an
equation, even if those factors may be zero: @expr{a x / b x}
-to @expr{a / b}. Such factors are never cancelled from
+to @expr{a / b}. Such factors are never canceled from
inequalities: Even @kbd{a e} is not bold enough to reduce
@expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
on whether you believe @expr{x} is positive or negative).
which the first argument is a number which is out of range for the
leading unit are modified accordingly.
-When cancelling and combining units in products and quotients,
+When canceling and combining units in products and quotients,
Calc accounts for unit names that differ only in the prefix letter.
For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
However, compatible but different units like @code{ft} and @code{in}
corresponding source code or DocLib header will be used as the help
text.
-@cindex Completion, cancelling
-@cindex Cancelling completion
+@cindex Completion, canceling
+@cindex Canceling completion
Completion is not a blocking operation --- you are free to continue
editing, enter commands, or simply ignore the @file{*Completions*}
buffer during a completion operation. If, however, the most recent
Hallvard B Furuseth <h.b.furuseth@@usit.uio.no> writes:
@end example
-@c FIXME: Add `message-insert-formated-citation-line' and
+@c FIXME: Add `message-insert-formatted-citation-line' and
@c `message-citation-line-format'
Point will be at the beginning of the body of the message when this
@tab Should sorting be case-sensitive? Default @code{nil}.
@item @code{:sitemap-file-entry-format}
-@tab With this option one can tell how a sitemap's entry is formated in the
+@tab With this option one can tell how a sitemap's entry is formatted in the
sitemap. This is a format string with some escape sequences: @code{%t} stands
for the title of the file, @code{%a} stands for the author of the file and
@code{%d} stands for the date of the file. The date is retrieved with the
-@code{org-publish-find-date} function and formated with
+@code{org-publish-find-date} function and formatted with
@code{org-publish-sitemap-date-format}. Default @code{%t}.
@item @code{:sitemap-date-format}
@tab Format string for the @code{format-time-string} function that tells how
-a sitemap entry's date is to be formated. This property bypasses
+a sitemap entry's date is to be formatted. This property bypasses
@code{org-publish-sitemap-date-format} which defaults to @code{%Y-%m-%d}.
@item @code{:sitemap-sans-extension}
@c host and then send commands to it.
@c * Use `filename' resp. `file name' consistently.
@c * Use `host' resp. `machine' consistently.
-@c * Consistent small or capitalized words especially in menues.
+@c * Consistent small or capitalized words especially in menus.
So that such output processing may be done efficiently, there is a new
variable, comint-last-output-start, that records the position of the start of
-the lastest output inserted into the buffer (effectively the previous value
+the last output inserted into the buffer (effectively the previous value
of process-mark). Output processing functions should process the text
between comint-last-output-start (or perhaps the beginning of the line that
the position lies on) and process-mark.
*** image-type-header-regexps priorities the jpeg loader over the
ImageMagick one. This is not wrong, but how should a user go about
-prefering the ImageMagick loader? The user might like zooming etc in jpegs.
+preferring the ImageMagick loader? The user might like zooming etc in jpegs.
Try (setq image-type-header-regexps nil) for a quick hack to prefer
ImageMagick over the jpg loader.
bind "p"
template priority :blank
-"Insert a priority statemept."
+"Insert a priority statement."
----
set priority $^$
----
template application :blank
-"Insert a priority statemept."
+"Insert an application statement."
----
set application "$^$"
----
1998-07-21 Kenichi Handa <handa@etl.go.jp>
* quail/japanese.el (quail-japanese-kanji-kkc): Handle the case
- that conversion is cancelled in kkc-region.
+ that conversion is canceled in kkc-region.
(quail-japanese-switch-package): Fix previous change.
1998-07-19 Kenichi Handa <handa@etl.go.jp>
(quail-mode-map): Change binding for ethio-insert-ethio-space.
(quail-mode-hook): Check the current Quail package name.
- * quail/latin-post.el: Add rules for cancelling accents by typing
+ * quail/latin-post.el: Add rules for canceling accents by typing
two accent keys (e.g. a~ => a-tilde, a~~ => a~) to all Quail
packages.
theta Q q
iota I i
kappa K k
-lamda L l
+lambda L l
mu M m
nu N n
xi X x
theta J j
iota I i
kappa K k
-lamda L l
+lambda L l
mu M m
nu N n
xi X x
2006-08-20 Chong Yidong <cyd@stupidchicken.com>
* frame.el (blink-cursor-start): Set timer first.
- (blink-cursor-end): Ignore timer cancelling errors.
+ (blink-cursor-end): Ignore timer canceling errors.
Suggested by Ken Manheimer.
2006-08-20 Juanma Barranquero <lekktu@gmail.com>
interactive spec from "p" to "P".
* progmodes/cc-styles.el: Amend the doc-string of c-set-style, in
- reponse to a report from Joseph Kiniry <kiniry@acm.org> that it
+ response to a report from Joseph Kiniry <kiniry@acm.org> that it
was difficult to understand.
2005-12-08 Martin Stjernholm <bug-cc-mode@gnu.org>
2007-10-31 Juanma Barranquero <lekktu@gmail.com>
* help-at-pt.el (help-at-pt-unload-hook): Remove.
- Timers are automatically cancelled by `unload-feature'.
+ Timers are automatically canceled by `unload-feature'.
* delsel.el (delsel-unload-hook): Remove function and variable.
(delsel-unload-function): New-style unload function, adapted
* calc/calc-embed.el (calc-embedded-restore-original-modes):
Add argument for Calculator buffer.
- (calc-do-embedded): Use specific Calculator buffer when cancelling
+ (calc-do-embedded): Use specific Calculator buffer when canceling
embedded mode.
* calc/calc.el (calc-buffer-list): New variable.
(sql-mode-oracle-font-lock-keywords): Improve SQL*Plus REMARK
syntax pattern.
(sql-mode-postgres-font-lock-keywords): Support Postgres V9.
- (sql-mode-sqlite-font-lock-keywords): Hilight sqlite commands.
+ (sql-mode-sqlite-font-lock-keywords): Highlight sqlite commands.
2010-09-10 Lars Magne Ingebrigtsen <larsi@gnus.org>
Add new VC methods: vc-log-incoming and vc-log-outgoing.
* vc.el (vc-print-log-setup-buttons): New function split out from
vc-print-log-internal.
- (vc-log-internal-common): New function, a parametrized version of
+ (vc-log-internal-common): New function, a parameterized version of
vc-print-log-internal.
(vc-print-log-internal): Just call vc-log-internal-common with the
right arguments.
to "Non-echoed text: ". This conforms with the convention
used by existing prompts, and gives more room to type stuff.
- * comint.el (comint-last-input-start): New varible. In
+ * comint.el (comint-last-input-start): New variable. In
particular, this helps support subprocesses that insist on echoing
their input. Added comments to porting guide indicating that
this should probably not be used for implementing history stuff.
1998-07-21 Kenichi Handa <handa@etl.go.jp>
* international/kkc.el (kkc-region): Handled the case that
- conversion is cancelled.
+ conversion is canceled.
(kkc-terminate): Update kkc-overlay-head correctly.
(kkc-cancel): Don't call kkc-terminate, but set kkc-converting to nil.
(defvar calc-arithmetic-menu
(list "Arithmetic"
(list "Basic"
- ["-(1:)" calc-change-sign
+ ["-(1:)" calc-change-sign
:keys "n" :active (>= (calc-stack-size) 1)]
- ["(2:) + (1:)" calc-plus
+ ["(2:) + (1:)" calc-plus
:keys "+" :active (>= (calc-stack-size) 2)]
- ["(2:) - (1:)" calc-minus
+ ["(2:) - (1:)" calc-minus
:keys "-" :active (>= (calc-stack-size) 2)]
- ["(2:) * (1:)" calc-times
+ ["(2:) * (1:)" calc-times
:keys "*" :active (>= (calc-stack-size) 2)]
- ["(2:) / (1:)" calc-divide
+ ["(2:) / (1:)" calc-divide
:keys "/" :active (>= (calc-stack-size) 2)]
- ["(2:) ^ (1:)" calc-power
+ ["(2:) ^ (1:)" calc-power
:keys "^" :active (>= (calc-stack-size) 2)]
- ["(2:) ^ (1/(1:))"
+ ["(2:) ^ (1/(1:))"
(progn
(require 'calc-ext)
(let ((calc-inverse-flag t))
:keys "I ^"
:active (>= (calc-stack-size) 2)
:help "The (1:)th root of (2:)"]
- ["abs(1:)"
- (progn
+ ["abs(1:)"
+ (progn
(require 'calc-arith)
(call-interactively 'calc-abs))
:keys "A"
(call-interactively 'calc-inv))
:keys "&"
:active (>= (calc-stack-size) 1)]
- ["sqrt(1:)"
+ ["sqrt(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-sqrt))
:keys "\\"
:active (>= (calc-stack-size) 2)
:help "The integer quotient of (2:) over (1:)"]
- ["(2:) mod (1:)"
+ ["(2:) mod (1:)"
(progn
(require 'calc-misc)
(call-interactively 'calc-mod))
:active (>= (calc-stack-size) 2)
:help "The remainder when (2:) is divided by (1:)"])
(list "Rounding"
- ["floor(1:)"
+ ["floor(1:)"
(progn
(require 'calc-arith)
(call-interactively 'calc-floor))
:keys "F"
:active (>= (calc-stack-size) 1)
:help "The greatest integer less than or equal to (1:)"]
- ["ceiling(1:)"
+ ["ceiling(1:)"
(progn
(require 'calc-arith)
(call-interactively 'calc-ceiling))
:keys "I F"
:active (>= (calc-stack-size) 1)
:help "The smallest integer greater than or equal to (1:)"]
- ["round(1:)"
+ ["round(1:)"
(progn
(require 'calc-arith)
(call-interactively 'calc-round))
:keys "R"
:active (>= (calc-stack-size) 1)
:help "The nearest integer to (1:)"]
- ["truncate(1:)"
+ ["truncate(1:)"
(progn
(require 'calc-arith)
(call-interactively 'calc-trunc))
:active (>= (calc-stack-size) 1)
:help "The argument (polar angle) of (1:)"])
(list "Conversion"
- ["Convert (1:) to a float"
+ ["Convert (1:) to a float"
(progn
(require 'calc-ext)
(call-interactively 'calc-float))
:keys "c f"
:active (>= (calc-stack-size) 1)]
- ["Convert (1:) to a fraction"
+ ["Convert (1:) to a fraction"
(progn
(require 'calc-ext)
(call-interactively 'calc-fraction))
:keys "c F"
:active (>= (calc-stack-size) 1)])
(list "Binary"
- ["Set word size"
+ ["Set word size"
(progn
(require 'calc-bin)
(call-interactively 'calc-word-size))
:keys "b w"]
- ["Clip (1:) to word size"
+ ["Clip (1:) to word size"
(progn
(require 'calc-bin)
(call-interactively 'calc-clip))
:keys "b c"
:active (>= (calc-stack-size) 1)
:help "Reduce (1:) modulo 2^wordsize"]
- ["(2:) and (1:)"
+ ["(2:) and (1:)"
(progn
(require 'calc-bin)
(call-interactively 'calc-and))
:active (>= (calc-stack-size) 2)
:help "Bitwise inclusive OR [modulo 2^wordsize]"]
["(2:) xor (1:)"
- (progn
+ (progn
(require 'calc-bin)
(call-interactively 'calc-xor))
:keys "b x"
:active (>= (calc-stack-size) 2)
:help "Bitwise exclusive OR [modulo 2^wordsize]"]
- ["diff(2:,1:)"
+ ["diff(2:,1:)"
(progn
(require 'calc-bin)
(call-interactively 'calc-diff))
:keys "I P"
:help "Euler's constant"])
(list "Logs and Exps"
- ["ln(1:)"
- (progn
- (require 'calc-math)
- (call-interactively 'calc-ln))
+ ["ln(1:)"
+ (progn
+ (require 'calc-math)
+ (call-interactively 'calc-ln))
:keys "L"
:active (>= (calc-stack-size) 1)
:help "The natural logarithm"]
- ["e^(1:)"
+ ["e^(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-exp))
:keys "E"
:active (>= (calc-stack-size) 1)]
- ["log(1:) [base 10]"
+ ["log(1:) [base 10]"
(progn
(require 'calc-math)
(call-interactively 'calc-log10))
:keys "H L"
:active (>= (calc-stack-size) 1)
:help "The common logarithm"]
- ["10^(1:)"
+ ["10^(1:)"
(progn
(require 'calc-math)
(let ((calc-inverse-flag t))
(call-interactively 'calc-log10)))
:keys "I H L"
:active (>= (calc-stack-size) 1)]
- ["log(2:) [base(1:)]"
+ ["log(2:) [base(1:)]"
(progn
(require 'calc-math)
(call-interactively 'calc-log))
:keys "B"
:active (>= (calc-stack-size) 2)
:help "The logarithm with an arbitrary base"]
- ["(2:) ^ (1:)"
- calc-power
+ ["(2:) ^ (1:)"
+ calc-power
:keys "^"
:active (>= (calc-stack-size) 2)])
(list "Trigonometric Functions"
- ["sin(1:)"
+ ["sin(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-sin))
:keys "S"
:active (>= (calc-stack-size) 1)]
- ["cos(1:)"
+ ["cos(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-cos))
:keys "C"
:active (>= (calc-stack-size) 1)]
- ["tan(1:)"
+ ["tan(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-tan))
:keys "T"
:active (>= (calc-stack-size) 1)]
- ["arcsin(1:)"
+ ["arcsin(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-arcsin))
:keys "I S"
:active (>= (calc-stack-size) 1)]
- ["arccos(1:)"
+ ["arccos(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-arccos))
:keys "I C"
:active (>= (calc-stack-size) 1)]
- ["arctan(1:)"
+ ["arctan(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-arctan))
:keys "I T"
:active (>= (calc-stack-size) 1)]
- ["arctan2(2:,1:)"
+ ["arctan2(2:,1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-arctan2))
:style radio
:selected (eq calc-angle-mode 'hms)])
(list "Hyperbolic Functions"
- ["sinh(1:)"
+ ["sinh(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-sinh))
:keys "H S"
:active (>= (calc-stack-size) 1)]
- ["cosh(1:)"
+ ["cosh(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-cosh))
:keys "H C"
:active (>= (calc-stack-size) 1)]
- ["tanh(1:)"
+ ["tanh(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-tanh))
:keys "H T"
:active (>= (calc-stack-size) 1)]
- ["arcsinh(1:)"
+ ["arcsinh(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-arcsinh))
:keys "I H S"
:active (>= (calc-stack-size) 1)]
- ["arccosh(1:)"
+ ["arccosh(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-arccosh))
:keys "I H C"
:active (>= (calc-stack-size) 1)]
- ["arctanh(1:)"
+ ["arctanh(1:)"
(progn
(require 'calc-math)
(call-interactively 'calc-arctanh))
:keys "I H T"
:active (>= (calc-stack-size) 1)])
(list "Advanced Math Functions"
- ["Gamma(1:)"
+ ["Gamma(1:)"
(progn
(require 'calc-comb)
(call-interactively 'calc-gamma))
:keys "f g"
:active (>= (calc-stack-size) 1)
:help "The Euler Gamma function"]
- ["GammaP(2:,1:)"
+ ["GammaP(2:,1:)"
(progn
(require 'calc-funcs)
(call-interactively 'calc-inc-gamma))
:keys "f G"
:active (>= (calc-stack-size) 2)
:help "The lower incomplete Gamma function"]
- ["Beta(2:,1:)"
+ ["Beta(2:,1:)"
(progn
(require 'calc-funcs)
(call-interactively 'calc-beta))
:keys "f b"
:active (>= (calc-stack-size) 2)
:help "The Euler Beta function"]
- ["BetaI(3:,2:,1:)"
+ ["BetaI(3:,2:,1:)"
(progn
(require 'calc-funcs)
(call-interactively 'calc-inc-beta))
:keys "f e"
:active (>= (calc-stack-size) 1)
:help "The error function"]
- ["BesselJ(2:,1:)"
+ ["BesselJ(2:,1:)"
(progn
(require 'calc-funcs)
(call-interactively 'calc-bessel-J))
:keys "f j"
:active (>= (calc-stack-size) 2)
:help "The Bessel function of the first kind (of order (2:))"]
- ["BesselY(2:,1:)"
+ ["BesselY(2:,1:)"
(progn
(require 'calc-funcs)
(call-interactively 'calc-bessel-Y))
:active (>= (calc-stack-size) 2)
:help "The Bessel function of the second kind (of order (2:))"])
(list "Combinatorial Functions"
- ["gcd(2:,1:)"
+ ["gcd(2:,1:)"
(progn
(require 'calc-comb)
(call-interactively 'calc-gcd))
:keys "k g"
:active (>= (calc-stack-size) 2)]
- ["lcm(2:,1:)"
+ ["lcm(2:,1:)"
(progn
(require 'calc-comb)
(call-interactively 'calc-lcm))
:keys "k l"
:active (>= (calc-stack-size) 2)]
- ["factorial(1:)"
+ ["factorial(1:)"
(progn
(require 'calc-comb)
(call-interactively 'calc-factorial))
:keys "!"
:active (>= (calc-stack-size) 1)]
- ["(2:) choose (1:)"
+ ["(2:) choose (1:)"
(progn
(require 'calc-comb)
(call-interactively 'calc-choose))
:keys "k c"
:active (>= (calc-stack-size) 2)]
- ["permutations(2:,1:)"
+ ["permutations(2:,1:)"
(progn
(require 'calc-comb)
(call-interactively 'calc-perm))
:keys "H k c"
:active (>= (calc-stack-size) 2)]
- ["Primality test for (1:)"
+ ["Primality test for (1:)"
(progn
(require 'calc-comb)
(call-interactively 'calc-prime-test))
:keys "k p"
:active (>= (calc-stack-size) 1)
:help "For large (1:), a probabilistic test"]
- ["Factor (1:) into primes"
+ ["Factor (1:) into primes"
(progn
(require 'calc-comb)
(call-interactively 'calc-prime-factors))
["Help on Scientific Functions"
(calc-info-goto-node "Scientific Functions")])
"Menu for Calc's scientific functions.")
-
+
(defvar calc-algebra-menu
(list "Algebra"
(list "Simplification"
- ["Simplify (1:)"
+ ["Simplify (1:)"
(progn
(require 'calc-alg)
(call-interactively 'calc-simplify))
:keys "a s"
:active (>= (calc-stack-size) 1)]
- ["Simplify (1:) with extended rules"
+ ["Simplify (1:) with extended rules"
(progn
(require 'calc-alg)
(call-interactively 'calc-simplify-extended))
:active (>= (calc-stack-size) 1)
:help "Apply possibly unsafe simplifications"])
(list "Manipulation"
- ["Expand formula (1:)"
+ ["Expand formula (1:)"
(progn
(require 'calc-alg)
(call-interactively 'calc-expand-formula))
:keys "a \""
:active (>= (calc-stack-size) 1)
:help "Expand (1:) into its defining formula, if possible"]
- ["Evaluate variables in (1:)"
+ ["Evaluate variables in (1:)"
(progn
(require 'calc-ext)
(call-interactively 'calc-evaluate))
:keys "="
:active (>= (calc-stack-size) 1)]
- ["Make substitution in (1:)"
+ ["Make substitution in (1:)"
(progn
(require 'calc-alg)
(call-interactively 'calc-substitute))
:keys "a b"
:active (>= (calc-stack-size) 1)
- :help
+ :help
"Substitute all occurrences of a sub-expression with a new sub-expression"])
(list "Polynomials"
- ["Factor (1:)"
+ ["Factor (1:)"
(progn
(require 'calc-alg)
(call-interactively 'calc-factor))
:keys "a f"
:active (>= (calc-stack-size) 1)]
- ["Collect terms in (1:)"
+ ["Collect terms in (1:)"
(progn
(require 'calc-alg)
- (call-interactively 'calc-collect))
+ (call-interactively 'calc-collect))
:keys "a c"
:active (>= (calc-stack-size) 1)
:help "Arrange as a polynomial in a given variable"]
- ["Expand (1:)"
+ ["Expand (1:)"
(progn
(require 'calc-alg)
(call-interactively 'calc-expand))
:keys "a x"
:active (>= (calc-stack-size) 1)
:help "Apply distributive law everywhere"]
- ["Find roots of (1:)"
+ ["Find roots of (1:)"
(progn
(require 'calcalg2)
(call-interactively 'calc-poly-roots))
:keys "a P"
:active (>= (calc-stack-size) 1)])
(list "Calculus"
- ["Differentiate (1:)"
+ ["Differentiate (1:)"
(progn
(require 'calcalg2)
(call-interactively 'calc-derivative))
:keys "a d"
:active (>= (calc-stack-size) 1)]
- ["Integrate (1:) [indefinite]"
+ ["Integrate (1:) [indefinite]"
(progn
(require 'calcalg2)
(call-interactively 'calc-integral))
:keys "a i"
:active (>= (calc-stack-size) 1)]
- ["Integrate (1:) [definite]"
+ ["Integrate (1:) [definite]"
(progn
(require 'calcalg2)
(let ((var (read-string "Integration variable: ")))
- (calc-tabular-command 'calcFunc-integ "Integration"
+ (calc-tabular-command 'calcFunc-integ "Integration"
"intg" nil var nil nil)))
:keys "C-u a i"
:active (>= (calc-stack-size) 1)]
:keys "a I"
:active (>= (calc-stack-size) 1)
:help "Integrate using the open Romberg method"]
- ["Taylor expand (1:)"
+ ["Taylor expand (1:)"
(progn
(require 'calcalg2)
(call-interactively 'calc-taylor))
:keys "a t"
:active (>= (calc-stack-size) 1)]
- ["Minimize (2:) [initial guess = (1:)]"
+ ["Minimize (2:) [initial guess = (1:)]"
(progn
(require 'calcalg3)
(call-interactively 'calc-find-minimum))
:keys "a N"
:active (>= (calc-stack-size) 2)
:help "Find a local minimum"]
- ["Maximize (2:) [initial guess = (1:)]"
+ ["Maximize (2:) [initial guess = (1:)]"
(progn
(require 'calcalg3)
(call-interactively 'calc-find-maximum))
:active (>= (calc-stack-size) 2)
:help "Find a local maximum"])
(list "Solving"
- ["Solve equation (1:)"
+ ["Solve equation (1:)"
(progn
(require 'calcalg2)
(call-interactively 'calc-solve-for))
:keys "a S"
:active (>= (calc-stack-size) 1)]
- ["Solve equation (2:) numerically [initial guess = (1:)]"
+ ["Solve equation (2:) numerically [initial guess = (1:)]"
(progn
(require 'calcalg3)
(call-interactively 'calc-find-root))
:keys "a R"
:active (>= (calc-stack-size) 2)]
- ["Find roots of polynomial (1:)"
+ ["Find roots of polynomial (1:)"
(progn
(require 'calcalg2)
(call-interactively 'calc-poly-roots))
:keys "a P"
:active (>= (calc-stack-size) 1)])
(list "Curve Fitting"
- ["Fit (1:)=[x values, y values] to a curve"
+ ["Fit (1:)=[x values, y values] to a curve"
(progn
(require 'calcalg3)
(call-interactively 'calc-curve-fit))
(defvar calc-graphics-menu
(list "Graphics"
- ["Graph 2D [(1:)= y values, (2:)= x values]"
+ ["Graph 2D [(1:)= y values, (2:)= x values]"
(progn
(require 'calc-graph)
(call-interactively 'calc-graph-fast))
:keys "g f"
:active (>= (calc-stack-size) 2)]
- ["Graph 3D [(1:)= z values, (2:)= y values, (3:)= x values]"
+ ["Graph 3D [(1:)= z values, (2:)= y values, (3:)= x values]"
(progn
(require 'calc-graph)
(call-interactively 'calc-graph-fast-3d))
(defvar calc-vectors-menu
(list "Matrices/Vectors"
(list "Matrices"
- ["(2:) + (1:)" calc-plus
+ ["(2:) + (1:)" calc-plus
:keys "+" :active (>= (calc-stack-size) 2)]
- ["(2:) - (1:)" calc-minus
+ ["(2:) - (1:)" calc-minus
:keys "-" :active (>= (calc-stack-size) 2)]
- ["(2:) * (1:)" calc-times
+ ["(2:) * (1:)" calc-times
:keys "*" :active (>= (calc-stack-size) 2)]
["(1:)^(-1)"
(progn
:keys "&"
:active (>= (calc-stack-size) 1)]
["Create an identity matrix"
- (progn
+ (progn
(require 'calc-vec)
(call-interactively 'calc-ident))
:keys "v i"]
- ["transpose(1:)"
+ ["transpose(1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-transpose))
:keys "v t"
:active (>= (calc-stack-size) 1)]
- ["det(1:)"
+ ["det(1:)"
(progn
(require 'calc-mtx)
(call-interactively 'calc-mdet))
(call-interactively 'calc-mtrace))
:keys "V T"
:active (>= (calc-stack-size) 1)]
- ["LUD decompose (1:)"
+ ["LUD decompose (1:)"
(progn
(require 'calc-mtx)
(call-interactively 'calc-mlud))
:keys "V L"
:active (>= (calc-stack-size) 1)]
- ["Extract a row from (1:)"
+ ["Extract a row from (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-mrow))
:keys "v r"
:active (>= (calc-stack-size) 1)]
- ["Extract a column from (1:)"
+ ["Extract a column from (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-mcol))
(call-interactively 'calc-head))
:keys "v h"
:active (>= (calc-stack-size) 1)]
- ["Extract an element from (1:)"
+ ["Extract an element from (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-mrow))
:keys "v r"
:active (>= (calc-stack-size) 1)]
- ["Reverse (1:)"
+ ["Reverse (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-reverse-vector))
:keys "v u"
:active (>= (calc-stack-size) 1)
:help "Separate the elements of (1:)"]
- ["(2:) cross (1:)"
+ ["(2:) cross (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-cross))
:keys "V C"
:active (>= (calc-stack-size) 2)
:help "The cross product in R^3"]
- ["(2:) dot (1:)"
- calc-mult
+ ["(2:) dot (1:)"
+ calc-mult
:keys "*"
:active (>= (calc-stack-size) 2)
:help "The dot product"]
- ["Map a function across (1:)"
+ ["Map a function across (1:)"
(progn
(require 'calc-map)
(call-interactively 'calc-map))
:active (>= (calc-stack-size) 1)
:help "Apply a function to each element"])
(list "Vectors As Sets"
- ["Remove duplicates from (1:)"
+ ["Remove duplicates from (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-remove-duplicates))
:keys "V +"
:active (>= (calc-stack-size) 1)]
- ["(2:) union (1:)"
+ ["(2:) union (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-set-union))
:keys "V V"
:active (>= (calc-stack-size) 2)]
- ["(2:) intersect (1:)"
+ ["(2:) intersect (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-set-intersect))
:keys "V ^"
:active (>= (calc-stack-size) 2)]
- ["(2:) \\ (1:)"
+ ["(2:) \\ (1:)"
(progn
(require 'calc-vec)
(call-interactively 'calc-set-difference))
:help "Set difference"
:active (>= (calc-stack-size) 2)])
(list "Statistics On Vectors"
- ["length(1:)"
+ ["length(1:)"
(progn
(require 'calc-stat)
(call-interactively 'calc-vector-count))
:keys "u #"
:active (>= (calc-stack-size) 1)
:help "The number of data values"]
- ["sum(1:)"
+ ["sum(1:)"
(progn
(require 'calc-stat)
(call-interactively 'calc-vector-sum))
:keys "u +"
:active (>= (calc-stack-size) 1)
:help "The sum of the data values"]
- ["max(1:)"
+ ["max(1:)"
(progn
(require 'calc-stat)
- (call-interactively 'calc-vector-max))
+ (call-interactively 'calc-vector-max))
:keys "u x"
:active (>= (calc-stack-size) 1)
:help "The maximum of the data values"]
- ["min(1:)"
+ ["min(1:)"
(progn
(require 'calc-stat)
- (call-interactively 'calc-vector-min))
+ (call-interactively 'calc-vector-min))
:keys "u N"
:active (>= (calc-stack-size) 1)
- :help "The minumum of the data values"]
- ["mean(1:)"
+ :help "The minimum of the data values"]
+ ["mean(1:)"
(progn
(require 'calc-stat)
(call-interactively 'calc-vector-mean))
:keys "I u M"
:active (>= (calc-stack-size) 1)
:help "The average (arithmetic mean) of the data values as an error form"]
- ["sdev(1:)"
+ ["sdev(1:)"
(progn
(require 'calc-stat)
(call-interactively 'calc-vector-sdev))
:keys "u S"
:active (>= (calc-stack-size) 1)
:help "The sample sdev, sqrt[sum((values - mean)^2)/(N-1)]"]
- ["variance(1:)"
+ ["variance(1:)"
(progn
(require 'calc-stat)
(call-interactively 'calc-vector-variance))
:keys "H u S"
:active (>= (calc-stack-size) 1)
:help "The sample variance, sum((values - mean)^2)/(N-1)"]
- ["population sdev(1:)"
+ ["population sdev(1:)"
(progn
(require 'calc-stat)
(call-interactively 'calc-vector-pop-sdev))
:keys "I u S"
:active (>= (calc-stack-size) 1)
:help "The population sdev, sqrt[sum((values - mean)^2)/N]"]
- ["population variance(1:)"
+ ["population variance(1:)"
(progn
(require 'calc-stat)
(call-interactively 'calc-vector-pop-variance))
(defvar calc-units-menu
(list "Units"
- ["Convert units in (1:)"
+ ["Convert units in (1:)"
(progn
(require 'calc-units)
(call-interactively 'calc-convert-units ))
:keys "u c"
:active (>= (calc-stack-size) 1)]
- ["Convert temperature in (1:)"
+ ["Convert temperature in (1:)"
(progn
(require 'calc-units)
(call-interactively 'calc-convert-temperature))
:keys "u t"
:active (>= (calc-stack-size) 1)]
- ["Simplify units in (1:)"
+ ["Simplify units in (1:)"
(progn
(require 'calc-units)
(call-interactively 'calc-simplify-units))
:keys "u s"
:active (>= (calc-stack-size) 1)]
- ["View units table"
+ ["View units table"
(progn
(require 'calc-units)
(call-interactively 'calc-view-units-table))
(defvar calc-variables-menu
(list "Variables"
- ["Store (1:) into a variable"
+ ["Store (1:) into a variable"
(progn
(require 'calc-store)
(call-interactively 'calc-store))
:keys "s s"
:active (>= (calc-stack-size) 1)]
- ["Recall a variable value"
+ ["Recall a variable value"
(progn
(require 'calc-store)
(call-interactively 'calc-recall ))
:keys "s r"]
- ["Edit the value of a variable"
+ ["Edit the value of a variable"
(progn
(require 'calc-store)
(call-interactively 'calc-edit-variable))
:keys "s e"]
- ["Exchange (1:) with a variable value"
+ ["Exchange (1:) with a variable value"
(progn
(require 'calc-store)
(call-interactively 'calc-store-exchange))
:keys "s x"
:active (>= (calc-stack-size) 1)]
- ["Clear variable value"
+ ["Clear variable value"
(progn
(require 'calc-store)
(call-interactively 'calc-unstore))
:keys "s u"]
- ["Evaluate variables in (1:)"
+ ["Evaluate variables in (1:)"
(progn
(require 'calc-ext)
(call-interactively 'calc-evaluate))
:keys "="
:active (>= (calc-stack-size) 1)]
- ["Evaluate (1:), assigning a value to a variable"
+ ["Evaluate (1:), assigning a value to a variable"
(progn
(require 'calc-store)
(call-interactively 'calc-let))
(defvar calc-stack-menu
(list "Stack"
- ["Remove (1:)"
- calc-pop
+ ["Remove (1:)"
+ calc-pop
:keys "DEL"
:active (>= (calc-stack-size) 1)]
- ["Switch (1:) and (2:)"
- calc-roll-down
+ ["Switch (1:) and (2:)"
+ calc-roll-down
:keys "TAB"
:active (>= (calc-stack-size) 2)]
- ["Duplicate (1:)"
- calc-enter
+ ["Duplicate (1:)"
+ calc-enter
:keys "RET"
:active (>= (calc-stack-size) 1)]
- ["Edit (1:)"
+ ["Edit (1:)"
(progn
(require 'calc-yank)
(call-interactively calc-edit))
(defvar calc-errors-menu
(list "Undo"
- ["Undo"
+ ["Undo"
(progn
(require 'calc-undo)
(call-interactively 'calc-undo))
:keys "U"]
- ["Redo"
+ ["Redo"
(progn
(require 'calc-undo)
(call-interactively 'calc-redo))
(defvar calc-modes-menu
(list "Modes"
- ["Precision"
+ ["Precision"
(progn
(require 'calc-ext)
(call-interactively 'calc-precision))
["Binary"
(progn
(require 'calc-bin)
- (call-interactively
+ (call-interactively
(lambda () (interactive) (calc-binary-radix t))))
:keys "C-u d 2"
:style radio
:keys "d e"
:style radio
:selected (eq (car-safe calc-float-format) 'eng)])
- (list "Complex Format"
+ (list "Complex Format"
["Default"
(progn
(require 'calc-cplx)
(defvar calc-help-menu
(list "Help"
- ["Manual"
+ ["Manual"
calc-info
:keys "h i"]
- ["Tutorial"
- calc-tutorial
+ ["Tutorial"
+ calc-tutorial
:keys "h t"]
- ["Summary"
- calc-info-summary
+ ["Summary"
+ calc-info-summary
:keys "h s"]
"----"
- ["Help on Help"
+ ["Help on Help"
(progn
(calc-info-goto-node "Introduction")
(Info-goto-node "Help Commands"))])
calc-errors-menu
calc-modes-menu
calc-help-menu
- ["Reset"
+ ["Reset"
(progn
(require 'calc-ext)
(call-interactively 'calc-reset))
["Quit" calc-quit]))
(provide 'calc-menu)
-
val))
val))))))))
-;;; The Calc set- and get-register commands are modified versions of functions
+;;; The Calc set- and get-register commands are modified versions of functions
;;; in register.el
(defvar calc-register-alist nil
(defun calc-add-to-register (register start end prepend delete-flag)
"Add the lines in the region to register REGISTER.
-If PREPEND is non-nil, add them to the beginning of the register,
+If PREPEND is non-nil, add them to the beginning of the register,
otherwise the end. If DELETE-FLAG is non-nil, also delete the region."
(let* ((top-num (calc-locate-cursor-element start))
(top-pos (save-excursion
(if (eq major-mode 'calc-mode)
(calc-add-to-register register start end nil delete-flag)
(append-to-register register start end delete-flag)))
-
+
(defun calc-prepend-to-register (register start end &optional delete-flag)
"Copy the lines in the region to the beginning of register REGISTER.
With prefix arg, also delete the region."
(if (eq major-mode 'calc-mode)
(calc-add-to-register register start end t delete-flag)
(prepend-to-register register start end delete-flag)))
-
+
(defun calc-clean-newlines (s)
(setq calc-allow-ret allow-ret)
(let ((inhibit-read-only t))
(erase-buffer))
- (add-hook 'kill-buffer-hook (lambda ()
+ (add-hook 'kill-buffer-hook (lambda ()
(let ((calc-edit-handler nil))
(calc-edit-finish t))
(message "(Cancelled)")) t t)
(insert (propertize
- (concat
+ (concat
(or title title "Calc Edit Mode. ")
"Press `C-c C-c'"
(if allow-ret "" " or RET")
(defcustom calculator-prompt "Calc=%s> "
"The prompt used by the Emacs calculator.
-It should contain a \"%s\" somewhere that will indicate the i/o radixes;
+It should contain a \"%s\" somewhere that will indicate the i/o radices;
this will be a two-character string as described in the documentation
for `calculator-mode'."
:type 'string
Optional argument WARNTIME is an integer (or string) giving the number
of minutes before the appointment at which to start warning.
The default is `appt-message-warning-time'."
- (interactive "sTime (hh:mm[am/pm]): \nsMessage:
+ (interactive "sTime (hh:mm[am/pm]): \nsMessage:
sMinutes before the appointment to start warning: ")
(unless (string-match appt-time-regexp time)
(error "Unacceptable time-string"))
(or appt-timer (appt-activate))
(let ((time-msg (list (list (appt-convert-time time))
(concat time " " msg) t)))
- ;; It is presently non-sensical to have multiple warnings about
+ ;; It is presently nonsensical to have multiple warnings about
;; the same appointment with just different delays, but it might
;; not always be so. TODO
(if warntime (setq time-msg (append time-msg (list warntime))))
(= v1-1 v2-1)
(= v1-2 v2-2)
(= v1-3 v2-3)
- v1-4 v2-4 ; all or nothin if elt - is =
+ v1-4 v2-4 ; all or nothing if elt - is =
(< v1-4 v2-4))
(and (= v1-0 v2-0)
(= v1-1 v2-1)
(= v1-2 v2-2)
- v1-3 v2-3 ; all or nothin if elt - is =
+ v1-3 v2-3 ; all or nothing if elt - is =
(< v1-3 v2-3))
(and (= v1-1 v2-1)
(< v1-2 v2-2))
(save-excursion (semantic-fetch-tags))
nil)
;; If we are here, it is because the lexical step failed,
- ;; proably due to unterminated lists or something like that.
+ ;; probably due to unterminated lists or something like that.
;; We do nothing, and just wait for the next idle timer
;; to go off. In the meantime, remember this, and make sure
(setq cacheend chil)
(while (and cacheend (not (eq last (car cacheend))))
(setq cacheend (cdr cacheend)))
- ;; The splicable part is after cacheend.. so move cacheend
+ ;; The spliceable part is after cacheend.. so move cacheend
;; one more tag.
(setq cacheend (cdr cacheend))
;; Splice the found end tag into the cons cell
(save-excursion (semantic-fetch-tags))
nil)
;; If we are here, it is because the lexical step failed,
- ;; proably due to unterminated lists or something like that.
+ ;; probably due to unterminated lists or something like that.
;; We do nothing, and just wait for the next idle timer
;; to go off. In the meantime, remember this, and make sure
(if (eq (semantic-lex-token-class (car semantic-lex-token-stream))
'whitespace)
;; Merge whitespace tokens together if they are adjacent. Two
- ;; whitespace tokens may be sperated by a comment which is not in
+ ;; whitespace tokens may be separated by a comment which is not in
;; the token stream.
(setcdr (semantic-lex-token-bounds (car semantic-lex-token-stream))
(match-end 0))
(if (eq (semantic-lex-token-class (car semantic-lex-token-stream))
'whitespace)
;; Merge whitespace tokens together if they are adjacent. Two
- ;; whitespace tokens may be sperated by a comment which is not in
+ ;; whitespace tokens may be separated by a comment which is not in
;; the token stream.
(progn
(setq semantic-lex-end-point (match-end 0))
;;;###autoload
(define-overloadable-function semantic-tag-prototype-p (tag)
"Return non nil if TAG is a prototype.
-For some laguages, such as C, a prototype is a declaration of
+For some languages, such as C, a prototype is a declaration of
something without an implementation."
)
)
(defvar srecode-field-replication-max-size 100
- "Maximum size of a field before cancelling replication.")
+ "Maximum size of a field before canceling replication.")
(defun srecode-field-mod-hook (ol after start end &optional pre-len)
"Modification hook for the field overlay.
:group 'columns)
(defcustom delimit-columns-start 0
- "Specify column number to start prettifing.
+ "Specify column number to start prettifying.
See also `delimit-columns-end' for documentation.
:group 'columns)
(defcustom delimit-columns-end 1000000
- "Specify column number to end prettifing.
+ "Specify column number to end prettifying.
See also `delimit-columns-start' for documentation.
(put 'newline 'delete-selection t)
(put 'open-line 'delete-selection 'kill)
-;; This is very useful for cancelling a selection in the minibuffer without
+;; This is very useful for canceling a selection in the minibuffer without
;; aborting the minibuffer.
(defun minibuffer-keyboard-quit ()
"Abort recursive edit.
(compose-string (string ch) 0 1 (format "\t%c\t" ch))
(string ch)))
-;; Return a nicely formated list of categories; extended category
+;; Return a nicely formatted list of categories; extended category
;; description is added to the category name as a tooltip
(defsubst describe-char-categories (category-set)
(let ((mnemonics (category-set-mnemonics category-set)))
;; Apparently people do use it. - lrd 12/22/97.
(with-no-warnings
- ;; Warnings are suppresed to avoid "global/dynamic var `X' lacks a prefix".
+ ;; Warnings are suppressed to avoid "global/dynamic var `X' lacks a prefix".
;; This is unbearably ugly, but not more than having global variables
;; named size, time, name or s, however practical it can be while writing
;; `dired-mark-sexp' predicates.
(eq last-input-event ?\C-g))
(progn (setq unread-command-events nil
prefix-arg nil)
- ;; If it wasn't cancelling a prefix character, then quit.
+ ;; If it wasn't canceling a prefix character, then quit.
(if (or (= (length (this-command-keys)) 1)
(not inhibit-quit)) ; safety
(progn (ding)
(defun edebug-on-entry (function &optional flag)
"Cause Edebug to stop when FUNCTION is called.
With prefix argument, make this temporary so it is automatically
-cancelled the first time the function is entered."
+canceled the first time the function is entered."
(interactive "aEdebug on entry to: \nP")
;; Could store this in the edebug data instead.
(put function 'edebug-on-entry (if flag 'temp t)))
(eval-and-compile
;; About the above. EIEIO must process its own code when it compiles
-;; itself, thus, by eval-and-compiling outselves, we solve the problem.
+;; itself, thus, by eval-and-compiling ourselves, we solve the problem.
;; Compatibility
(if (fboundp 'compiled-function-arglist)
;; Handle shifted cursor keys and other movement commands.
;; If region is not active, region is activated if key is shifted.
- ;; If region is active, region is cancelled if key is unshifted
+ ;; If region is active, region is canceled if key is unshifted
;; (and region not started with C-SPC).
;; If rectangle is active, expand rectangle in specified direction and
;; ignore the movement.
global marker is in another buffer.
If the global marker isn't set, set the global marker at point in the current
buffer. Otherwise jump to the global marker position and cancel it.
-With prefix argument, don't jump to global mark when cancelling it."
+With prefix argument, don't jump to global mark when canceling it."
(interactive "P")
(unless cua--global-mark-initialized
(cua--init-global-mark))
(goto-char (point-min))
(if (y-or-n-p "Inhibit VIP startup message? ")
(progn
- (with-current-buffer
+ (with-current-buffer
(find-file-noselect
(substitute-in-file-name vip-startup-file))
(goto-char (point-max))
(if (> beg end) (exchange-point-and-mark)))
(defun vip-global-execute ()
- "Call last keyboad macro for each line in the region."
+ "Call last keyboard macro for each line in the region."
(if (> (point) (mark)) (exchange-point-and-mark))
(beginning-of-line)
(call-last-kbd-macro)
(error
(viper-message-conditions conds))))
-;; escape to emacs mode termporarily
+;; escape to emacs mode temporarily
(defun viper-escape-to-emacs (arg &optional events)
"Escape to Emacs state from Vi state for one Emacs command.
ARG is used as the prefix value for the executed command. If
(message "Switched to EMACS state for the next command..."))
(viper-escape-to-state arg events 'emacs-state))
-;; escape to Vi mode termporarily
+;; escape to Vi mode temporarily
(defun viper-escape-to-vi (arg)
"Escape from Emacs state to Vi state for one Vi 1-character command.
If the Vi command that the user types has a prefix argument, e.g., `d2w', then
t 'local)
(add-hook
'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel t 'local)
- ;; guard against a smartie who switched from R-replace to normal replace
+ ;; guard against a smarty who switched from R-replace to normal replace
(remove-hook
'viper-post-command-hooks 'viper-R-state-post-command-sentinel 'local)
(if overwrite-mode (overwrite-mode -1))
'viper-post-command-hooks 'viper-R-state-post-command-sentinel t 'local)
(add-hook
'viper-pre-command-hooks 'viper-replace-state-pre-command-sentinel t 'local)
- ;; guard against a smartie who switched from R-replace to normal replace
+ ;; guard against a smarty who switched from R-replace to normal replace
(remove-hook
'viper-post-command-hooks 'viper-replace-state-post-command-sentinel 'local)
)
"//" 'vi-state
[1 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
scope)
- ;; toggle regexp/vanila search
+ ;; toggle regexp/vanilla search
(viper-record-kbd-macro
"///" 'vi-state
[2 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
"//" 'emacs-state
[1 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
(or arg-majormode major-mode))
- ;; toggle regexp/vanila search
+ ;; toggle regexp/vanilla search
(viper-record-kbd-macro
"///" 'emacs-state
[2 (meta x) v i p e r - t o g g l e - s e a r c h - s t y l e return]
(setq viper-prefix-commands
(cons viper-buffer-search-char viper-prefix-commands)))
-;; This is a Viper wraper for isearch-forward.
+;; This is a Viper wrapper for isearch-forward.
(defun viper-isearch-forward (arg)
"Do incremental search forward."
(interactive "P")
(if (listp arg) (setq arg (car arg)))
(viper-exec-form-in-emacs (list 'isearch-forward arg)))
-;; This is a Viper wraper for isearch-backward."
+;; This is a Viper wrapper for isearch-backward."
(defun viper-isearch-backward (arg)
"Do incremental search backward."
(interactive "P")
;;; Face-saving tricks
(defgroup viper-highlighting nil
- "Hilighting of replace region, search pattern, minibuffer, etc."
+ "Highlighting of replace region, search pattern, minibuffer, etc."
:prefix "viper-"
:group 'viper)
(defun viper-global-execute ()
- "Call last keyboad macro for each line in the region."
+ "Call last keyboard macro for each line in the region."
(if (> (point) (mark t)) (exchange-point-and-mark))
(beginning-of-line)
(call-last-kbd-macro)
)
"List specifying how to modify the various major modes to enable some Viperisms.
The list has the structure: ((mode viper-state keymap) (mode viper-state
-keymap) ...). If `mode' is on the list, the `kemap' will be made active (on
+keymap) ...). If `mode' is on the list, the `keymap' will be made active (on
the minor-mode-map-alist) in the specified viper state.
If you change this list, have to restart Emacs for the change to take effect.
However, if you did the change through the customization widget, then Emacs
directory 'full directory-files-no-dot-files-regexp))
(error "Directory is not empty, not moving to trash")
(move-file-to-trash directory)))
- ;; Otherwise, call outselves recursively if needed.
+ ;; Otherwise, call ourselves recursively if needed.
(t
(if (and recursive (not (file-symlink-p directory)))
(mapc (lambda (file)
(defvar kill-emacs-query-functions nil
"Functions to call with no arguments to query about killing Emacs.
-If any of these functions returns nil, killing Emacs is cancelled.
+If any of these functions returns nil, killing Emacs is canceled.
`save-buffers-kill-emacs' calls these functions, but `kill-emacs',
the low level primitive, does not. See also `kill-emacs-hook'.")
;;{{{ Redisplay
;; Redraw all the windows on the screen, starting with the top window.
-;; The window used as as marker is WIN, or the selcted window if WIN
+;; The window used as as marker is WIN, or the selected window if WIN
;; is nil. Start every window directly after the end of the previous
;; window, to make sure long lines are displayed correctly.
;; going to be recentered at the next redisplay, unless we do a
;; read-and-write cycle to update the `force' flag inside the windows.
;;
-;; In 19.30, a new varible `window-scroll-functions' is called every
+;; In 19.30, a new variable `window-scroll-functions' is called every
;; time a window is recentered. It is not perfect for our situation,
;; since when it is called for a tail window, it is to late. However,
;; if it is called for another window, we can try to update our
(message-mail-other-window, message-mail-other-frame)
(message-news-other-window, message-news-other-frame):
Use switch-to-buffer-other-frame and switch-to-buffer-other-window
- instead of setting buffer display varibles.
+ instead of setting buffer display variables.
2011-09-11 Lars Magne Ingebrigtsen <larsi@gnus.org>
* gnus-start.el (gnus-activate-group): Take an optional parameter to
say that you don't want to call gnus-request-group with don-check, but
- do check the reponse. This is for virtual groups only.
+ do check the response. This is for virtual groups only.
(gnus-get-unread-articles): Count the archive groups as secondary, so
that they're activated the same way as before.
result))
(defun gnus-fun-ppm-change-string ()
- (let* ((possibilites '("%02x0000" "00%02x00" "0000%02x"
- "%02x%02x00" "00%02x%02x" "%02x00%02x"))
+ (let* ((possibilities '("%02x0000" "00%02x00" "0000%02x"
+ "%02x%02x00" "00%02x%02x" "%02x00%02x"))
(format (concat "'#%02x%02x%02x' '#"
- (nth (random 6) possibilites)
+ (nth (random 6) possibilities)
"'"))
(values nil))
(dotimes (i 255)
;; BUG: We really need to get the charset for
;; each name in the Newsgroups and Followup-To
;; lines to allow crossposting between group
- ;; namess with incompatible character sets.
+ ;; names with incompatible character sets.
;; -- Per Abrahamsen <abraham@dina.kvl.dk> 2001-10-08.
(group-field-charset
(gnus-group-name-charset
(defun gnus-summary-find-for-reselect ()
"Return the number of an article to stay on across a reselect.
The current article is considered, then following articles, then previous
-articles. An article is sought which is not cancelled and isn't a temporary
+articles. An article is sought which is not canceled and isn't a temporary
insertion from another group. If there's no such then return a dummy 0."
(let (found)
(dolist (rev '(nil t))
(defface gnus-summary-cancelled
'((((class color))
(:foreground "yellow" :background "black")))
- "Face used for cancelled articles."
+ "Face used for canceled articles."
:group 'gnus-summary)
;; backward-compatibility alias
(put 'gnus-summary-cancelled-face 'face-alias 'gnus-summary-cancelled)
:type 'hook)
(defcustom message-cancel-hook nil
- "Hook run when cancelling articles."
+ "Hook run when canceling articles."
:group 'message-various
:link '(custom-manual "(message)Various Message Variables")
:type 'hook)
(message-fetch-field "Followup-To")))
;; BUG: We really need to get the charset for each name in the
;; Newsgroups and Followup-To lines to allow crossposting
- ;; between group namess with incompatible character sets.
+ ;; between group names with incompatible character sets.
;; -- Per Abrahamsen <abraham@dina.kvl.dk> 2001-10-08.
(group-field-charset
(gnus-group-name-charset method newsgroups-field))
;; List of NNDiary headers that specify the time spec. Each header name is
;; followed by either two integers (specifying a range of possible values
;; for this header) or one list (specifying all the possible values for this
- ;; header). In the latter case, the list does NOT include the unspecifyed
+ ;; header). In the latter case, the list does NOT include the unspecified
;; spec (*).
;; For time zone values, we have symbolic time zone names associated with
;; the (relative) number of seconds ahead GMT.
;; Parse the schedule string STR, or signal an error.
;; Signals are caught by `nndary-schedule'.
(if (string-match "[ \t]*\\*[ \t]*" str)
- ;; unspecifyed
+ ;; unspecified
nil
- ;; specifyed
+ ;; specified
(if (listp min-or-values)
;; min-or-values is values
;; #### NOTE: this is actually only a hack for time zones.
(message "Doing hyrex-search query \"%s\"...done" qstring)
(sit-for 0)
;; nnir-search returns:
- ;; for nnml/nnfolder: "filename mailid weigth"
- ;; for nnimap: "group mailid weigth"
+ ;; for nnml/nnfolder: "filename mailid weight"
+ ;; for nnimap: "group mailid weight"
(goto-char (point-min))
(delete-non-matching-lines "^\\S + [0-9]+ [0-9]+$")
;; HyREX doesn't search directly in groups -- so filter out here.
(process-buffer -process))))
;; When I an able to identify the
;; connection to the server AND I've
- ;; received NO reponse for
+ ;; received NO response for
;; nntp-connection-timeout seconds.
(when (and -buffer (eq 0 (buffer-size -buffer)))
;; Close the connection. Take no
'(menu-item "Save current filter groups permanently..."
ibuffer-save-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)
- :help "Use a mnemnonic name to store current filter groups"))
+ :help "Use a mnemonic name to store current filter groups"))
(define-key-after groups-map [switch-to-saved-filter-groups]
'(menu-item "Restore permanently saved filters..."
ibuffer-switch-to-saved-filter-groups
(define-key-after map [menu-bar view filter save-filters]
'(menu-item "Save current filters permanently..." ibuffer-save-filters
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)
- :help "Use a mnemnonic name to store current filter stack"))
+ :help "Use a mnemonic name to store current filter stack"))
(define-key-after map [menu-bar view filter switch-to-saved-filters]
'(menu-item "Restore permanently saved filters..."
ibuffer-switch-to-saved-filters
succeed, it checks to see if any function in `auto-coding-functions'
gives a match.
-If a coding system is specifed, the return value is a cons
+If a coding system is specified, the return value is a cons
\(CODING . SOURCE), where CODING is the specified coding system and
SOURCE is a symbol `auto-coding-alist', `auto-coding-regexp-alist',
`:coding', or `auto-coding-functions' indicating by what CODING is
;; Generate a half-cooked decode map (char-table) for the current
;; Quail map. An element for a character C is a key string or a list
-;; of a key strings to type to input C. The lenth of key string is at
+;; of a key strings to type to input C. The length of key string is at
;; most 2. If it is 2, more keys may be required to input C.
(defun quail-gen-decode-map ()
In this input method, you enter a Chinese character by first typing
keys corresponding to Zhuyin symbols (see the above table) followed by
-SPC, 1, 2, 3, or 4 specifing a tone (SPC:\e$(0?v(N\e(B, 1:\e$(0M=Vy\e(B, 2:\e$(0Dm(N\e(B, 3: \e$(0&9Vy\e(B,
+SPC, 1, 2, 3, or 4 specifying a tone (SPC:\e$(0?v(N\e(B, 1:\e$(0M=Vy\e(B, 2:\e$(0Dm(N\e(B, 3: \e$(0&9Vy\e(B,
4:\e$(0(+Vy\e(B).
\\<quail-translation-docstring>")
In this input method, you enter a Chinese character by first typing
keys corresponding to Zhuyin symbols (see the above table) followed by
-SPC, 6, 3, 4, or 7 specifing a tone (SPC:\e$(0?v(N\e(B, 6:\e$(0Dm(N\e(B, 3:\e$(0&9Vy\e(B, 4:\e$(0(+Vy\e(B,
+SPC, 6, 3, 4, or 7 specifying a tone (SPC:\e$(0?v(N\e(B, 6:\e$(0Dm(N\e(B, 3:\e$(0&9Vy\e(B, 4:\e$(0(+Vy\e(B,
7:\e$(0M=Vy\e(B).
\\<quail-translation-docstring>")))
(eval-when-compile decomposition-pair-to-composition)))
(defun ucs-normalize-primary-composite (decomposition-pair composition-predicate)
- "Convert DECOMPOSITION-PAIR to primay composite using COMPOSITION-PREDICATE."
+ "Convert DECOMPOSITION-PAIR to primary composite using COMPOSITION-PREDICATE."
(let ((char (or (gethash decomposition-pair
ucs-normalize-decomposition-pair-to-primary-composite)
(and (<= #x1100 (car decomposition-pair))
;; Create a separate keymap installed as a minor-mode keymap (e.g. in
;; the emulation-mode-map-alists) in which macro bindings are made
;; independent of any other bindings. When first binding is made,
-;; the kemap is created, installed, and enabled. Key seq. C-x C-k +
+;; the keymap is created, installed, and enabled. Key seq. C-x C-k +
;; can then be used to toggle the use of this keymap on and off.
;; This means that it would be safe(r) to bind ordinary keys like
;; letters and digits, provided that we inhibit the keymap while
(define-coding-system 'chinese-big5
"BIG5 8-bit encoding for Chinese (MIME:Big5)"
:coding-type 'big5
- :mnemonic ?B
+ :mnemonic ?B
:charset-list '(ascii big5)
:mime-charset 'big5)
(define-coding-system 'chinese-big5-hkscs
"BIG5-HKSCS 8-bit encoding for Chinese, Hong Kong supplement (MIME:Big5-HKSCS)"
:coding-type 'charset
- :mnemonic ?B
+ :mnemonic ?B
:charset-list '(ascii big5-hkscs)
:mime-charset 'big5-hkscs)
(define-coding-system-alias 'big5-hkscs 'chinese-big5-hkscs)
chinese-cns11643-5 chinese-cns11643-6
chinese-cns11643-7)
(iso639-language . zh)
- (setup-function . (lambda ()
+ (setup-function . (lambda ()
(use-cjk-char-width-table 'zh_TW)))
(exit-function . use-default-char-width-table)
(coding-system iso-2022-cn euc-tw)
chinese-cns11643-5 chinese-cns11643-6
chinese-cns11643-7 chinese-big5-1 chinese-big5-2)
(iso639-language . zh)
- (setup-function . (lambda ()
+ (setup-function . (lambda ()
(use-cjk-char-width-table 'zh_TW)))
(exit-function . use-default-char-width-table)
(coding-system euc-tw iso-2022-cn)
(features china-util)
(input-method . "chinese-cns-quick")
(documentation . "\
-Support for Chinese, prefering the EUC-TW character set. Note that
+Support for Chinese, preferring the EUC-TW character set. Note that
the EUC-TW coding system accepts Big5 for input also (which is then
converted to CNS)."))
'("Chinese"))
(set-language-info-alist
"Chinese-GBK" '((charset chinese-gbk)
(iso639-language . zh)
- (setup-function . (lambda ()
+ (setup-function . (lambda ()
(use-cjk-char-width-table 'zh_CN)))
(exit-function . use-default-char-width-table)
(coding-system chinese-gbk)
(coding-priority gbk iso-2022-cn chinese-big5
chinese-iso-8bit) ; fixme?
- (ctext-non-standard-encodings "gbk-0")
+ (ctext-non-standard-encodings "gbk-0")
(input-method . "chinese-py-punct") ; fixme?
(sample-text . "Chinese (\e$BCfJ8\e(B,\e$BIaDL\e$A;0\e(B,\e$A::So\e(B) \e$(D95\e$B9%\e(B")
(features china-util)
;; for representing these characters: VISCII, TCVN-5712, VPS, VIQR,
;; and Unicode. VISCII, TCVN-5712 and VPS are simple 1-byte code
;; which assigns 134 unique characters in control-code area
-;; (0x00..0x1F) and right half area (0x80..0xFF). VIQR is a menmonic
+;; (0x00..0x1F) and right half area (0x80..0xFF). VIQR is a mnemonic
;; encoding specification representing diacritical marks by following
;; ASCII characters.
"Return VISCII character code of CHAR if appropriate."
(encode-char char 'viscii))
-;; VIQR is a menmonic encoding specification for Vietnamese.
+;; VIQR is a mnemonic encoding specification for Vietnamese.
;; It represents diacritical marks by ASCII characters as follows:
;; ------------+----------+--------
;; mark | mnemonic | example
;; Otherwise record the current column and look backwards.
(setq column (current-column))
(skip-chars-backward ",; \t")
- ;; Record the distance travelled.
+ ;; Record the distance traveled.
(setq distance (- column (current-column)))
(when (looking-back
(concat "([ \t]*\\(?:" Man-section-regexp "\\)[ \t]*)"))
(if (not (and seen-prompt ange-ftp-pending-error-line))
(ange-ftp-process-handle-line line proc)
;; If we've seen a potential error message and it
- ;; hasn't been cancelled by a good message before
+ ;; hasn't been canceled by a good message before
;; seeing a prompt, then the error was real.
(delete-process proc)
(setq ange-ftp-process-busy nil
;; The function `zeroconf-publish-service' publishes a new service to
;; the Avahi daemon. Although the domain, where to the service is
-;; published, can be specified by this function, it is usally the
+;; published, can be specified by this function, it is usually the
;; default domain "local" (also written as nil or "").
;; (zeroconf-publish-service
(defun rng-kill-timers ()
;; rng-validate-timer and rng-validate-quick-timer have the
;; permanent-local property, so that the timers can be
- ;; cancelled even after changing mode.
- ;; This function takes care of cancelling the timers and
+ ;; canceled even after changing mode.
+ ;; This function takes care of canceling the timers and
;; then killing the local variables.
(when (local-variable-p 'rng-validate-timer)
(when rng-validate-timer
(defvar pgg-pending-timers (make-vector 7 0)
"Hash table for managing scheduled pgg cache management timers.
-We associate key and timer, so the timer can be cancelled if a new
+We associate key and timer, so the timer can be canceled if a new
timeout for the key is set while an old one is still pending.")
(defun pgg-read-passphrase (prompt &optional key notruncate)
* org-archive.el (org-archive-subtree): While it might be possible
to archive an headline of a temporary buffer (i.e. not visiting a
- file), it wouldn't be really sensical.
+ file), it wouldn't be really sensible.
2011-07-28 Nicolas Goaziou <n.goaziou@gmail.com>
* org-list.el (org-list-blocks): New variable.
(org-list-context): New function.
(org-list-full-item-re): New variable.
- (org-list-struct-assoc-at-point): Use new varible.
+ (org-list-struct-assoc-at-point): Use new variable.
(org-list-struct): Rewrite of function. Now, list data is
collected by looking at the list line after line. It reads the
whole list each time because reading only a subtree was not enough
2010-11-11 Nicolas Goaziou <n.goaziou@gmail.com>
* org-list.el (org-insert-item-internal): New function to handle
- positionning and contents of an item being inserted at a specific
+ positioning and contents of an item being inserted at a specific
pos. It is not possible anymore to split a term in a description
list or a checkbox when inserting a new item.
2010-07-19 Bastien Guerry <bzg@altern.org>
- * org-timer.el (org-timer-set-timer): Fix bug about cancelling
+ * org-timer.el (org-timer-set-timer): Fix bug about canceling
timers.
2010-07-19 David Maus <dmaus@ictsoc.de>
buffer and at the position of the given clock. However, changes
to the current clock are local and have no effect on the user's
active clock. This allows, for example, far any clock to be
- cancelled without cancelling the active clock.
+ canceled without canceling the active clock.
(org-clock-clock-in): New inline function that switches the active
clock to the given clock. If either the argument RESUME, or the
global `org-clock-in-resume', are non-nil, it will resume a clock
(org-agenda-remove-flag hdmarker)
(let ((win (get-buffer-window "*Flagging Note*")))
(and win (delete-window win)))
- (message "Entry unflaged"))
+ (message "Entry unflagged"))
(setq note (org-entry-get hdmarker "THEFLAGGINGNOTE"))
(unless note
(error "No flagging note"))
(org-entry-delete nil "THEFLAGGINGNOTE")
(setq newhead (org-get-heading)))
(org-agenda-change-all-lines newhead marker)
- (message "Entry unflaged")))
+ (message "Entry unflagged")))
(defun org-agenda-get-any-marker (&optional pos)
(or (get-text-property (or pos (point-at-bol)) 'org-hd-marker)
"Hook run when stopping the current clock.")
(defvar org-clock-cancel-hook nil
- "Hook run when cancelling the current clock.")
+ "Hook run when canceling the current clock.")
(defvar org-clock-goto-hook nil
"Hook run when selecting the currently clocked-in entry.")
(defvar org-clock-has-been-used nil
(defvar org-clock-start-time "")
(defvar org-clock-leftover-time nil
- "If non-nil, user cancelled a clock; this is when leftover time started.")
+ "If non-nil, user canceled a clock; this is when leftover time started.")
(defvar org-clock-effort ""
"Effort estimate of the currently clocking task.")
;; Computing a list structure can be a costly operation on huge lists
;; (a few thousand lines long). Thus, code should follow the rule :
-;; "collect once, use many". As a corollary, it is usally a bad idea
+;; "collect once, use many". As a corollary, it is usually a bad idea
;; to use directly an interactive function inside the code, as those,
;; being independent entities, read the whole list structure another
;; time.
(defgroup org-protocol nil
"Intercept calls from emacsclient to trigger custom actions.
-This is done by advising `server-visit-files' to scann the list of filenames
-for `org-protocol-the-protocol' and sub-procols defined in
+This is done by advising `server-visit-files' to scan the list of filenames
+for `org-protocol-the-protocol' and sub-protocols defined in
`org-protocol-protocol-alist' and `org-protocol-protocol-alist-default'."
:version "22.1"
:group 'convenience
:type 'string)
(defcustom org-publish-sitemap-file-entry-format "%t"
- "How a sitemap file entry is formated.
+ "How a sitemap file entry is formatted.
You could use brackets to delimit on what part the link will be.
%t is the title.
%a is the author.
-%d is the date formated using `org-publish-sitemap-date-format'."
+%d is the date formatted using `org-publish-sitemap-date-format'."
:group 'org-publish
:type 'string)
(and filtered-items (mapconcat 'identity filtered-items "\n"))))
(defun org-taskjuggler-get-attributes (item attributes)
- "Return all attribute as a single formated string. ITEM is an
+ "Return all attributes as a single formatted string. ITEM is an
alist representing either a resource or a task. ATTRIBUTES is a
list of symbols. Only entries from ITEM are considered that are
listed in ATTRIBUTES."
(defun gametree-save-and-hack-layout ()
"Save the current tree layout and hack the file local variable spec.
This function saves the current layout in `gametree-local-layout' and,
-if a local file varible specification for this variable exists in the
+if a local file variable specification for this variable exists in the
buffer, it is replaced by the new value. See the documentation for
`gametree-local-layout' for more information."
(interactive)
(c-narrow-to-comment-innards range) ; This may move point back.
(let* ((here (point))
last
- (here-filler ; matches WS and comment-prefices at point.
+ (here-filler ; matches WS and comment-prefixes at point.
(concat "\\=\\(^[ \t]*\\(" c-current-comment-prefix "\\)"
"\\|[ \t\n\r\f]\\)*"))
(prefix-at-bol-here ; matches WS and prefix at BOL, just before point
;; Now seek successively earlier sentence ends between PAR-BEG and
;; HERE, until the "start of sentence" following it is earlier than
- ;; HERE, or we hit PAR-BEG. Beware of comment prefices!
+ ;; HERE, or we hit PAR-BEG. Beware of comment prefixes!
(while (and (re-search-backward (c-sentence-end) par-beg 'limit)
(setq last (point))
(goto-char (match-end 0)) ; tentative beginning of sentence
(setq done t) ; not a label-only line, exit the loop
(setq retval (point))))
;; We couldn't go further back, and we haven't found a command yet.
- ;; Return to the start positionn
+ ;; Return to the start position.
(goto-char start)
(setq done t)
(setq retval nil)))
(setq done t) ; not a label-only line, exit the loop
(setq retval (point)))))
;; We couldn't go further back, and we haven't found a command yet.
- ;; Return to the start positionn
+ ;; Return to the start position.
(goto-char start)
(setq done t)
(setq retval nil)))
"Display online help about the completion at point."
(interactive "eP")
;; Restore last-command for next command, to make
- ;; scrolling/cancelling of completions work.
+ ;; scrolling/canceling of completions work.
(setq this-command last-command)
(idlwave-do-mouse-completion-help ev))
'(js> ((fifth hitab) "selectedTab") (fourth hitab))
cmds)))
- ;; Hilighting whole window
+ ;; Highlighting whole window
((third hitab)
(push '(js! ((third hitab) "document"
"documentElement" "setAttribute")
(defgroup vhdl-menu nil
- "Customizations for menues."
+ "Customizations for menus."
:group 'vhdl)
(defcustom vhdl-index-menu nil
;; Internal variables
(defvar vhdl-menu-max-size 20
- "*Specifies the maximum size of a menu before splitting it into submenues.")
+ "*Specifies the maximum size of a menu before splitting it into submenus.")
(defvar vhdl-progress-interval 1
"*Interval used to update progress status during long operations.
(goto-char marker))
(defun vhdl-menu-split (list title)
- "Split menu LIST into several submenues, if number of
+ "Split menu LIST into several submenus, if number of
elements > `vhdl-menu-max-size'."
(if (> (length list) vhdl-menu-max-size)
(let ((remain list)
(defun ses-read-printer (prompt default)
"Common code for `ses-read-cell-printer', `ses-read-column-printer', and `ses-read-default-printer'.
-PROMPT should end with \": \". Result is t if operation was cancelled."
+PROMPT should end with \": \". Result is t if operation was canceled."
(barf-if-buffer-read-only)
(if (eq default t)
(setq default "")
n)
;; next-matching-history-element always puts us at (point-min).
;; Move to the position we were at before changing the buffer contents.
- ;; This is still sensical, because the text before point has not changed.
+ ;; This is still sensible, because the text before point has not changed.
(goto-char point-at-start)))
(defun previous-complete-history-element (n)
(defvar buffer-quit-function nil
"Function to call to \"quit\" the current buffer, or nil if none.
\\[keyboard-escape-quit] calls this function when its more local actions
-\(such as cancelling a prefix argument, minibuffer or region) do not apply.")
+\(such as canceling a prefix argument, minibuffer or region) do not apply.")
(defun keyboard-escape-quit ()
"Exit the current \"mode\" (in a generalized sense of the word).
choice buffer base-position nil)
;; This remove-text-properties should be unnecessary since `choice'
;; comes from buffer-substring-no-properties.
- ;;(remove-text-properties 0 (lenth choice) '(mouse-face nil) choice)
+ ;;(remove-text-properties 0 (length choice) '(mouse-face nil) choice)
;; Insert the completion into the buffer where it was requested.
(funcall (or insert-function completion-list-insert-choice-function)
(or (car base-position) (point))
(if (not v)
(setq speedbar-special-mode-expansion-list t)
;; If it is autoloaded, we need to load it now so that
- ;; we have access to the varialbe -speedbar-menu-items.
+ ;; we have access to the variable -speedbar-menu-items.
;; Is this XEmacs safe?
(let ((sf (symbol-function v)))
(if (and (listp sf) (eq (car sf) 'autoload))
(defun emacs-session-save ()
"This function is called when the window system is shutting down.
-If this function returns non-nil, the window system shutdown is cancelled.
+If this function returns non-nil, the window system shutdown is canceled.
When a session manager tells Emacs that the window system is shutting
down, this function is called. It calls the functions in the hook
;; Implementation note: This really should honor the interval-fn entry
;; in the master table, `artist-mt', which would mean leaving a timer
;; that calls `draw-fn' every now and then. That timer would then have
-;; to be cancelled and reinstalled whenever the user moves the cursor.
+;; to be canceled and reinstalled whenever the user moves the cursor.
;; This could be done, but what if the user suddenly switches to another
;; drawing mode, or even kills the buffer! In the mouse case, it is much
;; simpler: when at the end of `artist-mouse-draw-continously', the
-;; user has released the button, so the timer will always be cancelled
+;; user has released the button, so the timer will always be canceled
;; at that point.
(defun artist-key-draw-continously (x y)
"Draw current continuous shape at X,Y."
;; of drawing mode.
;;
;; You should provide these functions. You might think that
-;; only you is using your type of mode, so noone will be able
+;; only you is using your type of mode, so no one will be able
;; to switch to another operation of the same type of mode,
;; but someone else might base a new drawing mode upon your
;; work.
;; hidden by new window, scroll it to just below new win
;; otherwise set top line of other win so it doesn't scroll.
(if (< oldot top) (setq top oldot))
- ;; if frame is unsplitable, temporarily disable that...
+ ;; if frame is unsplittable, temporarily disable that...
(if (cdr (assq 'unsplittable (frame-parameters (selected-frame))))
(let ((frame (selected-frame)))
(modify-frame-parameters frame '((unsplittable . nil)))
; LocalWords: AMStex hspace includeonly nocite epsfig displaymath eqnarray reg
; LocalWords: minipage modeline pers dict unhighlight buf grep sync prev inc
; LocalWords: fn oldot NB AIX msg init read's bufs pt cmd Quinlan eg
-; LocalWords: uuencoded unidiff sc nn VM SGML eval IspellPersDict unsplitable
+; LocalWords: uuencoded unidiff sc nn VM SGML eval IspellPersDict
; LocalWords: lns XEmacs HTML casechars Multibyte
;;; ispell.el ends here
(add-hook 'pre-command-hook 'reftex-highlight-shall-die)
(when (eq how 'tmp-window)
- ;; Resize window and arrange restauration
+ ;; Resize window and arrange restoration
(shrink-window (1- (- (window-height) 9)))
(recenter '(4))
(add-hook 'pre-command-hook 'reftex-restore-window-conf))
(car (table--get-coordinate (cdr (table--horizontal-cell-list nil t))))
(1+ (cdr (table--get-coordinate (cdr (table--vertical-cell-list nil t))))))))
-(defun table-call-interactively (function &optional recoard-flag keys)
+(defun table-call-interactively (function &optional record-flag keys)
"Call FUNCTION, or a table version of it if applicable.
See `call-interactively' for full description of the arguments."
(let ((table-func (intern-soft (format "*table--cell-%s" function))))
(if (and table-func
(table--point-in-cell-p))
table-func
- function) recoard-flag keys)))
+ function) record-flag keys)))
(defun table-funcall (function &rest arguments)
"Call FUNCTION, or a table version of it if applicable.
(table-entry-height 0)
;; unformatted row looks like: A1 @tab A2 @tab A3
;; extract-row command deletes the source line in the table.
- (unformated-row (texinfo-multitable-extract-row)))
+ (unformatted-row (texinfo-multitable-extract-row)))
;; Use a temporary buffer
(set-buffer (get-buffer-create texinfo-multitable-buffer-name))
(delete-region (point-min) (point-max))
- (insert unformated-row)
+ (insert unformatted-row)
(goto-char (point-min))
;; 1. Check for correct number of @tab in line.
(let ((tab-number 1)) ; one @tab between two columns
nil)))
(with-no-warnings
- ;; Warnings are suppresed to avoid "global/dynamic var `X' lacks a prefix".
+ ;; Warnings are suppressed to avoid "global/dynamic var `X' lacks a prefix".
(defvar now)
(defvar time)
(defvar load)
(url-dav-process-DAV:activelock)
(url-dav-process-DAV:lockdiscovery): Can now correctly parse
DAV:lockdiscovery nodes, so that we can find out who has a
- resource locked and properly parse the reponse to a LOCK request.
+ resource locked and properly parse the response to a LOCK request.
(url-dav-process-DAV:status): Now parses out the numeric status
from the HTTP response line.
(url-dav-process-response): New function to handle all the
:group 'url-gateway)
(defcustom url-gateway-telnet-login-prompt "^\r*.?login:"
- "Prompt that tells us we should send our username when loggin in w/telnet."
+ "Prompt that tells us we should send our username when logging in w/telnet."
:type 'regexp
:group 'url-gateway)
(defcustom url-gateway-telnet-password-prompt "^\r*.?password:"
- "Prompt that tells us we should send our password when loggin in w/telnet."
+ "Prompt that tells us we should send our password when logging in w/telnet."
:type 'regexp
:group 'url-gateway)
this-command)))
(defgroup ediff-highlighting nil
- "Hilighting of difference regions in Ediff."
+ "Highlighting of difference regions in Ediff."
:prefix "ediff-"
:group 'ediff)
by appending the branch to ARG which defaults to \"-r\".
Since the `cvs-secondary-branch-prefix' is only active if the primary
prefix is active, it is important to read the secondary prefix before
-the primay since reading the primary can deactivate it."
+the primary since reading the primary can deactivate it."
(let ((branch (and (cvs-prefix-get 'cvs-branch-prefix 'read-only)
(cvs-prefix-get 'cvs-secondary-branch-prefix))))
(if branch (cons (concat (or arg "-r") branch) flags) flags)))
;; automatically for a PC if Oemacs is detected. This set uses separate
;; control, shift and meta keys with function keys 1 to 10. In
;; particular, movement keys are concentrated on f5 to f8 with (in
-;; increasing order of distance travelled) C-, M- and S- as prefixes.
+;; increasing order of distance traveled) C-, M- and S- as prefixes.
;; See the actual bindings below (search for C-f1). This is because the
;; C-S- prefix is represented by weird key sequences and the set is
;; incomplete; if you don't mind that, some hints are given in comments
;; sets view-read-only to t as a buffer-local variable
;; after exiting View mode. That arranges that the next toggle-read-only
;; will reenable View mode.
- ;; Cancelling View mode in any other way should cancel that, too,
+ ;; Canceling View mode in any other way should cancel that, too,
;; so that View mode stays off if toggle-read-only is called.
(if (local-variable-p 'view-read-only)
(kill-local-variable 'view-read-only))
(error "Canceled"))
value))))
-(defun widget-remove-if (predictate list)
+(defun widget-remove-if (predicate list)
(let (result (tail list))
(while tail
- (or (funcall predictate (car tail))
+ (or (funcall predicate (car tail))
(setq result (cons (car tail) result)))
(setq tail (cdr tail)))
(nreverse result)))
"Map FUNCTION over the buttons in BUFFER.
FUNCTION is called with the arguments WIDGET and MAPARG.
-If FUNCTION returns non-nil, the walk is cancelled.
+If FUNCTION returns non-nil, the walk is canceled.
The arguments MAPARG, and BUFFER default to nil and (current-buffer),
respectively."
PREDICATE on each one of them with the window as its sole
argument. Return the first window for which PREDICATE returns
non-nil. Windows are scanned starting with the window following
-the selcted window. If no window satisfies PREDICATE, return
+the selected window. If no window satisfies PREDICATE, return
DEFAULT.
MINIBUF t means include the minibuffer window even if the
;; This `condition-case' shouldn't be necessary, but who knows?
(condition-case nil
(if (zerop delta)
- ;; Return zero if DELTA became zero in the proces.
+ ;; Return zero if DELTA became zero in the process.
0
;; Don't try to redisplay with the cursor at the end on its
;; own line--that would force a scroll and spoil things.
MB_OKCANCEL | MB_ICONQUESTION);
if (result != IDOK)
{
- fprintf (stderr, "Install cancelled\n");
+ fprintf (stderr, "Install canceled\n");
exit (1);
}
}
return 0;
}
-
* w32fns.c (current_popup_menu): Use from w32menu.c.
(w32_wnd_proc) <WM_EXITMENULOOP, WM_TIMER>: Use menubar_active
and current_popup_menu to determine whether a menubar menu has
- been cancelled.
+ been canceled.
* w32term.h (w32_output): Remove menu_command_in_progress.
* font.c (font_prop_validate_symbol, font_prop_validate_style)
(font_prop_validate_non_neg, font_prop_validate_spacing):
Delete argument prop_index.
- (font_property_table): Change arguments to validater. Change Callers.
+ (font_property_table): Change arguments to validator. Change Callers.
(font_lispy_object): Delete.
(font_at): Use font_find_object instead fo font_lispy_object.
1987-03-13 Richard M. Stallman (rms@prep)
* sysdep.c: Don't redefine TCSETAW if already defined.
- (Cancelled by change on March 17).
+ (Canceled by change on March 17).
* sunfns.c: New file containing interface to Sun windows.
This is enabled by the switch HAVE_SUN_WINDOWS.
quit_char is typed, in order to break out of potential deadlocks.
(cancel_all_deferred_msgs): New function.
(complete_deferred_msg): Don't abort if msg not found; may have
- been cancelled.
+ been canceled.
(Fw32_reconstruct_hot_key): Use pre-interned symbols.
(Fw32_send_sys_command): Wait for system command to
complete before returning.
* ccl.c (CCL_WRITE_CHAR): Don't use bcopy.
(ccl_driver): If BUFFER-MAGNIFICATION of the CCL program is 0,
cause error if the program is going to output some bytes. When
- outputing a string to notify an error, check the case that
+ outputting a string to notify an error, check the case that
DST_BYTES is zero.
* coding.h (CODING_FINISH_INTERRUPT): New macro.
But, when VALm is mapped to VALn and VALn is not a number, the
mapping proceed as below:
- If VALn is nil, the lastest map is ignored and the mapping of VALm
+ If VALn is nil, the last map is ignored and the mapping of VALm
proceed to the next map.
In VALn is t, VALm is reverted to reg[rrr] and the mapping of VALm
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
-/* Holds the minimum and maximum costs for the parametrized capabilities. */
+/* Holds the minimum and maximum costs for the parameterized capabilities. */
struct parmcap
{
int mincost, maxcost;
struct parmcap cc_multiright; /* multiple right (RI) */
#endif
- /* Costs for the non-parametrized capabilities */
+ /* Costs for the non-parameterized capabilities */
int cc_up; /* cost for up */
int cc_down; /* etc. */
int cc_left;
-/* A Gtk Widget that inherits GtkFixed, but can be shrinked.
+/* A Gtk Widget that inherits GtkFixed, but can be shrunk.
This file is only use when compiling with Gtk+ 3.
Copyright (C) 2011 Free Software Foundation, Inc.
-/* A Gtk Widget that inherits GtkFixed, but can be shrinked.
+/* A Gtk Widget that inherits GtkFixed, but can be shrunk.
This file is only use when compiling with Gtk+ 3.
Copyright (C) 2011 Free Software Foundation, Inc.
A value of `(t)' indicates an empty environment, otherwise it is an
alist of active lexical bindings. */);
Vinternal_interpreter_environment = Qnil;
- /* Don't export this variable to Elisp, so noone can mess with it
+ /* Don't export this variable to Elisp, so no one can mess with it
(Just imagine if someone makes it buffer-local). */
Funintern (Qinternal_interpreter_environment, Qnil);
/* Function to validate PROP's value VAL, or NULL if any value is
ok. The value is VAL or its regularized value if VAL is valid,
and Qerror if not. */
- Lisp_Object (*validater) (Lisp_Object prop, Lisp_Object val);
+ Lisp_Object (*validator) (Lisp_Object prop, Lisp_Object val);
} font_property_table[] =
{ { &QCtype, font_prop_validate_symbol },
{ &QCfoundry, font_prop_validate_symbol },
if (idx < 0)
return val;
}
- validated = (font_property_table[idx].validater) (prop, val);
+ validated = (font_property_table[idx].validator) (prop, val);
if (EQ (validated, Qerror))
signal_error ("invalid font property", Fcons (prop, val));
return validated;
range_mask = (range_mask << 1) | 1;
/* The triplet RANGE_FROM, RANGE_TO, and RANGE_MASK is a
- position-based retriction for FIELD[I]. */
+ position-based restriction for FIELD[I]. */
for (i = 0, range_from = 0, range_to = 14 - n; i < n;
i++, range_from++, range_to++, range_mask <<= 1)
{
else
{
/* The triplet FROM, TO, and MASK is a value-based
- retriction for FIELD[I]. */
+ restriction for FIELD[I]. */
int from, to;
unsigned mask;
These structures are hidden from the other codes than this file.
The other codes handle fontsets only by their ID numbers. They
usually use the variable name `fontset' for IDs. But, in this
- file, we always use varialbe name `id' for IDs, and name `fontset'
+ file, we always use variable name `id' for IDs, and name `fontset'
for an actual fontset object, i.e., char-table.
*/
FOCUS-FRAME after reading an event typed at FRAME.
If FOCUS-FRAME is omitted or nil, any existing redirection is
-cancelled, and the frame again receives its own keystrokes.
+canceled, and the frame again receives its own keystrokes.
Focus redirection is useful for temporarily redirecting keystrokes to
a surrogate minibuffer frame when a frame doesn't have its own
DEFVAR_LISP ("debug-on-event",
Vdebug_on_event,
doc: /* Enter debugger on this event. When Emacs
-receives the special event specifed by this variable, it will try to
+receives the special event specified by this variable, it will try to
break into the debugger as soon as possible instead of processing the
event normally through `special-event-map'.
#endif /* AIX */
/* We originally enabled ICANON (and set VEOF to 04), and then had
- proces.c send additional EOF chars to flush the output when faced
+ process.c send additional EOF chars to flush the output when faced
with long lines, but this leads to weird effects when the
subprocess has disabled ICANON and ends up seeing those spurious
extra EOFs. So we don't send EOFs any more in
deferred_msg * msg_buf = find_deferred_msg (hwnd, msg);
if (msg_buf == NULL)
- /* Message may have been cancelled, so don't abort. */
+ /* Message may have been canceled, so don't abort. */
return;
msg_buf->result = result;
the lisp thread to respond.
Note that we don't want to block the input thread waiting for
- a reponse from the lisp thread (although that would at least
+ a response from the lisp thread (although that would at least
solve the deadlock problem above), because we want to be able
to receive C-g to interrupt the lisp thread. */
cancel_all_deferred_msgs ();
flags |= TPM_RIGHTBUTTON;
/* Remember we did a SetCapture on the initial mouse down event,
- so for safety, we make sure the capture is cancelled now. */
+ so for safety, we make sure the capture is canceled now. */
ReleaseCapture ();
button_state = 0;
Otherwise TYPE is the name of the atom that denotes the type expected.
If SOURCE is non-nil, get the property on that window instead of from
FRAME. The number 0 denotes the root window.
-If DELETE_P is non-nil, delete the property after retreiving it.
+If DELETE_P is non-nil, delete the property after retrieving it.
If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
Value is nil if FRAME hasn't a property with name PROP or if PROP has
file = DECODE_FILE (build_string (filename));
}
- /* User cancelled the dialog without making a selection. */
+ /* User canceled the dialog without making a selection. */
else if (!CommDlgExtendedError ())
file = Qnil;
/* An error occurred, fallback on reading from the mini-buffer. */
{
/* Values for focus_state, used as bit mask.
EXPLICIT means we received a FocusIn for the frame and know it has
- the focus. IMPLICIT means we recevied an EnterNotify and the frame
+ the focus. IMPLICIT means we received an EnterNotify and the frame
may have the focus if no window manager is running.
FocusOut and LeaveNotify clears EXPLICIT/IMPLICIT. */
FOCUS_NONE = 0,
/* Return a pointer to the glyph W's physical cursor is on. Value is
- null if W's current matrix is invalid, so that no meaningfull glyph
+ null if W's current matrix is invalid, so that no meaningful glyph
can be returned. */
struct glyph *
get_phys_cursor_glyph (struct window *w)
extern void check_frame_size (struct frame *frame, int *rows, int *cols);
/* Return a pointer to the glyph W's physical cursor is on. Value is
- null if W's current matrix is invalid, so that no meaningfull glyph
+ null if W's current matrix is invalid, so that no meaningful glyph
can be returned. */
struct glyph *get_phys_cursor_glyph (struct window *w);
}
-/* Push the current message on Vmessage_stack for later restauration
+/* Push the current message on Vmessage_stack for later restoration
by restore_message. Value is non-zero if the current message isn't
empty. This is a relatively infrequent operation, so it's not
worth optimizing. */
Otherwise TYPE is the name of the atom that denotes the type expected.
If SOURCE is non-nil, get the property on that window instead of from
FRAME. The number 0 denotes the root window.
-If DELETE_P is non-nil, delete the property after retreiving it.
+If DELETE_P is non-nil, delete the property after retrieving it.
If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
Value is nil if FRAME hasn't a property with name PROP or if PROP has
{
/* Values for focus_state, used as bit mask.
EXPLICIT means we received a FocusIn for the frame and know it has
- the focus. IMPLICIT means we recevied an EnterNotify and the frame
+ the focus. IMPLICIT means we received an EnterNotify and the frame
may have the focus if no window manager is running.
FocusOut and LeaveNotify clears EXPLICIT/IMPLICIT. */
FOCUS_NONE = 0,
this
that)
-(define-mode-local-override a-overriden-function
+(define-mode-local-override a-overridden-function
emacs-lisp-mode (tag)
"A function that is overloaded."
nil)
HCoop / bpt / emacs.git / commitdiff