Converted by xy-reference.l at 07/12/25 01:20:39
======================================================================
*
[       type]: Function
[  arguments]: * &rest NUMBERS
[    package]: lisp
[    seealso]: /
[       file]: builtin.l
[    section]: l
[description]: 
SďZlԂ܂B

gpF  
  (* 1 2 3)
  => 6


*activate-hook*
[       type]: Variable
[    package]: editor
[    seealso]: verify-buffers-file-modtime , *deactivate-hook*
[    section]: ϐƒ萔
[description]: 
obt@activateꂽƂɔCӂ̏s߂Ɏgp܂B
ftHgł̓t@C̏CtmFĂ܂B


*after-save-buffer-hook*
[       type]: Variable
[    package]: editor
[    seealso]: save-buffer
[    section]: ϐƒ萔
[description]: 
 save-buffer ̍ŌɎs܂B


*apropos-no-regexp*
[       type]: Variable
[    package]: editor
[    seealso]: apropos
[       file]: help.l
[    section]: V{
[description]: 
non-nil ɐݒ肷ƁAapropos sɁAK\̃^̓GXP[v
܂BftHg nil łB


*auto-encoding-alist*
[       type]: Variable
[    package]: editor
[    seealso]: *find-file-no-auto-encoding* , find-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
GR[fBOp̘AzXgłB(key . datum) ̑gœo^܂B
find-file ܂ find-file-read-only ̍ۂ ENCODING w肳ꂸA
*find-file-no-auto-encoding*  nil ̎A
(string-matchp key filename)  non-nil ƂȂꍇAdatum funcall܂B
datum ɂ̓GR[fBO̓GR[fBO\Ԃ֐w肵܂B


*auto-fill-hook
[       type]: Variable
[    package]: editor
[    seealso]: auto-fill-mode , auto-fill-hook , self-insert-command , funcall
[       file]: cmds.l
[    section]: ϐƒ萔
[description]: 
auto-fill-mode ̎ɁAself-insert-command  *last-command-char*
ƂĎs܂Bʂ do-auto-fill ݒ肳Ă܂B
CȂǂƎv܂B
 run-hooks ł͂ȂA funcall ̂Œӂ邱


*auto-mode-alist*
[       type]: Variable
[    package]: editor
[    seealso]: *find-file-auto-mode-function* , *auto-mode-parameter-alist*
[       file]: defs.l
[    section]: [h
[description]: 
[hp̘AzXgłB(key . datum)̑gœo^܂B
(string-matchp key filename)non-nilɂȂꍇɁA
datumfuncall܂B

datumdecode-auto-modẽvpeB݂ꍇɂ́Aobt@
ɂdatumfuncall܂B
cc-mode.ldecode-c-modeQ

gpF
  (pushnew '("\\.asp" . basic-mode) *auto-mode-alist* :test 'equal)


*auto-mode-parameter-alist*
[       type]: Variable
[    package]: editor
[    seealso]: *find-file-auto-mode-function* , *auto-mode-alist* , *buffer-package* , find-file
[       file]: files.l
[    section]: [h
[description]: 
t@C̐擪̃p[^ɑ΂As֐w肷 alist łB
 ( . ֐) ƂȂĂ܂B

t@C̐擪Ƀp[^ -*- aaa: bbb -*- ꍇA
"aaa"  string-equal ȕ *auto-mode-parameter-alist* ɓo^Ă΁A
Ή֐ "bbb" ɂ funcall ܂B

ftHgl
  '(("mode" . find-file-auto-mode)
    ("package" . find-file-buffer-package))
łB


*auto-update-per-device-directory*
[       type]: Variable
[    package]: lisp
[    seealso]: set-per-device-directory
[    section]: t@CVXe
[description]: 
t@CňړƂɃhCũftHg̃fBNgɂĐ䂵܂B

  t   ړ邽тɍXV
  nil set-perdevice-directoryŎw肵fBNgɌŒ肷


*before-delete-buffer-hook*
[       type]: Variable
[    package]: editor
[    seealso]: delete-buffer , *delete-buffer-hook*
[    section]: ϐƒ萔
[description]: 
delete-bufferp邩ǂ𐧌䂵܂Bo^ꂽ֐
łnilԂdelete-buffer𒆎~܂B

QlF
  ;;; Ăяo
  (run-hook-with-args-until-success
       '*before-delete-buffer-hook* (selected-buffer))

gpF
  (add-hook '*before-delete-buffer-hook* 'func)
  =>(func)
  (defun func (x) (yes-or-no-p "delete-buffer ~A ?" (buffer-name x)))
  =>func


*before-find-file-hook*
[       type]: Variable
[    package]: editor
[    seealso]: find-file
[   referred]: ed::find-file-internal
[       file]: files.l
[    section]: ϐƒ萔
[description]: 
find-file̍ŏŎs܂B
run-hook-with-args-until-successŎŝŒӂ邱


*before-save-buffer-hook*
[       type]: Variable
[    package]: editor
[    seealso]: save-buffer , run-hook-with-args-until-success
[    section]: ϐƒ萔
[description]: 
 save-buffer ̍ŏɎs܂B
 run-hook-with-args-until-success ŎŝŒӂ邱


*brackets-is-wildcard-character*
[       type]: Variable
[    package]: lisp
[    seealso]: wild-pathname-p , pathname-match-p
[    section]: ϐƒ萔
[description]: 
non-nil Ȃ΃t@CpXƂēn񒆂 [...] Ch[J[
hƂĈ܂B
[ʐݒ] - [܂] - [[...]̓ChJ[h(I)] Œlw肷邱
ł܂B
xyzzy \[XŒ`ĂAftHgl t łB
̓Iɂ́Awild-pathname-p, pathname-match-p ֐ł̔̍ۂ
*brackets-is-wildcard-character* ̒ll܂B


*buffer-bar-context-menu*
[       type]: Variable
[    package]: editor
[   referred]: *buffer-bar-context-menu-handler*
[       file]: buffer.l
[    section]: obt@
[description]: 
obt@Eo[ŉENbNƂɏoĂReLXgj[łB
define-popup-menu ō쐬Ă܂Bi쐬 app-menu.lj


*buffer-bar-context-menu-buffer*
[       type]: Variable
[    package]: editor
[       file]: buffer.l
[    section]: obt@
[description]: 
obt@o[őIĂobt@łBAobt@o[
ReLXgj[Ŏ擾p炢gpł܂B


*buffer-bar-context-menu-handler*
[       type]: Variable
[    package]: editor
[    seealso]: *buffer-bar-context-menu*
[       file]: buffer.l
[    section]: obt@
[description]: 
ftHg̃obt@o[pReLXgj[nhłB
setq-default ɂĒ`ĂW̓́A 
*buffer-bar-context-menu-buffer* `A*buffer-bar-context-menu* 
Ԃ܂B


*buffer-bar-selected-buffer-to-first*
[       type]: Variable
[    package]: editor
[    section]: obt@
[description]: 
non-nil ȂAIꂽobt@obt@o[ňԐ擪ɂȂ܂B
L[Ń^uړꍇ͈ړ܂BftHg nil łB
(setq *buffer-bar-selected-buffer-to-first* t) ƂāAobt@o[
NbNΕƎv܂B


*buffer-info-variable-list*
[       type]: Variable
[    package]: editor
[    seealso]: save-session
[       file]: session.l
[    section]: obt@
[description]: 
ZbVt@CɕۑĂobt@[Jϐ̃XgłB

̃XgɊ܂܂ϐ̃obt@Ƃ̒l̓ZbVt@Cɕۑ
A[hۂɕ܂B(mɂ́Aobt@[JɂȂĂ
ꍇ̃obt@̏Ƃĕۑ܂)


*buffer-menu-mode-hook*
[       type]: Variable
[    package]: editor
[       file]: buf-menu.l
[    section]: j[
[description]: 
buffer-menűNɎs܂B

QlF
  (run-hooks '*buffer-menu-mode-hook*)


*buffer-package*
[       type]: BufferLocal
[    package]: editor
[    seealso]: *auto-mode-parameter-alist*
[       file]: lispmode.l
[    section]: obt@
[description]: 
t@C̐擪̃p[^Xg Package Ŏw肵pbP[W
܂B


*change-buffer-colors-hook*
[       type]: Variable
[    package]: editor
[    section]: ϐƒ萔
[description]: 
r


*char-encoding-list*
[       type]: Variable
[    package]: editor
[   referred]: read-char-encoding , set-buffer-fileio-encoding
[       file]: encoding.l
[    section]: eLXg
[description]: 
GR[fBÕXgłB~jobt@͕̓⊮̃Xg
 file-name-dialog ̃GR[fBÕXgƂĎgꂽ肷݂
łB
GR[fBO̓NI[gĂ͂Ȃ݂ł̂ŁA`Ȃ
͒ӂĂB


*command-line-mailto-hook*
[       type]: Variable
[    package]: editor
[    seealso]: Nt[
[       file]: estartup.l
[    section]: ϐƒ萔
[description]: 
R}hCŎw肳ꂽ -mailto IvV̈Ɏs܂B 
run-hooksł͂Ȃfuncall̂Œӂ邱


*command-output-mode-hook*
[       type]: Variable
[    package]: editor
[       file]: process.l
[    section]: [h
[description]: 
execute-subprocess̒command-output-modeNɎs܂B


*create-buffer-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *default-buffer-mode* , create-new-buffer
[    section]: ϐƒ萔
[description]: 
create-new-bufferŎs܂B


*dabbrev-search-this-buffer-only*
[       type]: Variable
[    package]: editor
[    seealso]: dabbrev-expand
[       file]: dabbrev.l
[    section]: eLXg
[description]: 
dabbrev-expanďΏۂݒ肵܂B

  t   Jgobt@݂̂܂
  nil Sobt@܂


*dabbrevs-no-undo*
[       type]: Variable
[    package]: editor
[    seealso]: undo , dabbrev-expand
[       file]: defs.l
[    section]: obt@
[description]: 
dabbrev-expandundo̕@ݒ肵܂B
dabbrev-expandsȂۂɌ₪}܂...
  non-nil  dabbrev-expand̒O܂ňCɎ
  nil      ȓ}ߒԂɎ


*deactivate-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *activate-hook*
[    section]: ϐƒ萔
[description]: 
obt@deactivateꂽƂɔCӂ̏s߂Ɏgp
BftHgł̓Nbv{[h̓sĂ܂B


*default-buffer-mode*
[       type]: Variable
[    package]: editor
[   referred]: *create-buffer-hook*
[       file]: defs.l
[    section]: obt@
[description]: 
Vobt@쐬ꍇ̃[hw肵܂B
Ⴆ΁Alisp-modew肵Ă΁AV쐬obt@͑Slisp-mode
ɂȂ܂B

gpF  
  (setq *default-buffer-mode* 'lisp-mode)
  => lisp-mode
  (switch-to-buffer "*new*")
  => #<buffer: *new*>
  buffer-mode
  => lisp-mode


*default-eol-code*
[       type]: Variable
[    package]: editor
[    seealso]: buffer-eol-code , *default-fileio-encoding*
[    section]: obt@
[description]: 
VKɍobt@̉sR[h̃ftHglłB


*default-fileio-encoding*
[       type]: Variable
[    package]: editor
[    seealso]: buffer-fileio-encoding , *default-eol-code*
[    section]: obt@
[description]: 
VKɍobt@̕GR[fBÕftHglłB


*default-load-path*
[       type]: Variable
[    package]: editor
[    seealso]: *load-path*
[       file]: misc.l
[    section]: ϐƒ萔
[description]: 
siteinit.l*load-path*C邽߂ɗp܂B
siteinit.l̒*default-load-path*̓eA*load-path*Ƀ}[
WA*pre-startup-hook*LɂȂ܂B
ǉpX̓XgŐݒ肵܂B

gpF
  (setq *default-load-path* '("C:/APPLICATIONS/XYZZY/lib"))


*default-session-directory*
[       type]: Variable
[    package]: editor
[    seealso]: load-session , save-session , ed::session-directory
[       file]: session.l
[    section]: obt@
[description]: 
ZbVt@C̕ۑE[h̍ۂɃt@CǂނƂɃftHg
ŕ\fBNgłB


*default-write-file-directory*
[       type]: Variable
[    package]: editor
[    seealso]: emacs-write-file , write-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
write-file  emacs-write-file ̃ftHg̃fBNgw肵܂B


*delete-buffer-hook*
[       type]: Variable
[    package]: editor
[    seealso]: delete-buffer , *before-delete-buffer-hook*
[    section]: ϐƒ萔
[description]: 
delete-bufferŎs܂B


*diff-mode-hook*
[       type]: Variable
[    package]: editor
[       file]: diff.l
[    section]: [h
[description]: 
diffNɎs܂B


*do-completion
[       type]: Function
[  arguments]: *do-completion STRING TYPE &optional WORDP LIST
[    package]: editor
[       file]: builtin.l
[    section]: eLXg
[description]: 
w肵ɏ]⊮܂B

  STRING : ⊮
  TYPE   : ⊮^
        :symbol-name
        :function-name
        :command-name
        :variable-name
        :non-trivial-symbol-name
        :exist-file-name
        :file-name
        :file-name-list
        :directory-name
        :buffer-name
        :exist-buffer-name
        :list
        :list-ignore-case
  WORD   : nilłȂΒPꂲƂ̕⊮
  LIST   : TYPE  :list  :list-ignore-case ̏ꍇ̕⊮Xg

߂l͈ȉ̂ƂłB

  l3̒l߂Ă܂̂ŁAmultiple-value-bind Ŏ󂯎Ƃ
  ł傤Bcomplete.l̒ɂ do-completion-internal QlɂĂ
  Bȉ͏ꍇĂ܂B

        [1] ⊮̌₪݂Ȃꍇ     :no-completions  nil
        [2] }b`₪Ȃꍇ   :no-match  nil
        [3] ^ꂽ񂪂łɌ
            ꂩƈvĂ
            ⊮KvȂꍇ
            [3.1] v₪   :solo-match  list  prefix
            [3.2] ƈvꍇ       :not-unique  list  prefix
        [4] ⊮ꍇ                   ⊮ʂ̕ list  prefix

  list ́AṽXgB
  prefix ́AႦ΃t@C̕⊮̂Ƃ̃fBNgƂA
  V{̕⊮̂Ƃ̃pbP[WCƂB


*drag-and-drop-hook*
[       type]: Variable
[    package]: editor
[       file]: mouse.l
[    section]: ϐƒ萔
[description]: 
D&DɎs܂BftHgł́AD&D悪~jobt@
Ȃ~jobt@ւ̓͂ƂĈAȊOȂfind-file
悤ɂȂĂ܂B

run-hooksł͂Ȃfuncall܂B2ŁAhbvꂽEBh
  Eƃhbvt@C̃XgłB


*enter-minibuffer-hook*
[       type]: Variable
[    package]: editor
[    section]: ~jobt@
[description]: 
~jobt@ɓƂɎs܂B(interactive...)Ŏw肳
ꂽn܂B


*eol-cr*
[       type]: Variable
[    package]: editor
[    seealso]: *eol-lf* , *eol-crlf* , set-buffer-eol-code
[       file]: encoding.l
[    section]: o
[description]: 
sR[hCR\lłB
vZXobt@̓o͂̉sR[hݒ肷̂Ɏgp܂B


*eol-crlf*
[       type]: Variable
[    package]: editor
[    seealso]: *eol-cr* , *eol-lf* , set-buffer-eol-code
[       file]: encoding.l
[    section]: o
[description]: 
sR[hCRLF\lłB
vZXobt@̓o͂̉sR[hݒ肷̂Ɏgp܂B


*eol-lf*
[       type]: Variable
[    package]: editor
[    seealso]: *eol-cr* , *eol-crlf* , set-buffer-eol-code
[       file]: encoding.l
[    section]: o
[description]: 
sR[hLF\lłB
vZXobt@̓o͂̉sR[hݒ肷̂Ɏgp܂B


*error-regexp-list*
[       type]: Variable
[    package]: editor
[    seealso]: next-error , first-error
[       file]: errors.l
[    section]: G[
[description]: 
first-error/next-errorŎgpG[ʒu̕\L`ύX邱Ƃ\łB
*error-regexp-list*̌`͈ȉ̂ƂłB

  ((K\1 t@C̃}b`ʒu1 s̃}b`ʒu1)
   (K\2 t@C̃}b`ʒu2 s̃}b`ʒu2)
    ...
   (K\N t@C̃}b`ʒuN s̃}b`ʒuN))

[xyzzy:05447]ŋT䂳񂪎ĂƂApushgĒǉ̂łB
(push (list (compile-regexp "^\"\\([^\"\n]+\\)\", line \\([0-9]+\\):") 1 2)
      *error-regexp-list*)


*etc-path*
[       type]: Variable
[    package]: editor
[    seealso]: etc-path
[   referred]: *keyword-load-path*
[       file]: misc.l
[    section]: ϐƒ萔
[description]: 
L[[ht@Ci[pXݒ肳Ă܂B
Wł(merge-pathnames "etc" (si:system-root))ݒ肳Ă܂B

QƗF
  *etc-path*
  => "C:/APPLICATIONS/XYZZY/etc"


*executing-macro*
[       type]: Variable
[    package]: editor
[       file]: cmds.l
[    section]: }N
[description]: 
}NsۂԂ܂B
  t    }Ns
  nil  }Nsł͂Ȃ


*exit-minibuffer-hook*
[       type]: Variable
[    package]: editor
[    section]: ~jobt@
[description]: 
~jobt@oƂɎs܂B


*features*
[       type]: Variable
[    package]: lisp
[    seealso]: featurep
[    section]: VXe
[description]: 
̓\L[[hXgƂĊi[Ă܂B
#+  #- ̕]ɉe܂B

gpF
  (+ 2 #+xyzzy 3 #+foo 4)
  => 5
  (push :foo *features*)
  => (:foo :windows-me :windows-98 :xyzzy :ieee-floating-point)
  (+ 2 #+xyzzy 3 #+foo 4)
  => 9
  (pop *features*)
  => :foo
  (+ 2 #+xyzzy 3 #+foo 4)
  => 5


*filer-chdir-hook*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
it@CŃfBNgύXꂽ肷Ǝs܂Bprsj 


*filer-chdir-primary-p*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
iڍוsj


*filer-click-toggle-marks-always*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
nilȂAt@CōNbNƂÄʒuɃJ[\ꍇ
݃}[N𔽓]܂B
non-nil ȂAJ[\̈ړƃ}[N̔]̗𓯎ɍs܂B
ftHg t łB


*filer-directories*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[       file]: filer.l
[    section]: t@C
[description]: 
t@C̃Wvp̃fBNgAzXgŐݒ肵܂B

gpF
  (setq *filer-directories*
      '((" [fXNgbv]" . "c:/windows/fXNgbv")
        (" [Xv[]" . "c:/spool")))


*filer-drag-and-drop-helper
[       type]: Function
[  arguments]: *filer-drag-and-drop-helper EFFECT FILES SRC DEST
[    package]: editor
[       file]: filer.l
[    section]: t@C
[description]: 
iڍוsj


*filer-dual-window*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
~jobt@ȂǂŃfBNg͂ɗオt@CI
܂B nil Ȃʃt@CAnon-nil Ȃʃt@CN܂B
ftHg nil łB


*filer-eat-esc*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
nilȂA[hXt@CESCĂ܂B
ftHg t łB


*filer-echo-filename*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[    section]: t@C
[description]: 
irj
t@C̃Xe[^XEBhEւ̃t@C̕\𐧌䂵܂B
t@C̕\͉ɂȂƂɍsȂĂ悤łB
  non-nil  ɂȂƂɕ\
  nil      \Ȃ


*filer-format-comma*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
non-nilȂAt@CTCYJ}؂ŕ\܂B
[ʐݒ] - [t@C] - [t@CTCYJ}؂ŕ\(C)] Œl
w肷邱Ƃł܂B


*filer-guide-text*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[    section]: t@C
[description]: 
t@Cɕ\KCheLXgݒ肵܂B

gpF
  (setq *filer-guide-text*
      '("(A)ttribute  (B)yteCompile  (C)opy  (D)elete  (E)xtract  (F)ind"
        "(G)o  (J)ump  m(K)dir  <L>Cd  (M)ove  re(N)ame"))


*filer-last-command-char*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
t@CɂăR}hsɍŌɓ͂ꂽ܂B


*filer-last-file-mask*
[       type]: Variable
[    package]: editor
[    seealso]: *filer-primary-file-mask* , *filer-secondary-file-mask*
[    section]: t@C
[description]: 
ʃt@C̏̃t@C}XNXgŐݒ肵܂B


*filer-left-window-p*
[       type]: Variable
[    package]: editor
[    section]: t@C
[description]: 
ʃt@CƂAǂ̃EBhEANeBuۑ
܂Bt@CN̒l t łB

  nil     : ẼEBhE
  non-nil : ̃EBhE


*filer-mark-file-size-unit*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[    section]: t@C
[description]: 
t@C̃}[Nt@C̍vTCY̒Pʂw肵܂B
#\B, #\K, #\M, #\G, #\T̉ꂩw\łBAႦ#\K
ݒ肳ꂽƂATCY1KȂoCgPʂɂȂ܂BftH
głnilɐݒ肳Ă܂B

gpF
  (setq *filer-mark-file-size-unit* #\M)


*filer-modal*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[       file]: filer.l
[    section]: t@C
[description]: 
t@C̓w肵܂B

[_̏ꍇɂ́At@C̓GfB^Ƃ͓Iɓ삵܂B
t@CN̓GfB^ł̕ҏW͕s\łB
[hX̏ꍇɂ́At@C̓GfB^Ƃ͔񓯊ɓ삵܂B
t@CNɃGfB^ł̕ҏW\łB

  t   [_œ삳܂
  nil [hXœ삳܂


*filer-path-masks*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[       file]: filer.l
[    section]: t@C
[description]: 
t@C̃t@C}XNݒ肵܂B

gpF
  (pushnew '("Microsoft" "*.doc" "*.xls" "*.ppt" "*.sys" "*.bat" "*.ini")
           *filer-path-masks* :test 'equal)


*filer-primary-directory*
[       type]: Variable
[    package]: editor
[    seealso]: *filer-secondary-directory*
[   referred]: filer
[    section]: t@C
[description]: 
ʃt@C̃ANeBuȕ̃fBNg܂B
E *filer-left-window-p* ̒lɂČ܂܂B
t@CÑ͍fBNgwł܂B

gpF
  ; [xyzzy:07218]
  ; ɃJgfBNgt@CNB
  (defun foo ()
    (interactive)
    (let ((*filer-primary-directory* nil)
          (*filer-secondary-directory* nil))
      (open-filer)))


*filer-primary-file-mask*
[       type]: Variable
[    package]: editor
[    seealso]: filer , *filer-secondary-file-mask*
[   referred]: *filer-last-file-mask*
[    section]: t@C
[description]: 
t@C̏̃t@C}XNXgŐݒ肵܂B

gpF
  (setq *filer-primary-file-mask* '("*"))


*filer-retrieve-icon*
[       type]: Variable
[    package]: editor
[       file]: filer.l
[    section]: t@C
[description]: 
non-nil ̂ƂAt@CŃt@C^CvɉACR\܂B
[ʐݒ] - [t@C] - [ACRt@CĂ(I)] Œlw
肷邱Ƃł܂B


*filer-secondary-directory*
[       type]: Variable
[    package]: editor
[    seealso]: *filer-primary-directory*
[   referred]: filer
[    section]: t@C
[description]: 
ʃt@C̃ANeBułȂ̃fBNg܂B
E *filer-left-window-p* ̒lɂČ܂܂B
t@CN͉ẼfBNgwł܂B


*filer-secondary-file-mask*
[       type]: Variable
[    package]: editor
[    seealso]: *filer-primary-file-mask* , filer
[   referred]: *filer-last-file-mask*
[    section]: t@C
[description]: 
t@CȄ̃t@C}XNXgŐݒ肵܂B

gpF
  (setq *filer-secondary-file-mask* '("*"))


*filer-use-recycle-bin*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[       file]: filer.l
[    section]: t@C
[description]: 
t@CŃt@C̍폜ɃS~gp邩ݒ肵܂B
  non-nil  t@Cō폜Ƃ̓S~s
  nil      ڍ폜


*find-file-auto-mode-function*
[       type]: Variable
[    package]: editor
[    seealso]: *auto-mode-parameter-alist* , *auto-mode-alist* , find-file
[   referred]: ed::find-file-internal
[       file]: files.l
[    section]: [h
[description]: 
find-file ̍ۂɃ[hݒ肷邽߂̊֐o^܂B

t@C̐擪̃p[^i-*- Mode: LISP -*- Ȃǁj 
*auto-mode-alist* D悳܂B


*find-file-file-not-found-hook*
[       type]: Variable
[    package]: editor
[    seealso]: find-file , run-hook-with-args-until-success
[   referred]: ed::find-file-internal
[       file]: files.l
[    section]: ϐƒ萔
[description]: 
find-file Ŏw肳ꂽt@C݂ȂƂɎs܂B
run-hook-with-args-until-successŎŝŒӂ邱


*find-file-hooks*
[       type]: Variable
[    package]: editor
[    seealso]: *find-file-read-only-hook* , find-file-read-only , find-file
[   referred]: ed::find-file-internal
[       file]: files.l
[    section]: t@CVXe
[description]: 
find-file  find-file-read-only ŐVt@CJтɁAŌɎs܂B
łɃt@CJĂobt@݂ꍇɂ͎s܂B


*find-file-no-auto-encoding*
[       type]: Variable
[    package]: editor
[    seealso]: *auto-encoding-alist* , find-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
non-nil ȂA*auto-encoding-alist* ɂGR[fBO̔肪sꂸA
t@C̐擪ɃGR[fBO(-*- Encoding: EUC-JP -*-Ȃ)Lq
ĂĂ܂B


*find-file-read-only-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *find-file-hooks* , find-file-read-only
[       file]: files.l
[    section]: t@CVXe
[description]: 
find-file-read-only Ńt@CƂɍŌɎs܂B
*find-file-hooks* ƈقȂAłɃt@CJĂꍇɂs܂B


*find-other-file-requires-file-name*
[       type]: Variable
[    package]: editor
[    seealso]: find-other-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
non-nil Ȃ find-other-file ̃vvgɌ݂̃obt@\܂B


*full-keymap-length*
[       type]: Variable
[    package]: editor
[    seealso]: make-keymap
[       file]: keymap.l
[    section]: L[}bv
[description]: 
make-keymap ōL[}bv̒łB


*gensym-counter*
[       type]: Variable
[    package]: lisp
[    seealso]: gensym
[       file]: evalmacs.l
[    section]: V{
[description]: 
gensym ōV{̖OɂłB
g邽тɃCNg܂B


*global-abbrev-table*
[       type]: Variable
[    package]: editor
[    seealso]: expand-abbrev , *local-abbrev-table* , define-abbrev-table
[       file]: abbrev.l
[    section]: eLXg
[description]: 
O[oabbrev-tableݒ肵܂B


*global-keymap*
[       type]: Variable
[    package]: editor
[    seealso]: global-set-key
[    section]: L[}bv
[description]: 
O[oȃL[}bvłB[h̃L[}bvɉ蓖ĂĂ
ȂꍇɎg܂B

global-set-key ͂̃L[}bvɃoCfBOZbg܂B


*gmark-keep-column*
[       type]: Variable
[    package]: editor
[       file]: gmark.l
[    section]: |WV
[description]: 
non-nil ȂAglobal-mark-goto  back-tag-jump ̈ړ̎ɍsֈړ
Ȃ悤ɂȂ܂B


*grep-directory-name-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *grep-hook*
[       file]: grepd.l
[    section]: ϐƒ萔
[description]: 
grep-dialoggrepΏۂ̃fBNgXɐݒ肵ꍇɎs
܂B
funcall̂Œӂ邱


*grep-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *grepd-hook*
[   referred]: *grep-directory-name-hook*
[       file]: grep.l
[    section]: ϐƒ萔
[description]: 
grepNɎs܂B


*grepd-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *grep-hook*
[       file]: grepd.l
[    section]: ϐƒ萔
[description]: 
grep-dialogNɎs܂B


*gresreg-directory-name-hook*
[       type]: Variable
[    package]: editor
[    seealso]: gresreg-dialog
[       file]: gresregd.l
[    section]: ϐƒ萔
[description]: 
gresreg-dialog  gresreg Ώۂ̃fBNgXɐݒ肵ꍇ
Ɏs܂B
funcallŎŝŒӂ邱


*history-file-name*
[       type]: Variable
[    package]: editor
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
qXgۑt@CłB
nil ̏ꍇ͊֐ history-file-name ɂ
KɌ肳܂B

:
  *history-file-name*
  =>"X:/xyzzy/usr/username/wxp/.xyzzy.history"


*ime-mode-hook*
[       type]: Variable
[    package]: editor
[    seealso]: toggle-ime
[    section]: [h
[description]: 
IME̐ؑւɌĂяo܂B


*inhibit-quit*
[       type]: Variable
[    package]: editor
[    seealso]: quit-char
[    section]: ϐƒ萔
[description]: 
̒l t ̂ƂA quit-char ͂Ă܂B


*init-app-menus-hook*
[       type]: Variable
[    package]: editor
[    seealso]: Nt[
[       file]: app-menu.l
[    section]: j[
[description]: 
xyzzysɎs܂B*app-menu*𒼐ڕύXprŗp
܂B

gpF
  (add-hook '*init-app-menus-hook*
            #'(lambda ()
                (add-menu-item *app-menu* 'close-box :close-box
                               #'kill-selected-buffer)))


*isearch-scanner-hook*
[       type]: Variable
[    package]: editor
[       file]: isearch.l
[    section]: EK\
[description]: 
isearch-scannerŎs܂Bscan-bufferp^[邱Ƃ
ołBmigemopH

QlF
  (funcall *isearch-scanner-hook* pattern)


*kbd-translate-table*
[       type]: Variable
[    package]: editor
[    seealso]: L[\gp\
[       file]: keyboard.l
[    section]: L[}bv
[description]: 
A͂ꂽIȃL[_IȃL[ɕϊ邽߂̂̂łB
̘_IȃL[́AF13`F24Ȃǂ̂悤ɑ݂ȂL[ɐU邱Ƃ
o܂BႦ΁AL[gbṽxɕʂ̃̕x\t悤
̂Ǝv܂B

  EIȃL[_IȃL[ւ̕ϊ
  E[JL[}bvɘ_IȃL[̐ݒ肪΃R}hs
  EO[oL[}bvɘ_IȃL[̐ݒ肪΃R}hs

gpF
  ;;; C-[  ESC ʕɂ
  (setf (svref *kbd-translate-table* (char-code #\C-[)) #\F15)
  (global-set-key #\F15 'xxxx)

  ;;; BSCtrl-hʕɂ
  (setf (svref *kbd-translate-table* (char-code #\C-h)) #\F13)
  (global-set-key #\F13 'replace-dialog)


*keyboard*
[       type]: Variable
[    package]: editor
[    seealso]: *standard-input*
[    section]: o
[description]: 
L[{[h̓͂\Xg[łB


*keyword-load-path*
[       type]: Variable
[    package]: editor
[    seealso]: load-keyword-file , *etc-path* , L[[ht@C̏
[       file]: kwd.l
[    section]: ϐƒ萔
[description]: 
L[[ht@C̃pXXgŐݒ肵܂B
w肳ꂽL[[ht@C̃Xg猩Ȃꍇɂ́A
etc-pathŎ擾pX܂B

gpF
  (setq *keyword-load-path* '("C:/Program Files/xyzzy/keyword"))


*kill-buffer-kills-scratch*
[       type]: Variable
[    package]: editor
[    seealso]: kill-buffer
[       file]: lispmode.l
[    section]: ϐƒ萔
[description]: 
*kill-buffer-kills-scratch*non-nil̏ꍇɂ́Akill-buffer
*scratch*폜\łBftHgnilɂȂĂ܂B


*kill-ring*
[       type]: Variable
[    package]: editor
[    seealso]: *kill-ring-max* , kill-region , yank , *selection-ring*
[   referred]: kill-line
[       file]: region.l
[    section]: [W
[description]: 
killi[܂B
*kill-ring*͒*kill-ring-max*ł郊Oobt@łB


*kill-ring-max*
[       type]: Variable
[    package]: editor
[   referred]: *kill-ring*
[       file]: region.l
[    section]: [W
[description]: 
killŕۑłB*kill-ring*̒łB


*kill-xyzzy-hook*
[       type]: Variable
[    package]: editor
[    seealso]: kill-xyzzy , *query-kill-xyzzy-hook*
[    section]: ϐƒ萔
[description]: 
xyzzy̏IɎs܂B


*last-command*
[       type]: Variable
[    package]: editor
[    seealso]: *this-command*
[    section]: ϐƒ萔
[description]: 
ŌɎsR}hĂ܂BO *this-command* ̒lݒ肳܂B


*lisp-popup-completion-list*
[       type]: Variable
[    package]: editor
[    seealso]: lisp-complete-symbol , *popup-completion-list-default*
[       file]: lispmode.l
[    section]: ϐƒ萔
[description]: 
lisp-complete-symbol ̕⊮|bvAbv\邩ݒ肵܂B 

:
  *lisp-popup-completion-list*
    :always   |bvAbv\
    :never    *Completion*obt@ŕ\

    *popup-completion-list-default*
      :always |bvAbv\
      :never  *Completion*obt@ŕ\

    non-nil   |bvAbv\
    nil       *Completion*obt@ŕ\


*load-history-hook*
[       type]: Variable
[    package]: editor
[    seealso]: Nt[
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
.xyzzyɎs܂BR}ho[AZbṼqXg
̓ǂݍ݂ɎgpĂ܂B


*load-path*
[       type]: Variable
[    package]: lisp
[    seealso]: si:*load-library , load-library , *default-load-path* , find-load-path
[    section]: ϐƒ萔
[description]: 
Cu[hpXXgŐݒ肳Ă܂B
ڃXgCAsiteinit.l *default-load-path* 
ɒǉD܂悤łB


*load-pathname*
[       type]: Variable
[    package]: lisp
[    section]: t@CVXe
[description]: 
ݓǂݍݒ̃t@Ci̓Xg[j܂B

load-fileŃoCh܂B


*local-abbrev-table*
[       type]: BufferLocal
[    package]: editor
[    seealso]: expand-abbrev , *global-abbrev-table* , define-abbrev-table
[       file]: abbrev.l
[    section]: eLXg
[description]: 
obt@Ƃabbrev-tableݒ肵܂B
ł̒`*global-abbrev-table*D悵Ďgp܂B


*make-backup-filename-hook*
[       type]: Variable
[    package]: editor
[       file]: backup.l
[    section]: ϐƒ萔
[description]: 
iGȂقƎv܂j 


*menu-display-length*
[       type]: Variable
[    package]: editor
[       file]: app-menu.l
[    section]: ϐƒ萔
[description]: 
j[́uŋߎgt@Cvŕ\t@CpX̒w肵܂B
ftHgł40łB


*minibuffer-buffer-name-history*
[       type]: Variable
[    package]: editor
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
~jobt@̃obt@̗łB


*minibuffer-directory-name-history*
[       type]: Variable
[    package]: editor
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
~jobt@̃fBNg̗łB


*minibuffer-execute-history*
[       type]: Variable
[    package]: editor
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
iڍוsj


*minibuffer-file-name-history*
[       type]: Variable
[    package]: editor
[    seealso]: add-file-history-to-menu
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
~jobt@̃t@C̗łB


*minibuffer-lisp-sexp-history*
[       type]: Variable
[    package]: editor
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
~jobt@S̗łB


*minibuffer-popup-completion-list*
[       type]: Variable
[    package]: editor
[    seealso]: *popup-completion-list-default*
[       file]: minibuf.l
[    section]: ~jobt@
[description]: 
~jobt@ŕ⊮Xg|bvAbv\邩ݒ肵܂B

gpF
  (setq *popup-completion-list-default* :always)
  (setq *minibuffer-popup-completion-list* :never)

F
  *minibuffer-popup-completion-list*
    :always   |bvAbv\
    :never    *Completion*obt@ŕ\
  
    *popup-completion-list-default*
      :always |bvAbv\
      :never  *Completion*obt@ŕ\
  
    non-nil   |bvAbv\
    nil       *Completion*obt@ŕ\


*minibuffer-save-ime-status*
[       type]: Variable
[    package]: editor
[    section]: ~jobt@
[description]: 
~jobt@IMȄԂ𐧌䂵܂B
  nil  ~jobt@IMȄԂۑ܂B
  t    ~jobt@IMȄԂۑ܂B


*minibuffer-search-string-history*
[       type]: Variable
[    package]: editor
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
~jobt@̗̌łB


*minibuffer-symbol-name-history*
[       type]: Variable
[    package]: editor
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
~jobt@̃V{̗łB


*minor-mode-alist*
[       type]: Variable
[    package]: editor
[    section]: [h
[description]: 
}Ci[hÎƂɃ[hCɕ\镶̘AzXgłB
evf car ̓V{A cdr ͕񂩃V{łB

car Ɏw肵V{̒l non-nil łāA cdr 񂩂܂͒l
ł悤ȃV{Ȃ΁A̕񂪃[hCɕ\܂B

gpF
  (pushnew '(edict-mode . "Edict") *minor-mode-alist* :key #'car)

  (pushnew '(async-grep-mode . async-grep-status)
           *minor-mode-alist* :key #'car)


*modal-filer-save-position*
[       type]: Variable
[    package]: editor
[    seealso]: *modal-filer-save-size*
[    section]: t@C
[description]: 
[_Ńt@C𓮍삳ĂƂ́At@CI̓ݒ肵܂B

  t   ʒuۑ܂
  nil ʒuۑ܂


*modal-filer-save-size*
[       type]: Variable
[    package]: editor
[    seealso]: filer
[   referred]: *modal-filer-save-position*
[    section]: t@C
[description]: 
[_Ńt@C𓮍삳ĂƂ́At@CI̓ݒ肵܂B

  t   傫ۑ܂
  nil 傫ۑ܂


*modules*
[       type]: Variable
[    package]: lisp
[    seealso]: provide , require , modulep , e탍[h֌W̊֐̈Ⴂ
[       file]: evalmacs.l
[    section]: VXe
[description]: 
[hꂽW[̈ꗗi[Ă܂B
(require "foo")ŎۂɃW[ǂݍނۂ*modules*ɓo^
邩ǂŌ܂܂BW[̒(provide "foo")ƁÃ
W[*modules*ɒǉ܂B

gpF
  ;;; W[̈ꗗĂ݂B
  *modules*
  => ( ... )
  (provide "foo")
  => ("foo" ... )
  *modules*
  => ("foo" ... )


*move-forward-after-undo-deletion*
[       type]: Variable
[    package]: editor
[    seealso]: undo
[    section]: obt@
[description]: 
폜undoꍇ̃J[\̈ʒu𐧌䂵܂B
  non-nil  폜͈͂̍Ō
  nil      폜͈͂̐擪


*next-buffer-in-tab-order*
[       type]: Variable
[    package]: editor
[   referred]: next-buffer
[       file]: buffer.l
[    section]: obt@
[description]: 
next-bufferŎɈړobt@A^uł̏Ԃǂɂ邩ۂ
肵܂Bprevious-bufferɂe܂B
  t    obt@o[ł̎̃obt@ɈړB
  nil  ǂȂł傤H


*next-screen-context-lines*
[       type]: Variable
[    package]: editor
[    seealso]: next-page , previous-page , *page-scroll-half-window*
[       file]: page.l
[    section]: EBhE
[description]: 
previous-page  next-page ŏdȂĕ\sw肵܂B
*page-scroll-half-window*  non-nil̂Ƃ͌ʂ͂܂B


*package*
[       type]: Variable
[    package]: lisp
[    seealso]: pbP[W , defpackage , in-package
[    section]: pbP[W
[description]: 
s̃pbP[WێĂ܂B
in-packageŕʂ̃pbP[WɈڂ邱Ƃł܂B

gpF
  *package*
  => #<package: user>


*page-scroll-half-window*
[       type]: Variable
[    package]: editor
[    seealso]: next-page , previous-page , *next-screen-context-lines*
[       file]: page.l
[    section]: EBhE
[description]: 
next-page/previous-pagẽXN[̒Pʂ𔼉ʂɂ邩䂵܂B

  t     ʂXN[
  nil   ʂXN[


*page-scroll-keep-window-position*
[       type]: Variable
[    package]: editor
[   referred]: next-page
[       file]: page.l
[    section]: |WV
[description]: 
next-pagesɃobt@̍ŌオEBhEɂꍇAobt@
̍ŌɈړ܂Bprevious-pagelłB

  t   ړ܂
  nil ړ܂


*popup-completion-list-default*
[       type]: Variable
[    package]: editor
[    seealso]: *minibuffer-popup-completion-list* , *lisp-popup-completion-list*
[   referred]: *print-completion-list-hook*
[       file]: complete.l
[    section]: ̑
[description]: 
⊮Xg\̃ftHg̓𐧌䂵܂B
  :always   K|bvAbv\܂B
  :never    *Completion*obt@ŕ\܂B
  LȊO  X̐ݒ(*minibuffer-popup-completion-list*)
            Kp܂B


*post-command-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *pre-command-hook*
[    section]: ϐƒ萔
[description]: 
R}h[vɂăR}h̎sɎs܂B


*post-startup-hook*
[       type]: Variable
[    package]: editor
[    seealso]: Nt[
[       file]: estartup.l
[    section]: ϐƒ萔
[description]: 
ݒt@C.xyzzysɈȉ̏ԂŃtbNϐ]
B
  1. *load-history-hook*
  2. *init-app-menu-hook*
  3. *command-line-mailto-hook*i-mailtoꍇj
  4. *process-command-line-hook*isȃIvVꍇj
  5. *post-startup-hook*


*pre-abbrev-expand-hook*
[       type]: Variable
[    package]: editor
[    seealso]: expand-abbrev
[       file]: abbrev.l
[    section]: ϐƒ萔
[description]: 
expand-abbrev̍ŏɎs܂B


*pre-command-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *post-command-hook*
[    section]: ϐƒ萔
[description]: 
R}h[vɂăR}h̎sOɎs܂B 


*pre-startup-hook*
[       type]: Variable
[    package]: editor
[    seealso]: Nt[
[       file]: estartup.l
[    section]: ϐƒ萔
[description]: 
ݒt@Csiteinit.lsɎs܂B


*prefix-args*
[       type]: Variable
[    package]: editor
[    seealso]: *prefix-value* , universal-argument
[   referred]: command-execute , find-file , forward-char , forward-line , interactive
[    section]: ϐƒ萔
[description]: 
R}htŌĂ΂ꂽꍇɐݒ肳ϐłB

  (defun test1 ()
    (interactive)
    (message "~s,~s " *prefix-args* *prefix-value*))

Ⴆ΁AC-u 10 M-x test1ƌĂяoƁA
*prefix-args*  non nil ɂȂA *prefix-value* ɒl܂B


*prefix-value*
[       type]: Variable
[    package]: editor
[    seealso]: *prefix-args* , universal-argument
[    section]: ϐƒ萔
[description]: 
R}htŌĂ΂ꂽɐl܂B


*print-circle*
[       type]: Variable
[    package]: lisp
[    seealso]: *print-length*
[    section]: ϐƒ萔
[description]: 
zXg̕\ȗ`ɂ܂

WnilłBread-eval-print̃[vł
\͏t̂悤łB

(setq *print-circle* nil) => nil
(setq x (list 'a))        => (a)
(setf (cdr x) x)          => #1=(a . #1#)
(princ x)
=> (a a a ...
;;ɑ̂C-gŏI
(setq *print-circle* t)   => t
(princ x)
#1=(a . #1#)
=> #1=(a . #1#)


*print-completion-list-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *popup-completion-list-default*
[       file]: complete.l
[    section]: ϐƒ萔
[description]: 
do-completionsɁA⊮Xg\邽߂ɎgpĂ܂B
|bvAbv\̑Oɏ܂B 
funcallŎŝŒӂ邱
  
gpF
  (setq *print-completion-list-hook*
        #'(lambda (list prefix &optional string)
            (popup-string
             (format nil
                     "Possible completions are ~D items:\n~{\n~A~}"
                     (length list) list) (point))))


*print-length*
[       type]: Variable
[    package]: lisp
[    seealso]: *print-circle*
[    section]: ϐƒ萔
[description]: 
Xg̕\rőł؂܂B

(setq *print-length* nil) => nil
(princ '(a b c d e f g h i j))
=>(a b c d e f g h i j)

(setq *print-length* 5)   => 5
(princ '(a b c d e f g h i j))
=>(a b c d e ...)


*print-option-show-dialog*
[       type]: Variable
[    package]: editor
[       file]: estartup.l
[    section]: ̑
[description]: 
nil̏ꍇ́AR}hCIvV -p w肵A_CAO
\܂B


*print-pretty*
[       type]: Variable
[    package]: lisp
[    section]: ϐƒ萔
[description]: 
̕\₷܂B

WtłB

(flet ((f (x) (princ x) (terpri)))
  (let ((*print-pretty* t))
    (f '('a #'b))  ;;t̎̕\
    (setq *print-pretty* nil)
    (f '('a #'b))));;nil̎̕\
=> ('a #'b)
   ((quote a) (function b))


*process-command-line-hook*
[       type]: Variable
[    package]: editor
[    seealso]: Nt[
[       file]: estartup.l
[    section]: VXe
[description]: 
xyzzy.exeɓnꂽIvV𔻒肷ۂɌĂяo܂B
*post-startup-hook*̒OŌĂяo܂B

QlF
  (run-hook-with-args-until-success
   '*process-command-line-hook* arg)


*query-kill-buffer-hook*
[       type]: Variable
[    package]: editor
[    seealso]: kill-buffer , run-hook-with-args-while-success
[       file]: buffer.l
[    section]: ϐƒ萔
[description]: 
kill-buffer Ŏs܂Bobt@̔jmF邽߂Ɏgp܂B
run-hook-with-args-while-successŎŝŒӂ邱ƁB


*query-kill-xyzzy-hook*
[       type]: Variable
[    package]: editor
[    seealso]: *kill-xyzzy-hook*
[    section]: ϐƒ萔
[description]: 
xyzzyIɎs܂B̃tbNϐ̎snilƏI܂B
[xyzzy:03872]Q


*quotation-prefix*
[       type]: Variable
[    package]: editor
[    seealso]: quote-region
[       file]: region.l
[    section]: eLXg
[description]: 
p\ړqłB̓Iɂ́A quote-region ƂɃ[W̍s
ɑ}镶łB

QlF
  ;;; lł͂Ȃ̂ݒ肳Ă܂B
  (defvar *quotation-prefix* "| ")


*random-state*
[       type]: Variable
[    package]: lisp
[    seealso]: random , make-random-state
[    section]: l
[description]: 
݂̗̏ԂێĂ܂B
random  STATE ŌĂ΂ꂽƂg܂B


*readtable*
[       type]: Variable
[    package]: lisp
[    seealso]: si:*set-readtable-case , readtable-case , readtablep , copy-readtable , *ole-readtable*
[    section]: o
[description]: 
݂̃[he[ui[ĂϐłB


*rectangle-kill-buffer*
[       type]: Variable
[    package]: editor
[    seealso]: copy-rectangle , kill-rectangle , yank-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
Rs[`i[܂B
g͋`̊esׂ̕XgłB


*save-buffer-no-filenames-hook*
[       type]: Variable
[    package]: editor
[    seealso]: save-buffer , get-buffer-file-name
[    section]: ϐƒ萔
[description]: 
get-buffer-file-name  nil ƂƎs܂B
gp:
  (add-hook '*save-buffer-no-filenames-hook*
          #'(lambda ()
              (if (yes-or-no-p "ۑ܂")
                  ;;̎_ set-buffer-file-name ĂxB
                  ;;emacs-write-file ȂĂłnon-nilnׂ
                  (emacs-write-file (read-file-name "filename:"))
                ;;hookɏnꍇniln
                nil)))


*save-history*
[       type]: Variable
[    package]: editor
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
ۑqXǧłB
[ʐݒ] - [낢] - [ۑqXǧ(S)] Œlw肷邱
ł܂B


*save-history-hook*
[       type]: Variable
[    package]: editor
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
*kill-xyzzy-hook*sɌĂяo܂B
R}ho[AZbṼqXgϐ̕ۑɎgpĂ܂B


*save-resume-info*
[       type]: Variable
[    package]: editor
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
non-nil ȂΏȈԂۑ܂B
[ʐݒ] - [܂] - [ȈԂۑ(U)] Œlw肷邱
ł܂B


*scroll-bar-step*
[       type]: Variable
[  arguments]: *scroll-bar-step*
[    package]: editor
[    section]: EBhE
[description]: 
XN[o[ɂĂ遣E{^Ƃ̃XN[ʂłB
ftHg 2 łB


*select-pseudo-frame-hook*
[       type]: Variable
[    package]: editor
[    seealso]: new-pseudo-frame , select-pseudo-frame , ed::pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
t[IAړAѐVK쐬ƂɎs܂B
ׂẴt[ɑ΂ēKp܂B

t[ƂɈႤꍇ́A
t[\̂̃Xbg selected-fn Ɋ֐ݒ肵܂B


*selection-ring*
[       type]: Variable
[    package]: editor
[    seealso]: yank-selection , copy-selection , *kill-ring*
[       file]: select.l
[    section]: [W
[description]: 
copy-selectionkill-selectionŐ؂Iꂽ̈Ǘ܂B
*selection-ring**kill-ring*ƓlɃOobt@ƂĊǗ܂B


*show-cursor-line-always*
[       type]: Variable
[    package]: editor
[    seealso]: toggle-cursor-line , inverse-cursor-line
[    section]: obt@
[description]: 
JgłȂEBhEłJ[\C\܂B

gpF
  (setq *show-cursor-line-always* t)


*show-match-hook*
[       type]: Variable
[    package]: editor
[    seealso]: search-dialog
[       file]: search.l
[    section]: ϐƒ萔
[description]: 
ňv̂̕\ɎgpĂ܂Bݒ肳ĂȂ΁A
show-matchs܂B
run-hook-with-args-while-successŎŝŒӂ邱ƁB


*show-matched-parenthesis*
[       type]: Variable
[    package]: editor
[    seealso]: set-syntax-match
[       file]: cmds.l
[    section]: obt@
[description]: 
Ή銇ʂ̕\𐧌䂵܂BʂɎgp镶
set-syntax-match Ŏw肵܂B
  non-nil  Ή銇ʂ\
  nil      Ή銇ʂ\Ȃ


*smart-indentation*
[       type]: Variable
[    package]: editor
[    seealso]: smart-indentation
[       file]: cmds.l
[    section]: |WV
[description]: 
Cfg̑OőSύXKvꍇ̐ݒ肵܂B

  nil      ʒuł]ʂɕύX
  t        ʒuႤꍇ̂ݕύXi^uƃXy[X̑gݍ킹͋Cɂj
  LȊO ʒuႤꍇ̂ݕύXi^uƃXy[X̑gݍ킹͋CɂȂj


*standard-input*
[       type]: Variable
[    package]: lisp
[    seealso]: *standard-output* , *keyboard*
[    section]: o
[description]: 
W͂\Xg[łB
i̓L[{[h̓͂ɂȂĂ܂B


*standard-output*
[       type]: Variable
[    package]: lisp
[    seealso]: *standard-input*
[    section]: o
[description]: 
Wo͂\Xg[łB
i̓Xe[^Xo[̃EBhEւ̏o͂ɂȂĂ܂B
lisp-interaction-mode  C-j(eval-print-last-sexp) ł
̃obt@ւ̏o͂ɂȂĂ܂B

gpF
  ;;; eval-expression ŕ]ꍇ
  *standard-output*  
  => #<status window stream 48042808>

  ;;; eval-print-last-sexp ŕ]ꍇ
  *standard-output*
  => #<buffer stream 48042280>


*status-bar-format*
[       type]: Variable
[    package]: editor
[   referred]: what-cursor-position
[       file]: page.l
[    section]: EBhE
[description]: 
Xe[^Xo[ɕ\w肷镶łB̕яɕ\܂B

  t     v
  p     J[\ʒu
  c     J[\ʒu̕R[h(R[h)
  u     J[\ʒu̕R[h(jR[h)
  T     vijj

gpF
  (setq *status-bar-format* "cupT")


*std-control-default-char*
[       type]: Variable
[    package]: editor
[       file]: defs.l
[    section]: _CAO
[description]: 
select-buffer_CAÕXg{bNXŁAftHgIp
LN^ݒ肵܂B

gpF
  (setq *std-control-default-char* #\RET)


*std-control-down-char*
[       type]: Variable
[    package]: editor
[    seealso]: *std-control-up-char*
[       file]: defs.l
[    section]: _CAO
[description]: 
select-buffer_CAÕXg{bNXŁAɈړL
N^ݒ肵܂B

gpF
  (setq *std-control-down-char* #\C-n)


*std-control-next-char*
[       type]: Variable
[    package]: editor
[    seealso]: *std-control-prior-char*
[    section]: _CAO
[description]: 
select-buffer_CAÕXg{bNXŁA
y[W_ELN^ݒ肵܂B

gpF
  (setq *std-control-next-char* #\C-v)


*std-control-prior-char*
[       type]: Variable
[    package]: editor
[    seealso]: *std-control-next-char*
[    section]: _CAO
[description]: 
select-buffer_CAÕXg{bNXŁA
y[WAbvLN^ݒ肵܂B

gpF
  (setq *std-control-prior-char* #\C-u)


*std-control-up-char*
[       type]: Variable
[    package]: editor
[    seealso]: *std-control-down-char*
[       file]: defs.l
[    section]: _CAO
[description]: 
select-buffer_CAÕXg{bNXŁAɈړL
N^ݒ肵܂B

gpF
  (setq *std-control-up-char* #\C-p)


*tail-f-mode-hook*
[       type]: Variable
[    package]: editor
[    seealso]: tail-f
[       file]: tail-f.l
[    section]: [h
[description]: 
tail-fNɎs܂B


*this-command*
[       type]: Variable
[    package]: editor
[    seealso]: *last-command*
[    section]: ϐƒ萔
[description]: 
ݎs̊֐̃V{i[Ă܂B*last-command*ɐݒ肳܂B
*pre-command-hook* / *post-command-hook*œʂȏ܂̂ɎgA
s̃R}hUł܂B


*unicode-to-half-width*
[       type]: Variable
[    package]: editor
[    seealso]: unicode-char , char-columns
[    section]: 
[description]: 
non-nil ȂAUNICODE ̕\ɔpgp܂B
ftHgł t  xyzzy \[XŐݒ肳Ă܂B

gpF
  ;;; pŕ\
  (setq *unicode-to-half-width* t)   => t
  (unicode-char 180)                 => #\x0134
  ;;; Spŕ\
  (setq *unicode-to-half-width* nil) => nil
  (unicode-char 180)                 => #\4


*wrap-search*
[       type]: Variable
[    package]: editor
[   referred]: search-forward-again
[       file]: search.l
[    section]: EK\
[description]: 
񌟍Ńobt@̍Ō܂łAŏɖ߂邩ǂ𐧌䂵܂B

| search-forward-again ŁAobt@̍Ō܂ōsƁAŏ
| ߂ĒTÂ܂ˁB
| ċ֎~łȂł傤H

  (setq *wrap-search* nil)

Ƃ΂ł܂ǁA܂ɋ֎~ƂȂƂƖʓ|łˁB

| ƌA͂ŕ֗Ȃ񂾂ǁA֎~łB
| uȍ~ɂ邩vƌƂm肽ƂEEE

݈ʒuŌ܂ł narrow ăT[`ƂB
count-matches  0 疳ƂB
_CAOw肷ƂB


+
[       type]: Function
[  arguments]: + &rest NUMBERS
[    package]: lisp
[    seealso]: -
[       file]: builtin.l
[    section]: l
[description]: 
SĉZĕԂ܂B

gpF  
  (+ 1 2 3)
  => 6
  (+ 1.2 4 -2)
  => 3.2


-
[       type]: Function
[  arguments]: - NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: +
[       file]: builtin.l
[    section]: l
[description]: 
̏ꍇɂ͂̐l}CiXɂ̂Ԃ܂B
ȏ̏ꍇɂ͈ڂ̈炻̑̈ZlԂ܂B

gpF
  (- 3)
  => -3
  (- 3 2 1)
  => 0


/
[       type]: Function
[  arguments]: / NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: denominator , numerator , *
[       file]: builtin.l
[    section]: l
[description]: 
̏ꍇɂ 1 ŏZlԂ܂B
ȏ̏ꍇɂ͈ڂ̈ڂ̈SĂŏZlԂ܂B
  
gpF  
  (/ 2)
  => 1/2  
  (/ 3 2 1)
  => 3/2
  (/ 4 3 2)
  => 2/3


/=
[       type]: Function
[  arguments]: /= NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: =
[       file]: builtin.l
[    section]: l
[description]: 
ׂĈقȂĂtAłȂnilԂ܂B

gpF  
  (/= 2 3)
  => t
  (/= 3 3)
  => nil
  (/= 2 3 4 5)
  => t
  (/= 2 3 4 2)
  => nil


1+
[       type]: Function
[  arguments]: 1+ NUM
[    package]: lisp
[    seealso]: 1-
[       file]: number.l
[    section]: l
[description]: 
NUM1𑫂Ԃ܂B

gpF  
  (1+ 1)
  => 2


1-
[       type]: Function
[  arguments]: 1- NUM
[    package]: lisp
[    seealso]: 1+
[       file]: number.l
[    section]: l
[description]: 
NUM1Ԃ܂B

gpF  
  (1- 2)
  => 1


:case-fold
[       type]: Keyword
[    package]: keyword
[    seealso]: scan-buffer
[    section]: ϐƒ萔
[description]: 
ꍇɑ啶Əʂ邩ǂw肵܂B

  t     啶Əʂ܂B
  nil   啶Əʂ܂B


:key
[       type]: Keyword
[    package]: keyword
[    seealso]: :test , :test-not
[    section]: ϐƒ萔
[description]: 
assoc  memberAfind Ȃǂ̊֐Ōۂ
evfɓKp֐w肵܂B
ƁA:test  :test-not Ŏw肳ꂽ֐ɓnl
evfgoh@̊֐Ŏw肵܂B

gp:
  ;; car  'a łvf
  (remove 'a '((a . b) (b . x) (c d e) (a f h i) (x y)) :key #'car)
  => ((b . x) (c d e) (x y))
  ;; :test Ƒgݍ킹邱Ƃ\
  (remove "a" '(("a" . "b") ("b" . "c") ("d" . "a") ("a" . "e") ("b". "b"))
          :test #'string= :key #'car)
  => (("b" . "c") ("d" . "a") ("b" . "b"))


:no-dup
[       type]: Keyword
[    package]: keyword
[    seealso]: scan-buffer
[    section]: ϐƒ萔
[description]: 
ꍇɓʒusǂw肵܂B

  t     ЂƂ猟sB
  nil   ʒu猟sB


:regexp
[       type]: Keyword
[    package]: keyword
[    seealso]: scan-buffer
[    section]: ϐƒ萔
[description]: 
񂪐K\ۂw肵܂B

  t     ͐K\
  nil   ͂̕


:reverse
[       type]: Keyword
[    package]: keyword
[    seealso]: scan-buffer
[    section]: ϐƒ萔
[description]: 
ꍇɐtw肵܂B

  t     tɌ܂B
  nil   Ɍ܂B


:right-bound
[       type]: Keyword
[    package]: keyword
[    seealso]: scan-buffer
[    section]: ϐƒ萔

:tail
[       type]: Keyword
[    package]: keyword
[    seealso]: scan-buffer
[    section]: ϐƒ萔
[description]: 
ꍇɃJ[\𕶎̐擪̂ǂɈʒuÂ邩w肵܂B

  t     J[\𖖔ɈʒuÂ܂B
  nil   J[\擪ɈʒuÂ܂B


:test
[       type]: Keyword
[    package]: keyword
[    seealso]: :test-not , :key
[    section]: ϐƒ萔
[description]: 
assoc  memberAfind Ȃǂ̊֐ŌۂɁA
̃L[[hɐݒ肵֐pĐ^U̔܂B

Ȃ :test-not ƓɎw肷邱Ƃ͂ł܂B

gp:
  (assoc "b" '(("a" . 1) ("B" . 2) ("b" . 3) ("c" . 4)))
  => nil
  (assoc "b" '(("a" . 1) ("B" . 2) ("b" . 3) ("c" . 4)) :test #'string=)
  => ("b" . 3)
  (assoc "b" '(("a" . 1) ("B" . 2) ("b" . 3) ("c" . 4)) :test #'string-equal)
  => ("B" . 2)


:test-not
[       type]: Keyword
[    package]: keyword
[    seealso]: :test , :key
[    section]: ϐƒ萔
[description]: 
assoc  memberAfind Ȃǂ̊֐ŌۂɁA
̃L[[hɐݒ肵֐̋tinotjpĐ^U̔܂B
  
Ȃ :test ƓɎw肷邱Ƃ͂ł܂B

gp:
  ;; "abc" ܂ޕI = "abc" ܂܂Ȃ
  (remove "abc" '("abcd" "test" "xabcx" "abc" "xyz") :test-not #'string-match)
  => ("abcd" "xabcx" "abc")


<
[       type]: Function
[  arguments]: < NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: >
[       file]: builtin.l
[    section]: l
[description]: 
ɕłtAłȂnilԂ܂B

gpF  
  (< 2 3 4)
  => t
  (< 2 4 3 5)
  => nil


<=
[       type]: Function
[  arguments]: <= NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: >=
[       file]: builtin.l
[    section]: l
[description]: 
ׂ荇ׂ<=̊֌WȂtAłȂnilԂ܂B

gpF  
  (<= 2 3 3 4)
  => t
  (<= 2 4 3 5)
  => nil


=
[       type]: Function
[  arguments]: = NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: equal , equalp , /=
[       file]: builtin.l
[    section]: l
[description]: 
̐lׂētAłȂnilԂ܂B

gpF  
  (= 3 3)
  => t
  (= 3 4)
  => nil
  (= 3 3 3 3)
  => t
  (= 3 3 3 4)
  => nil


>
[       type]: Function
[  arguments]: > NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: <
[       file]: builtin.l
[    section]: l
[description]: 
傫ɕłtAłȂnilԂ܂B

gpF  
  (> 3 2 1)
  => t
  (> 3 2 1 4)
  => nil


>=
[       type]: Function
[  arguments]: >= NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: <=
[       file]: builtin.l
[    section]: l
[description]: 
ׂ荇ׂ>=̊֌WȂtAłȂnilԂ܂B
  
gpF  
  (>= 4 3 3 2 1)
  => t
  (>= 4 2 3 1)
  => nil


BS  C-h ɕʁX̋@\蓖Ăɂ́H
[       type]: Tips
[    seealso]: global-set-key
[    section]: L[}bv
[description]: 
| (global-set-key #\C-h 'replace-dialog) ƂݒsƁA
| BS Key ꍇA_CAOoĂ܂B

`IȎdlłA

  (setf (svref *kbd-translate-table* (char-code #\C-h)) #\F13)
  (global-set-key #\F13 'replace-dialog)

̂悤ɂΓȂȂłB


C-z ŃACRɂ́H
[       type]: Tips
[    section]: ̑
[description]: 
(require "wip/winapi")
(c:define-dll-entry winapi:BOOL ShowWindow (winapi:HWND c:int) "user32")

(global-set-key #\C-z #'(lambda () (interactive)
                          (ShowWindow (get-window-handle) 6)))


DOS̃R}hLbNČʂ𕶎ɂɂ́H
[       type]: Tips
[    section]: ̑
[description]: 
| DOS̃R}h(R\[AvČق̂ȁHj
| LbNāAʂ𕶎ƂāAo͂ł܂H

Ȋł傤B

(defun command-substitution (command)
  (let ((outfile nil)
        (buffer nil))
    (unwind-protect
        (save-excursion
          (setq buffer (create-new-buffer "*foo*"))
          (setq outfile (make-temp-file-name))
          (call-process command :output outfile :show :hide :wait t)
          (set-buffer buffer)
          (insert-file-contents outfile)
          (goto-char (1- (point-max)))
          (when (looking-for "\n")
            (delete-char 1))
          (goto-char (point-min))
          (replace-buffer "\n+" " " :regexp t)
          (buffer-substring (point-min) (point-max)))
      (and buffer
           (delete-buffer buffer))
      (and outfile
           (delete-file outfile)))))


Emacs ݊ł͂ȂK\͌\̂ł傤H
[       type]: Tips
[   referred]: K\̕\L
[    section]: EK\
[description]: 
\'  \`  \=  \c  \C ꂾłB


OLEI[g[V̎gp
[       type]: Tips
[    section]: ̑
[description]: 
; ӖȂS̃V[gɁukv
(setq application (ole-create-object "Excel.Application"))
(ole-putprop application 'visible 1)
(setq workbook (ole-method (ole-getprop application 'Workbooks) 'Add))
(setq numbers-of-worksheets
      (ole-getprop
       (ole-getprop workbook 'worksheets)
       'count))
(setq worksheet-index 1)
(while (<= worksheet-index numbers-of-worksheets)
  (setq worksheet
 (ole-getprop workbook 'Worksheets worksheet-index))
  (ole-putprop (ole-method worksheet 'Range "A1:D1")
        'value #("" "" "" "k"))
  (setq worksheet-index (+ worksheet-index 1)))


ȏ׍HĂ݂łǂǂł傤?

(defmacro $ (obj prop &rest args)
  `(ole-method ,obj ',prop ,@args))

(defsetf $ (obj prop &rest args) (x)
  `(progn
     (ole-putprop ,obj ',prop ,x ,@args)
     ,x))

(let (app workbook worksheet range)
  (setq app (ole-create-object "Excel.Application"))
  (setf ($ app Visible) t)
  (setq workbook ($ ($ app Workbooks) Add))
  (setq worksheet ($ workbook Worksheets 1))
  (setf ($ ($ worksheet Range "A1:D1") Value) '("North" "South" "East" "West"))
  (setf ($ ($ worksheet Range "A2:B2") Value) #(5.2 10))
  (setf ($ ($ worksheet Range "C2") Value) 8)
  (setf ($ ($ worksheet Range "D2") Value) 20)

  (setq range ($ worksheet Range "A1:D2"))
  ($ range Select)
  ($ ($ workbook Charts) Add)
  (sit-for 5)

  (setf ($ workbook saved) t)
  ($ ($ app ActiveWorkbook) Close 0)
  ($ app Quit))


``'(backquote)
[       type]: Misc
[  arguments]: form
[    package]: ???
[   referred]: defmacro , quote
[    section]: }N
[description]: 
F^Cv̓[h}NȂłEEE
@@info-modokiłǂ悤Ył܂܂B

``'(tp(backquote))̓Xgquote܂BAʂȕW `,' 
y `,@' p邱ƂŁAXg̗vfIIɕ]邱Ƃł܂B

gpF
  ;;; tpgpăXg쐬
  (setq f0 '(0 1 2 3))         =>  (0 1 2 3)  
  (setq f1 `(0 1 2 3))         =>  (0 1 2 3)
  (setq f2 `(4 5 ,(car f1)))   =>  (4 5 0)
  (setq f3 `(6 7 ,(cdr f1)))   =>  (6 7 (1 2 3))
  (setq f4 `(8 9 ,@(cdr f1)))  =>  (8 9 1 2 3)


abbrev-mode
[       type]: Function
[  arguments]: abbrev-mode &optional (ARG () SV)
[    package]: editor
[    seealso]: quietly-read-abbrev-file
[   referred]: expand-abbrev
[       file]: abbrev.l
[    section]: [h
[description]: 
abbrev-modeJn܂B

gpF
  (abbrev-mode t)


abbreviate-display-string
[       type]: Function
[  arguments]: abbreviate-display-string STRING LENGTH &optional PATHNAMEP
[    package]: editor
[       file]: builtin.l
[    section]: 
[description]: 
\Ɏ܂悤[...]ŏȗĕԂ܂B

  STRING    : \镶w肵܂B
  LENGTH    : \w肵܂B
  PATHNAMEP : 񂪃t@Cǂw肵܂B
              t@C̏ꍇɂ͐擪3(F"C:/"jcďȗ܂B

gpF
 (abbreviate-display-string "c:/xyzzy/lisp/builtin.l" 20 nil)
 => "c:/xyzzy.../builtin.l"
 (abbreviate-display-string "c:/xyzzy/lisp/builtin.l" 20 t)
 => "c:/.../lisp/builtin.l"


abs
[       type]: Function
[  arguments]: abs NUMBER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
ΒlԂ܂B

gpF
  ;;; ΒlԂB
  (abs -3.0)
  => 3.0  


acons
[       type]: Function
[  arguments]: acons KEY DATUM A-LIST
[    package]: lisp
[       file]: builtin.l
[    section]: Xg
[description]: 
(KEY . DATUM)  A-LIST ɉAzXgԂ܂B

  (acons x y a) == (cons (cons x y) a)

gpF
  (setq foo '((b . 2))) => ((b . 2))
  (acons 'a 1 foo)      => ((a . 1) (b . 2))
  foo                   => ((b . 2))


acos
[       type]: Function
[  arguments]: acos NUMBER
[    package]: lisp
[    seealso]: acosh
[       file]: builtin.l
[    section]: l
[description]: 
t]֐̒lԂ܂B


acosh
[       type]: Function
[  arguments]: acosh Z
[    package]: lisp
[    seealso]: acos
[       file]: number.l
[    section]: l
[description]: 
toȐ]֐vZ܂B


activate-xyzzy-window
[       type]: Function
[  arguments]: activate-xyzzy-window INSTANCE
[    package]: editor
[    seealso]: si:*instance-number , list-xyzzy-windows
[       file]: builtin.l
[    section]: vZX
[description]: 
w肵xyzzyANeBuɂ܂B
  
  INSTANCE : NxyzzyɊ蓖Ăꂽ񕉂̐


add-file-history-to-menu
[       type]: Function
[  arguments]: add-file-history-to-menu
[    package]: editor
[    seealso]: *minibuffer-file-name-history*
[       file]: app-menu.l
[    section]: ̑
[description]: 
t@Cj[̗̂ƂɗL^H
iڍוsj
(add-file-history-to-menu)


add-history
[       type]: Function
[  arguments]: add-history ITEM VAR
[    package]: editor
[    seealso]: *minibuffer-maximum-history-count* , *minibuffer-enable-add-to-menu*
[       file]: minibuf.l
[    section]: ϐƒ萔
[description]: 
VAR  ITEM  LRUŒǉ܂B *minibuffer-maximum-history-count* 
𒴂Ƃ́AłgpĂȂqXg폜܂B

܂A *minibuffer-enable-add-to-menu*  non-nil ̂ƂɁA
(get VAR 'add-lru-menu-function) Ɋ֐ݒ肳Ă΁A
̊֐s܂BႦ΁A *minibuffer-file-name-history* ɂ́A 
add-file-history-to-menu ݒ肳ĂAJt@Cj[
uŋߎgt@C(F)vɓo^Ă܂B

gpF
  (add-history file '*minibuffer-file-name-history*)
  (add-history cmd '*minibuffer-execute-history*)


add-hook
[       type]: Function
[  arguments]: add-hook HOOK FN &optional APPEND
[    package]: editor
[    seealso]: delete-hook , run-hooks
[       file]: misc.l
[    section]: [h
[description]: 
tbNϐɊ֐ǉ܂B

  HOOK : tbNϐ̃V{w肵܂B
  FN   : ֐̃V{w肵܂B

tbNƂ͓̏ɂă[U]ޏǉ邽߂̎dg݂łB
xyzzyɂ́u[UC낤ȂvƎvƂɃtbNd|
Ă܂BႦ΁ufind-fileƂɂ͉֐svƎv
Aufind-file㏑vAuxxx-find-filev̂ł͂
A̗prɎgtbNϐȂǂmF܂傤B

̗find-file鎞func1func2Ăяoĉ炩̏łB

  yz
        ;;; find-fileŌĂяo*before-find-file-hook*
        ;;; [U֐func1func2Ăяo悤ɓo^B
        (add-hook '*before-find-file-hook* 'func1)
        (add-hook '*before-find-file-hook* 'func2)

  yfind-filesz
        ;;; find-filesƁAt@C̓ǂݍ݂̑O
        ;;; *before-find-file-hook*ɓo^Ă֐sB
        (find-file ...)
          (run-hooks '*before-find-file-hook*)
              (func1)
              (func2)

  yЕtz
        ;;; find-fileŌĂяo*before-find-file-hook*
        ;;; [U֐func1func2菜
        (delete-hook '*before-find-file-hook* 'func1)
        (delete-hook '*before-find-file-hook* 'func2)

ȂAtbNϐ͗prɉČĂяo߂l̈ӖقȂ܂B
ӂ܂傤B

gpF
  ;;; lispmode.l
  (add-hook '*query-kill-buffer-hook* 'kill-scratch-hook)


add-menu-item
[       type]: Function
[  arguments]: add-menu-item MENU TAG NAME &optional COMMAND INIT
[    package]: editor
[    seealso]: insert-menu-item , get-menu , create-menu , define-menu
[       file]: builtin.l
[    section]: j[
[description]: 
Vɍ쐬j[ڂj[̖ɒǉ܂B

  MENU    : ǉ̃j[w肵܂B
  TAG     : ʗp̃^Ow肵܂B
  NAME    : j[ɕ\閼Ow肵܂B
  COMMAND : j[̍ڂIꂽƂɎsR}hw肵܂B
  INIT    : j[JOɕ]Ԃlɂăj[̏Ԃ
            ݒ肵܂BCӂSwł܂A܂薳ȂƂ͂
            łB̒lƂĈӖ̂lɂ͈ȉ̂̂܂B

        :modified     Jgobt@ύXĂȂΊDF\B
        :undo         undos\łΊDF\B
        :redo         redos\łΊDF\B
        :selection    Jgobt@̃eLXgIł邩`I
                      łΊDF\B
        :rectangle    Jgobt@̃eLXgIł邩`ȊO
                      ̑IłΊDF\B
        :clipboard    Nbv{[hłΊDF\B
        :check        `FbNB
        :disable      DF\B
        ̑        gp\B


add-menu-separator
[       type]: Function
[  arguments]: add-menu-separator MENU &optional TAG
[    package]: editor
[    seealso]: insert-menu-separator , define-menu , define-popup-menu , get-menu , get-menu-position
[       file]: builtin.l
[    section]: j[
[description]: 
Zp[^j[̖ɒǉ܂B

  MENU : ǉ̃j[w肵܂B
  TAG  : ʗp̃^Ow肵܂B


add-popup-menu
[       type]: Function
[  arguments]: add-popup-menu MENU POPUP-MENU NAME
[    package]: editor
[    seealso]: insert-popup-menu , define-popup-menu
[       file]: builtin.l
[    section]: j[
[description]: 
|bvAbvj[j[̖ɒǉ܂B

  MENU       : ǉ̃j[w肵܂B
  POPUP-MENU : ǉ|bvAbvj[w肵܂B
  NAME       : j[ɕ\閼Ow肵܂B

gpF
  ;;; ENbNj[W̃j[ɒǉĂ݂B
  (add-popup-menu *app-menu* *app-popup-menu* "ҏW2(&E)")
  => #<menu 48701736>


adjoin
[       type]: Function
[  arguments]: adjoin ITEM LIST &key :test :test-not :key
[    package]: lisp
[    seealso]: pushnew
[       file]: builtin.l
[    section]: Xg
[description]: 
ITEM  LIST  member łȂΐ擪ɒǉ LIST ԂB member Ȃ LIST 
̂܂ܕԂ܂B

  (adjoin item list) == (if (member item list) list (cons item list))

  :key : :key fn w肳ꂽꍇCxyzzył
          (adjoin item list) == (if (member item list :key fn) list (cons item list))
         ƂȂ܂CCLTL2ł͎̂悤ɓ삵C݊łD
          (adjoin item list) == (if (member (funcall fn item) list :key fn) list (cons item list))

gpF
  (adjoin 'a '(b c d))
  => (a b c d)
  (adjoin 'b '(a b c d))
  => (a b c d)
  (adjoin '(a) '((b) (c) (d)) :key #'car)
  => ((a) (b) (c) (d))


adjustable-array-p
[       type]: Function
[  arguments]: adjustable-array-p ARRAY
[    package]: lisp
[    seealso]: vector-push-extend , make-array
[       file]: builtin.l
[    section]: z
[description]: 
ARRAY TCYύX\Ȃ tAs\Ȃ nil Ԃ܂B


alpha-char-p
[       type]: Function
[  arguments]: alpha-char-p CHAR
[    package]: lisp
[    seealso]: both-case-p , alphanumericp , characterp
[       file]: builtin.l
[    section]: f[^^
[description]: 
p[A-Za-z]ǂ𔻒肵܂B

  CHAR : 肷镶


alphanumericp
[       type]: Function
[  arguments]: alphanumericp CHAR
[    package]: lisp
[    seealso]: alpha-char-p , characterp
[       file]: builtin.l
[    section]: f[^^
[description]: 
p[A-Za-z0-9]ǂ𔻒肵܂B

  CHAR : 肷镶


and
[       type]: Macro
[  arguments]: and &rest FORMS
[    package]: lisp
[    seealso]: or
[       file]: evalmacs.l
[    section]: \
[description]: 
tH[non-nil̊ԂԂɕ]܂B
tH[łnilȂ΁Aŕ]𒆒fnilԂďI܂B
SẴtH[non-nilȂ΁AŌɎstH[̒lԂ܂B

  ;;; exp1 non-nilȂ exp2sA
  ;;; exp2 non-nilȂ exp3sA
  ;;; exp3 non-nilȂ.......
  (and exp1 exp2 exp3 ...)

Ⴆ΁Aȉ̗lɃ`FbNԂɋLq悤ȏꍇɌĂƎv܂B
`FbNɎs΁Aȍ~͎̏s܂B

  (and (file-exist-p ...) ; ̃t@C̑݃`FbN
       (find-file ...)    ; ̃t@Cǂݍ݃`FbN
       (scan-buffer ...)  ; K\Ō
       (match-string 2)   ; ʂ̃`FbN
       ...)


append
[       type]: Function
[  arguments]: append &rest LISTS
[    package]: lisp
[    seealso]: nconc , concatenate
[       file]: builtin.l
[    section]: Xg
[description]: 
̃XgɂƂĂXgԂ܂B
͕ۑ܂B

gpF
  ;;; XgĂ݂B
  (setq x '(a b c))
  (setq y '(d e f))
  (append x y)
  =>(a b c d e f)
  x
  =>(a b c)
  y
  =>(d e f)


append-file
[       type]: Function
[  arguments]: append-file FILENAME &optional NOMSG CHAR-ENCODING EOL-CODE
[    package]: editor
[    seealso]: write-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
obt@̓e FILENAME ɒǉ݂܂B
write-file  APPEND  non-nil ɂꍇƓłB

  NOMSG         : non-nil ȂXe[^Xo[Ɍo߃bZ[W\܂B
  CHAR-ENCODING : GR[fBOw肵܂B
  EOL-CODE      : sR[hw肵܂B


append-rectangle
[       type]: Function
[  arguments]: append-rectangle
[    package]: editor
[       file]: rectangl.l
[    section]: [W
[description]: 
Rs[Ă`̊esݍsȉ̍s֒ǉ܂B

gpF
  Ȃ̂Rs[ĂƂ
          
          A       
          BC      
          DEF     
          GHIJ    
          
  * ̈ʒu append-rectangle 
         
   *-lmn           --lmnA    
   --op          --opBC    
   --              --DEF     
   --q             --qGHIJ   
         


append-to-register
[       type]: Function
[  arguments]: append-to-register R START END &optional DELETE
[    package]: editor
[    seealso]: prepend-to-register
[   referred]: copy-to-register
[       file]: register.l
[    section]: [W
[description]: 
START  END Ŏw肳郊[WAWX^ R Ɋi[ĂeL
Xg̖֒ǉ܂B [C-x r a]
R ɃeLXgĂȂƃG[ɂȂ܂B
DELETE  non-nil ȂΓɃ[W폜܂B


append-trail-slash
[       type]: Function
[  arguments]: append-trail-slash STRING
[    package]: editor
[    seealso]: remove-trail-slash
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
̖"/"Ȃ"/"ǉ܂B

gpF
  (append-trail-slash "ffjfj")
  => "ffjfj/"
  (append-trail-slash "ffjfj/")
  => "ffjfj/"


apply
[       type]: Function
[  arguments]: apply FUNCTION ARG &rest MORE-ARGS
[    package]: lisp
[    seealso]: funcall , multiple-value-call
[       file]: builtin.l
[    section]: ]
[description]: 
i[Xgw肵Ċ֐\V{֐Ăяo܂B
FNɂ͊֐\V{ł֐ł\܂B̌K܂
ꍇɂ́AapplygKv͖funcall̕ǂƎv܂B

gpF
  ;;; car낢ȌĂяołB
  (car '(a b c))                => a
  (apply 'car '((a b c)))       => a
  (apply #'car '((a b c)))      => a


apps-popup
[       type]: Function
[  arguments]: apps-popup
[    package]: editor
[    seealso]: mouse-menu-popup
[       file]: mouse.l
[    section]: j[
[description]: 
|bvAbvj[\܂B[Apps]

j[́A*app-popup-menu* ɒ`ꂽ̂gp܂B


apropos
[       type]: Function
[  arguments]: apropos STRING &optional PRINT-KEY PRED
[    package]: editor
[    seealso]: *apropos-no-regexp* , command-apropos
[       file]: help.l
[    section]: V{
[description]: 
w肵K\ɈvV{̈ꗗ\܂B

  STRING    : 镶
  PRINT-KEY : oChĂL[\邩ǂ
        non-nil : \
        nil     : \Ȃ
  PRED      : HHH


archiver-dll-config-dialog
[       type]: Function
[  arguments]: archiver-dll-config-dialog DLL &optional MODE
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
A[JCo̐ݒ_CAO\܂B

  DLL  : ݒ肷A[JCow肵܂B
  MODE : iڍוsj

gpF
  (archiver-dll-config-dialog :unlha32)


archiver-dll-version
[       type]: Function
[  arguments]: archiver-dll-version DLL
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
A[JCõo[W擾܂B

  DLL  : A[JCow肵܂B

gpF
  (archiver-dll-version :unrar32)
  => "0.09"


aref
[       type]: Accessor
[  arguments]: aref ARRAY &rest SUBSCRIPTS
[    package]: lisp
[    seealso]: make-array , setf , svref
[   referred]: row-major-aref , vector
[       file]: builtin.l
[    section]: z
[description]: 
SUBSCRIPTS œ肳z̗vfɃANZX܂BSUBSCRIPTS Ȃz
[̏ꍇ́AẑЂƂ̗vfɃANZX܂B
̓IȎgɂẮAȉ̗QƂĂB

gpF
  ;;; 2x2̏ꂽz܂Bl̎擾EύXs܂B
  (setf foo (make-array '(2 2) :initial-contents '((1 2) (3 4))))
  =>#2A((1 2) (3 4))
  (aref foo 1 1);zfoo̗vf(1,1)̒l𓾂
  =>4
  (setf (aref foo 1 1) 10);zfoo̗vf(1,1)̒l10ɂ
  =>10
  foo
  =>#2A((1 2) (3 10))


array-dimension
[       type]: Function
[  arguments]: array-dimension ARRAY AXIS-NUMBER
[    package]: lisp
[    seealso]: array-dimensions , array-total-size
[       file]: array.l
[    section]: z
[description]: 
z ARRAY  AXIS-NUMBER Ԗڂ̎̃TCYԂ܂B
AXIS-NUMBER  0 n܂鐮lłB
ȂAtB|C^ĂxN^ɊւĂA{̃TCYԂ܂B

gp:
  (setf x (make-array '(2 3)))
  => #2A((nil nil nil) (nil nil nil))
  (array-dimension x 0)
  => 2
  (array-dimension x 1)
  => 3

  ;; tB|C^̃xN^
  (setf x (make-array 5 :initial-contents '(a b c d e) :fill-pointer 3))
  => #(a b c)
  (array-dimension x 0)
  => 5
  (length x) ; length ƃtB|C^܂ł̒ɂȂ
  => 3


array-dimensions
[       type]: Function
[  arguments]: array-dimensions ARRAY
[    package]: lisp
[    seealso]: array-dimension , array-total-size , make-array
[       file]: array.l
[    section]: z
[description]: 
z ARRAY ̊ẽTCYXgɂĕԂ܂B

gp:
  (setf x (make-array '(2 3)))
  => #2A((nil nil nil) (nil nil nil))
  (array-dimensions x)
  => (2 3)


array-element-type
[       type]: Function
[  arguments]: array-element-type ARRAY
[    package]: lisp
[    seealso]: make-array
[       file]: builtin.l
[    section]: z
[description]: 
ARRAY ̗vf̃^Cv𔻕ʂ܂B
zȂ tAȂ character Ԃ܂B


array-has-fill-pointer-p
[       type]: Function
[  arguments]: array-has-fill-pointer-p ARRAY
[    package]: lisp
[    seealso]: fill-pointer
[       file]: builtin.l
[    section]: z
[description]: 
z ARRAY tB|C^ĂȂ tA
ĂȂȂ nil Ԃ܂B


array-rank
[       type]: Function
[  arguments]: array-rank ARRAY
[    package]: lisp
[    seealso]: make-array
[       file]: builtin.l
[    section]: z
[description]: 
z ARRAY ̎Ԃ܂B

gp:
  (setf x (make-array '(2 3)))
  => #2A((nil nil nil) (nil nil nil))
  (array-rank x)
  => 2


array-row-major-index
[       type]: Function
[  arguments]: array-row-major-index ARRAY &rest SUBSCRIPTS
[    package]: lisp
[    seealso]: row-major-aref
[       file]: builtin.l
[    section]: z
[description]: 
ARRAY  SUBSCRIPTS ŕ\vfAARRAY ꎟ̔zƂ݂ȂƂ
Ԗڂ̗vfɂ邩̃CfbNXԂ܂B

SUBSCRIPTS ̐ ARRAY ̎ƓKvA
܂e ARRAY ̊ẽTCYłKv܂B

gp:
  (setf x (make-array '(2 3)))
  => #2A((nil nil nil) (nil nil nil))
  (array-row-major-index x 0 2)
  => 2
  (array-row-major-index x 1 1)
  => 4

  ̗͂ȊłB

        0   1   2
     
   0  0 1 2
     
   1  3 4 5
     


array-total-size
[       type]: Function
[  arguments]: array-total-size ARRAY
[    package]: lisp
[    seealso]: array-dimension , array-dimensions
[       file]: builtin.l
[    section]: z
[description]: 
z ARRAY ̑SvfԂ܂B

gp:
  (setf x (make-array '(2 3)))
  => #2A((nil nil nil) (nil nil nil))
  (array-total-size x)
  => 6


arrayp
[       type]: Function
[  arguments]: arrayp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT  array Ȃ t AȊOȂ nil Ԃ܂B


ash
[       type]: Function
[  arguments]: ash INTEGER COUNT
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
WJɃVtg܂B

  INTEGER : Vtg鐔l
  COUNT   : rbgȂ΍ɁAȂΉEɃVtg
  
F
  ;;; 4ƉE3rbgVtgĂ݂B
  (ash 4 3)
  => 32
  (ash 4 -3)
  => 0


asin
[       type]: Function
[  arguments]: asin NUMBER
[    package]: lisp
[    seealso]: asinh
[       file]: builtin.l
[    section]: l
[description]: 
t֐̒lԂ܂B


asinh
[       type]: Function
[  arguments]: asinh Z
[    package]: lisp
[    seealso]: asin
[       file]: number.l
[    section]: l
[description]: 
toȐ֐vZ܂B


assoc
[       type]: Function
[  arguments]: assoc ITEM A-LIST &key :test :test-not :key
[    package]: lisp
[    seealso]: assoc-if , assoc-if-not , rassoc
[       file]: builtin.l
[    section]: Xg
[description]: 
AzXg A-LIST ̒ car  ITEM Ƃ :test 𖞂ŏ̃yAԂ܂B

gpF
  (assoc 'r '((a . b) (c . d) (r . x) (s . y) (r . z))) 
  =>  (r . x) 
  (assoc 'goo '((foo . bar) (zoo . goo)))
  => nil 
  (assoc '2 '((1 a b c) (2 b c d) (-7 x y z)))
  => (2 b c d)


assoc-if
[       type]: Function
[  arguments]: assoc-if PREDICATE A-LIST &key :key
[    package]: lisp
[    seealso]: assoc , assoc-if-not
[       file]: builtin.l
[    section]: Xg
[description]: 
AzXg A-LIST ̒ car  PREDICATE 𖞂ŏ̃yAԂ܂B

gpF
  (assoc-if #'numberp '((a . b) (1 . c) (2 . d)))
  => (1 . c)


assoc-if-not
[       type]: Function
[  arguments]: assoc-if-not PREDICATE A-LIST &key :key
[    package]: lisp
[    seealso]: assoc , assoc-if
[       file]: builtin.l
[    section]: Xg
[description]: 
AzXg A-LIST ̒ car  PREDICATE 𖞂Ȃŏ̃yAԂ܂B

gpF
  (assoc-if-not #'numberp '((a . b) (1 . c) (2 . d)))
  => (a . b)


atan
[       type]: Function
[  arguments]: atan Y &optional X
[    package]: lisp
[    seealso]: atanh
[       file]: builtin.l
[    section]: l
[description]: 
tڊ֐̒lԂ܂B


atanh
[       type]: Function
[  arguments]: atanh Z
[    package]: lisp
[    seealso]: atan
[       file]: number.l
[    section]: l
[description]: 
toȐڊ֐vZ܂B


atom
[       type]: Function
[  arguments]: atom OBJECT
[    package]: lisp
[    seealso]: consp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTconsłȂtAȊOȂnilԂ܂B

  (atom x) == (typep x 'atom) == (not (typep x 'cons))

ӁF(atom '())  '() == nilȂ̂t


auto-fill-hook
[       type]: Variable
[    package]: editor
[    seealso]: *auto-fill-hook
[   referred]: auto-fill-mode , fill-region-hook
[    section]: ϐƒ萔
[description]: 
͂̌ʁAfill-columnzdo-auto-fills܂B


auto-fill-mode
[       type]: Function
[  arguments]: auto-fill-mode &optional (ARG () SARG)
[    package]: editor
[    seealso]: fill-column , auto-fill-hook
[   referred]: *auto-fill-hook , set-fill-prefix
[       file]: fill.l
[    section]: eLXg
[description]: 
lߍ݃[h̊JnƏIgO܂B


auto-save
[       type]: BufferLocal
[    package]: editor
[    seealso]: setup-temp-buffer
[    section]: ϐƒ萔
[description]: 
ۑs𐧌䂷邽߂̃tOłB
X̃obt@̃[hȂ̂ł΁Agp̗lɃ[
Jϐɂ܂B

  t     ۑ
  nil   ۑȂ

gpF
  ;;; ݂̃obt@͎ۑȂ悤ɂB
  (make-local-variable 'auto-save)
  => t  
  (setq auto-save nil)
  => nil


autoload
[       type]: Function
[  arguments]: autoload FN FILE &optional COMMANDP MACROP
[    package]: lisp
[    seealso]: mc-autoload , autoload-function-p , e탍[h֌W̊֐̈Ⴂ
[       file]: misc.l
[    section]: ֐
[description]: 
֐Ăяoꂽ_Ńt@C[h悤錾܂B

  FN       : ֐V{w肵܂B
  FILE     : [ht@Cw肵܂B
  COMMANDP : sƂ interactive Ɏs邩ǂw肵܂B
  MACROP   : }Nǂw肵܂B

FN Ɋ֐ƂĒ`Ăꍇ͂Ȃɂ܂B
`ĂȂꍇ͐VɊ֐ FN ̈ꎞIȒ`Ƃ܂B
֐͏߂ FN Ă΂ꂽƂɎsAw肳ꂽt@C FILE {
Ăяoׂ FN ̒`[h܂B FILE  FN ̒`
݂Ȃ΃G[ƂȂ܂B

֐ĂяóAX̃t@C[hĂ̂悤Ɏs
𑱂܂B߂ɎgȂ֐ autoload Ő錾Ăƃ
ʂߖł܂B܂ANɃt@C[hȂ̂ŋNȂ
܂B

gpF
  ;;; defs.l
  (autoload 'search-dialog "dialogs" t)
  (autoload 'replace-dialog "dialogs" t)
  (autoload 'count-matches-dialog "dialogs" t)
  (autoload 'goto-line-dialog "dialogs" t)
  (autoload 'open-file-dialog "dialogs" t)


autoload-function-p
[       type]: Function
[  arguments]: autoload-function-p DEF
[    package]: lisp
[    seealso]: autoload
[       file]: misc.l
[    section]: ֐
[description]: 
w肳ꂽ֐autoloadꂽۂԂ܂B
  nil w肳ꂽ֐autoloadς
      autoloadȂ֐̏ꍇ
  t   w肳ꂽ֐autoloadȌꍇ

gpF
  (export 'lisp-info-F1)
  (autoload 'lisp-info-F1 "info-modoki" t)
  (autoload-function-p 'lisp-info-F1)
  => t
  (lisp-info-F1)
  (autoload-function-p 'lisp-info-F1)
  => nil


back-to-indentation
[       type]: Function
[  arguments]: back-to-indentation
[    package]: editor
[    seealso]: beginning-of-line
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\Cfg̖is̍ŏ̋󔒂łȂjֈړ܂B
[ESC m]


backward-char
[       type]: Function
[  arguments]: backward-char &optional (N 1)
[    package]: editor
[    seealso]: forward-char
[   referred]: backward-word
[       file]: cmds.l
[    section]: |WV
[description]: 
w肳ꂽɈړ܂BsȂΑOs̏I[Ɉʒu܂B
[C-b], [Left]

݊F
   Emacsł̓obt@̐擪ł̓G[܂Bxyzzył̓G[͔
  ܂B̑AƂ tAȂ nil Ԃ܂B


backward-delete-char-untabify
[       type]: Function
[  arguments]: backward-delete-char-untabify &optional (ARG 1)
[    package]: editor
[    seealso]: delete-backward-char , backward-delete-char-untabify-or-selection , untabify
[       file]: cmds.l
[    section]: eLXg
[description]: 
J[\̕w蕶폜܂B^u폜ۂ́A
KȐ̔pXy[XɒuĂ폜܂B


backward-delete-char-untabify-or-selection
[       type]: Function
[  arguments]: backward-delete-char-untabify-or-selection &optional (N 1)
[    package]: editor
[    seealso]: delete-backward-char , backward-delete-char-untabify
[       file]: cmds.l
[    section]: eLXg
[description]: 
ZNVőI𒆂Ȃ΃ZNVŜAłȂ΃J[\
̕w蕶폜܂B^u폜ۂ́AK
̔pXy[XɒuĂ폜܂B


backward-kill-paragraph
[       type]: Function
[  arguments]: backward-kill-paragraph &optional (ARG 1)
[    package]: editor
[    seealso]: kill-paragraph , kill-region
[       file]: paragrph.l
[    section]: [W
[description]: 
݂̃pOt̐擪܂kill܂B


backward-kill-word
[       type]: Function
[  arguments]: backward-kill-word &optional (ARG 1)
[    package]: editor
[    seealso]: kill-word
[       file]: cmds.l
[    section]: [W
[description]: 
J[\ʒu̒P̐擪܂ł؂ALOɒǉ܂B
[ESC C-h]
J[\P̓rɂꍇ́AJ[\ʒu炻̒P̐擪܂łA
ΏۂƂȂ܂B


backward-line
[       type]: Function
[  arguments]: backward-line &optional (N 1)
[    package]: editor
[    seealso]: forward-line
[       file]: cmds.l
[    section]: |WV
[description]: 
N sֈړ܂B
ړ̑O goal-column ۑ܂B

(backward-line n)  (forward-line (- n)) ͓łB


backward-page
[       type]: Function
[  arguments]: backward-page &optional (ARG 1)
[    package]: editor
[    seealso]: forward-page
[   referred]: mark-page
[       file]: page.l
[    section]: |WV
[description]: 
̉y[W܂ňړ܂B[C-x ]]
y[Wꍇ̓obt@̐擪Ɉړ܂B
ʂɂ͐䕶form feedPƂłsŉy[W\܂B

  ARG : y[Ww肵܂BftHg 1 łB
        ̒l̏ꍇAtɈړ܂B


backward-paragraph
[       type]: Function
[  arguments]: backward-paragraph &optional (ARG 1)
[    package]: editor
[    seealso]: forward-paragraph
[       file]: paragrph.l
[    section]: |WV
[description]: 
J[\i̐擪Ɉړ܂B[ESC {]


backward-sexp
[       type]: Function
[  arguments]: backward-sexp &optional (ARG 1) NOERROR
[    package]: editor
[    seealso]: forward-sexp , down-list
[       file]: sexp.l
[    section]: obt@
[description]: 
lisp-modeS1߂܂B[ESC C-b]

gpF
  (backward-sexp)


backward-virtual-line
[       type]: Function
[  arguments]: backward-virtual-line &optional (N 1)
[    package]: editor
[    seealso]: forward-virtual-line
[       file]: cmds.l
[    section]: |WV
[description]: 
\s N sֈړ܂B


backward-word
[       type]: Function
[  arguments]: backward-word &optional (N 1)
[    package]: editor
[    seealso]: forward-word , backward-char
[   referred]: previous-word
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\̒PɈړ܂B[ESC b]


base64-decode-region
[       type]: Function
[  arguments]: base64-decode-region FROM TO
[    package]: editor
[    seealso]: si:base64-encode , base64-decode-region-to-file
[       file]: encdec.l
[    section]: [W
[description]: 
[WBase64fR[h܂B


base64-decode-region-to-file
[       type]: Function
[  arguments]: base64-decode-region-to-file FILENAME FROM TO
[    package]: editor
[    seealso]: si:base64-decode , base64-decode-region
[       file]: encdec.l
[    section]: [W
[description]: 
[WBase64fR[hăt@Cɕۑ܂B


beginning-of-buffer
[       type]: Function
[  arguments]: beginning-of-buffer
[    package]: editor
[    seealso]: end-of-buffer , set-mark-command , selection-beginning-of-buffer
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\obt@̐擪Ɉړ܂B[ESC <]
J[\ʒuɂ̓}[Nݒ肵܂B

}[NύXȂ߂ɂ
(goto-char (point-min))g܂B


beginning-of-defun
[       type]: Function
[  arguments]: beginning-of-defun &optional (ARG 1)
[    package]: editor
[    seealso]: end-of-defun
[       file]: sexp.l
[    section]: ֐
[description]: 
J[\֐`̐擪Ɉړ܂B[ESC C-a]


beginning-of-line
[       type]: Function
[  arguments]: beginning-of-line
[    package]: editor
[    seealso]: end-of-line , back-to-indentation
[   referred]: selection-beginning-of-line
[       file]: cmds.l
[    section]: |WV
[description]: 
sɈړ܂Bgoto-bolinteractivełłB[C-a], [C-Left]


beginning-of-virtual-line
[       type]: Function
[  arguments]: beginning-of-virtual-line
[    package]: editor
[    seealso]: goto-virtual-bol
[   referred]: selection-beginning-of-virtual-line
[       file]: cmds.l
[    section]: |WV
[description]: 
\s̍sɈړ܂B
goto-virtual-bol  interactive łłB


block
[       type]: Special Form
[  arguments]: block NAME {FORM}*
[    package]: lisp
[    seealso]: return-from
[       file]: builtin.l
[    section]: \
[description]: 
tH[Ԃɕ]čŌ̃tH[̌ʂԂ܂B 
قƂprognłreturn-fromreturnŖ߂lwłƂ낪Ⴂ܂B
returnreturn-fromɂԂƂɂ͎c͕̎]܂B


bobp
[       type]: Function
[  arguments]: bobp
[    package]: editor
[    seealso]: eobp
[       file]: builtin.l
[    section]: |WV
[description]: 
|Cgobt@̐擪ɂ邩ۂԂ܂B
  t    |Cgobt@̐擪ɂB
  nil  |Cgobt@̐擪ɂ͂ȂB


bolp
[       type]: Function
[  arguments]: bolp
[    package]: editor
[    seealso]: eolp
[       file]: builtin.l
[    section]: |WV
[description]: 
J[\sɂtAłȂnilԂ܂B


both-case-p
[       type]: Function
[  arguments]: both-case-p CHAR
[    package]: lisp
[    seealso]: lower-case-p , upper-case-p , alpha-char-p
[       file]: builtin.l
[    section]: 
[description]: 
CHAR 啶̂镶Ȃ t AłȂ nil Ԃ܂B

gpF  
  (both-case-p #\a)
  => t
  (both-case-p #\A)
  => t
  (both-case-p #\RET)
  => nil


boundp
[       type]: Function
[  arguments]: boundp SYMBOL
[    package]: lisp
[    seealso]: fboundp , macro-function , makunbound
[       file]: builtin.l
[    section]: V{
[description]: 
V{ɒlݒ肳Ă邩ǂԂ܂B

gpF
  (boundp 'test)          => nil
  (defvar test "string")  => test
  (boundp 'test)          => t


broadcast-stream-streams
[       type]: Function
[  arguments]: broadcast-stream-streams BROADCAST-STREAM
[    package]: lisp
[    seealso]: make-broadcast-stream
[       file]: builtin.l
[    section]: o
[description]: 
make-broadcast-streamōꂽBROADCAST-STREAM̏o͐̃Xg[̃
XgԂ܂B

gpF
  ;;; hogȅo͐XgœB
  (with-open-stream (foo (open "foo.txt" :direction :output))
    (with-open-stream (bar (open "bar.txt" :direction :output))
      (with-open-stream (hoge (make-broadcast-stream foo bar))
        (broadcast-stream-streams hoge))))
  => (#<file-output stream: C:/applications/xyzzy/foo.txt>
      #<file-output stream: C:/applications/xyzzy/bar.txt>)


buffer-can-redo-p
[       type]: Function
[  arguments]: buffer-can-redo-p BUFFER
[    package]: editor
[    seealso]: redo
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@redo\ȏԂȂtAłȂnilԂ܂B


buffer-can-undo-p
[       type]: Function
[  arguments]: buffer-can-undo-p BUFFER
[    package]: editor
[    seealso]: undo
[       file]: builtin.l
[    section]: obt@
[description]: 
bufferundo\ȂtAłȂnilԂ܂B


buffer-eol-code
[       type]: Function
[  arguments]: buffer-eol-code &optional BUFFER
[    package]: editor
[    seealso]: set-buffer-eol-code , *default-eol-code*
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̉sR[hԂ܂BύXꍇset-buffer-eol-codegp
܂B

 BUFFER: sR[hԂobt@
         w肪Ό݂̃obt@

߂l:
  0  *eol-lf*   LF
  1  *eol-cr*   CR
  2  *eol-crlf* CRLF


buffer-fileio-encoding
[       type]: Function
[  arguments]: buffer-fileio-encoding &optional BUFFER
[    package]: editor
[    seealso]: set-buffer-fileio-encoding , *default-fileio-encoding*
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̕GR[fBOԂ܂BύXꍇɂ́A
set-buffer-fileio-encodinggp܂B

gpF
  (buffer-fileio-encoding)
  => #.(make-iso2022-encoding "jis" ... )

QƁF
  kanji.l


buffer-fold-width
[       type]: Function
[  arguments]: buffer-fold-width &optional BUFFER
[    package]: editor
[    seealso]: default-fold-width , set-buffer-fold-width
[       file]: builtin.l
[    section]: eLXg
[description]: 
܂Ԃ̏ԂԂ܂B

  BUFFER : Ԃ擾obt@

߂l͈ȉ̂ƂłB

  t    EBhEŐ܂Ԃ
  nil  ܂ԂȂ
  l ̕Ő܂Ԃ܂B

lŕԂĂĂ t ̈Ӗ͕słB


buffer-lines
[       type]: Function
[  arguments]: buffer-lines &optional BUFFER
[    package]: editor
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̕sԂ܂B

gpF  
  (buffer-lines)
  => 5014


buffer-list
[       type]: Function
[  arguments]: buffer-list &key :buffer-bar-order
[    package]: editor
[    seealso]: enum-buffers
[   referred]: get-next-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
Sobt@XgŕԂ܂B

gp:
  (buffer-list)
  =>(#<buffer:  *Minibuf0*> #<buffer: *grep*> #<buffer: *scratch*> #<buffer: *untitled*> #<buffer: addref.xml> #<buffer: reference.xml>)
  
  (buffer-list :buffer-bar-order t)
  =>(#<buffer: *scratch*> #<buffer: reference.xml> #<buffer: *untitled*> #<buffer: addref.xml> #<buffer: *grep*> #<buffer:  *Minibuf0*>)
  
  ;;~jobt@̖O̓Xy[XŎn܂_ɒ
  (mapcar #'buffer-name (buffer-list))
  =>(" *Minibuf0*" "*grep*" "*scratch*" "*untitled*" "addref.xml" "reference.xml")


buffer-local-value
[       type]: Function
[  arguments]: buffer-local-value BUFFER SYMBOL
[    package]: editor
[    seealso]: symbol-value , make-local-variable , defvar-local
[       file]: builtin.l
[    section]: obt@
[description]: 
w肳ꂽobt@̃[Jϐ̒lԂ܂B

  BUFFER : [JȒl擾obt@
  SYMBOL : [Jϐ

gpF
  (buffer-local-value (selected-buffer) 'mode-name)
  => "xmldoc"


buffer-menu
[       type]: Function
[  arguments]: buffer-menu
[    package]: editor
[   referred]: select-buffer
[       file]: buf-menu.l
[    section]: obt@
[description]: 
obt@ꗗ\܂B
ꗗ̒ł̓obt@̑IA폜Ȃǂł܂B


buffer-mode
[       type]: BufferLocal
[    package]: editor
[    seealso]: mode-name
[    section]: obt@
[description]: 
Jgobt@̃[hi[Ă܂B

gpF
  ;;; list-interaction-modȅꍇ
  buffer-mode
  => lisp-interaction-mode


buffer-modified-count
[       type]: Function
[  arguments]: buffer-modified-count &optional BUFFER
[    package]: editor
[    seealso]: buffer-modified-p
[       file]: builtin.l
[    section]: obt@
[description]: 
iobt@CꂽJEgHj


buffer-modified-p
[       type]: Function
[  arguments]: buffer-modified-p &optional BUFFER
[    package]: editor
[    seealso]: set-buffer-modified-p , buffer-modified-count
[   referred]: save-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@ BUFFER ύXĂ邩ǂԂ܂B
obt@ύXĂȂ nil AύXĂ鎞̓obt@̕ҏW
(buffer-modified-count ̒l)Ԃ܂B
BUFFER w肳ȂA nil w肳ꂽ̓Jgobt@̌
ʂԂ܂B


buffer-name
[       type]: Function
[  arguments]: buffer-name BUFFER
[    package]: editor
[    seealso]: create-new-buffer , get-buffer-create , rename-buffer , find-name-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̖OԂ܂B

  BUFFER : OԂobt@w肵܂B

gpF
  ;;; Jgobt@̖OԂ܂B
  (buffer-name (selected-buffer))
  => "reference.xml"


buffer-process
[       type]: Function
[  arguments]: buffer-process BUFFER
[    package]: editor
[    seealso]: make-process
[   referred]: process-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@ɌѕtĂvZXԂ܂B
vZXmake-processō쐬܂B


buffer-read-only
[       type]: BufferLocal
[    package]: editor
[    seealso]: toggle-read-only , setup-temp-buffer
[   referred]: ed::find-file-internal
[    section]: ϐƒ萔
[description]: 
obt@ǂݎpǂǗ܂B

  t     obt@͓ǂݎp
  nil   obt@͓ǂݏ\


buffer-selector
[       type]: Function
[  arguments]: buffer-selector
[    package]: editor
[    seealso]: select-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@IEBhE\܂B
obt@I΂̃obt@AłȂnilԂ܂B


buffer-size
[       type]: Function
[  arguments]: buffer-size &optional BUFFER
[    package]: editor
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̃TCYԂ܂B2oCĝ buffer-size ̕Ԃl
t@CTCY͈v܂B

gpF
  (buffer-size)
  => 200170


buffer-stream-buffer
[       type]: Function
[  arguments]: buffer-stream-buffer STREAM
[    package]: editor
[    seealso]: make-buffer-stream , buffer-stream-point , xyzzyŒ񋟂ĂXg[̎
[       file]: builtin.l
[    section]: o
[description]: 
buffer-streamłXg[֘AtĂobt@Ԃ܂B

  STREAM : buffer-streamłXg[w肵܂B


buffer-stream-p
[       type]: Function
[  arguments]: buffer-stream-p STREAM
[    package]: editor
[    seealso]: make-buffer-stream , xyzzyŒ񋟂ĂXg[̎
[       file]: builtin.l
[    section]: o
[description]: 
Xg[buffer-streamǂԂ܂B

  STREAM : 肷Xg[

  t   Xg[buffer-streamłB
  nil Xg[buffer-streamł͂ȂB


buffer-stream-point
[       type]: Function
[  arguments]: buffer-stream-point STREAM
[    package]: editor
[    seealso]: buffer-stream-set-point , buffer-stream-buffer , file-position , make-buffer-stream , read , xyzzyŒ񋟂ĂXg[̎
[       file]: builtin.l
[    section]: o
[description]: 
buffer-streamłXg[̓o͂̃|CgԂ܂B

  STREAM : buffer-streamłXg[w肵܂B


buffer-stream-set-point
[       type]: Function
[  arguments]: buffer-stream-set-point STREAM POINT
[    package]: editor
[    seealso]: buffer-stream-point , xyzzyŒ񋟂ĂXg[̎
[   referred]: file-position , make-buffer-stream
[       file]: builtin.l
[    section]: o
[description]: 
buffer-streamłXg[̓o͂̃|Cgw肵܂B

  STREAM : buffer-streamłXg[w肵܂B
  POINT  : buffer-stream̓o͂̃|Cgw肵܂B

QlF
  misc.l with-output-to-buffer Ƃ with-input-from-buffer


buffer-substring
[       type]: Function
[  arguments]: buffer-substring FROM TO
[    package]: editor
[    seealso]: substring
[       file]: builtin.l
[    section]: 
[description]: 
obt@̎w肳ꂽ͈͂̕Ԃ܂B


bufferp
[       type]: Function
[  arguments]: bufferp OBJECT
[    package]: editor
[       file]: builtin.l
[    section]: obt@
[description]: 
OBJECTobt@ȂtAłȂȂnilԂ܂B


bury-buffer
[       type]: Function
[  arguments]: bury-buffer &optional BUFFER
[    package]: editor
[    seealso]: other-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
other-buffeř̍Ōɂ܂B


butlast
[       type]: Function
[  arguments]: butlast LIST &optional (N 1)
[    package]: lisp
[    seealso]: nbutlast , last , subseq
[       file]: list.l
[    section]: Xg
[description]: 
Xg̍ŌNvfXgԂ܂B
 LIST ͕ۑ܂B

gpF
  ;;; Ō̗vf菜B
  (butlast '(1 2 3))
  => (1 2) 
  ;;; Ō2vf菜B
  (butlast '(1 2 3) 2)
  => (1) 


byte
[       type]: Function
[  arguments]: byte SIZE POSITION
[    package]: lisp
[    seealso]: dpb , ldb , byte-position , byte-size
[       file]: number.l
[    section]: l
[description]: 
byte specifier ܂B
u0 Ƃ POSITION rbgڂn܂ SIZE rbgv
\IuWFNgԂ܂B

Iɂ cons ƓłB


byte-position
[       type]: Function
[  arguments]: byte-position BYTESPEC
[    package]: lisp
[    seealso]: byte
[       file]: number.l
[    section]: l
[description]: 
byte specifier ̈ʒuԂ܂B

Iɂ cdr ƓłB


byte-size
[       type]: Function
[  arguments]: byte-size BYTESPEC
[    package]: lisp
[    seealso]: byte
[       file]: number.l
[    section]: l
[description]: 
byte specifier ̃TCYԂ܂B

Iɂ car ƓłB


caaaar
[       type]: Function
[  arguments]: caaaar X
[    package]: lisp
[    seealso]: car
[       file]: list.l
[    section]: Xg
[description]: 
caaaar Ԃ܂B

  (caaaar X) = (car (car (car (car X))))


caaadr
[       type]: Function
[  arguments]: caaadr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
caaadr Ԃ܂B

  (caaadr X) = (car (car (car (cdr X))))


caaar
[       type]: Function
[  arguments]: caaar X
[    package]: lisp
[    seealso]: car
[       file]: list.l
[    section]: Xg
[description]: 
caaar Ԃ܂B

  (caaar X) = (car (car (car X)))


caadar
[       type]: Function
[  arguments]: caadar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
caadar Ԃ܂B

  (caadar X) = (car (car (cdr (car X))))


caaddr
[       type]: Function
[  arguments]: caaddr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
caaddr Ԃ܂B

  (caaddr X) = (car (car (cdr (cdr X))))


caadr
[       type]: Function
[  arguments]: caadr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
caadr Ԃ܂B

  (caadr X) = (car (car (cdr X)))


caar
[       type]: Function
[  arguments]: caar X
[    package]: lisp
[    seealso]: car
[       file]: list.l
[    section]: Xg
[description]: 
caar Ԃ܂B

  (caar X) = (car (car X))


cadaar
[       type]: Function
[  arguments]: cadaar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cadaar Ԃ܂B

  (cadaar X) = (car (cdr (car (car X))))


cadadr
[       type]: Function
[  arguments]: cadadr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cadadr Ԃ܂B

  (cadadr X) = (car (cdr (car (cdr X))))


cadar
[       type]: Function
[  arguments]: cadar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cadar Ԃ܂B

  (cadar X) = (car (cdr (car X)))


caddar
[       type]: Function
[  arguments]: caddar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
caddar Ԃ܂B

  (caddar X) = (car (cdr (cdr (car X))))


cadddr
[       type]: Function
[  arguments]: cadddr X
[    package]: lisp
[    seealso]: car , cdr , fourth
[       file]: list.l
[    section]: Xg
[description]: 
cadddr Ԃ܂B

  (cadddr X) = (car (cdr (cdr (cdr X))))


caddr
[       type]: Function
[  arguments]: caddr X
[    package]: lisp
[    seealso]: car , cdr , third
[       file]: list.l
[    section]: Xg
[description]: 
caddr Ԃ܂B

  (caddr X) = (car (cdr (cdr X)))


cadr
[       type]: Function
[  arguments]: cadr X
[    package]: lisp
[    seealso]: car , cdr , second
[       file]: list.l
[    section]: Xg
[description]: 
cadr Ԃ܂B

  (cadr X) = (car (cdr X))


calendar
[       type]: Function
[  arguments]: calendar &optional YEAR
[    package]: editor
[       file]: calendar.l
[    section]: tE
[description]: 
YEARɂw肳ꂽÑJ_[\܂Bɂ͉A
jՓɂ͐FtĂ܂B}EX̏ɈړƁAx
̓e|bvAbv\܂B


call-arguments-limit
[       type]: Variable
[    package]: lisp
[    seealso]: lambda-parameters-limit
[    section]: ϐƒ萔
[description]: 
֐ɗ^邱Ƃ̂ł̌̌El

QƗF 
  call-arguments-limit
  => 536870911


call-interactively
[       type]: Function
[  arguments]: call-interactively COMMAND &optional HOOK
[    package]: editor
[    seealso]: command-execute
[       file]: misc.l
[    section]: ]
[description]: 
w肳ꂽ֐interactiveɌĂяôƂs܂B

  COMMAND : interactiveɌĂяo֐w肵܂B
            (interactive ...)ƂĐ錾ꂽ֐łȂ΂Ȃ܂B

gpF
  ;;; find-file𖳈ŌĂяoĂG[ɂȂB
  (find-file)
  => Ȃ܂: (find-file)

  ;;; interactiveɌĂяoƑv
  (call-interactively 'find-file)
  => Find file: C:/applications/xyzzy/


call-last-kbd-macro
[       type]: Function
[  arguments]: call-last-kbd-macro &optional (ARG 1)
[    package]: editor
[    seealso]: command-execute
[       file]: kbdmacro.l
[    section]: }N
[description]: 
start-kbd-macro/end-kbd-macroœo^L[{[h}Ns܂B
[C-x e]
[c[(T)]-[L[{[h}N܂(O)]-[ۑ]L[{[h}ŃA
[c[(T)]-[L[{[h}N܂(O)]-[ǂݍ]ŌォI邱Ƃ\łB


call-menu
[       type]: Function
[  arguments]: call-menu N
[    package]: editor
[       file]: builtin.l
[    section]: j[
[description]: 
ut@C(F)vuҏW(E)vƂj[ N Ԗڂ̍ڂJ܂B
N ɂ 0 IWňʒuw肵܂B
Ȃ킿 0 w肵Ƃ͒ʏut@C(F)ṽj[J܂B


call-process
[       type]: Function
[  arguments]: call-process COMMAND-LINE &key :environ :no-std-handles :input :output :error :exec-directory :show :wait
[    package]: editor
[    seealso]: execute-shell-command , make-process
[   referred]: filter-region
[       file]: builtin.l
[    section]: vZX
[description]: 
OvOs܂BSxyzzẙOŃvOs܂B

  COMMAND-LINE    : sR}hIvVtŎw肵܂B
  :environ        : ݒ肷ϐAzXg`œn܂B
                    (("HOME" . "C:/applications/xyzzy/")
                     ("TOPDIR" . "C:/spool/"))
  :no-std-handles : t ̏ꍇC :input :output :error ̎w𖳎܂D
  :input          : W͂gpOvOłΓ̓t@C
                    w肵܂B
  :output         : Wo͂gpOvOłΏo̓t@C
                    w肵܂B
  :error          : WG[o͂gpOvOłΏo̓t@
                    Cw肵܂Dw肵ȂƂ́CWo͂ɏo͂
                    ܂D
  :exec-directory : sfBNgw肵܂B
  :show           : OvO̎s̕\w肵܂B
                    :show      ʏ̃EBhE
                    :no-active ANeBu
                    :minimize  ŏ
                    :maximize  ő剻
                    :hide      \
                    LȊO   ʏ̃EBhE
  :wait           : OvOÎ҂킹܂B

svZX擾Ƃ make-process g܂D

gpF
  ;;; notepad.exȅI҂킹Ă݂B
  (call-process "notepad" :wait t)


capitalize-region
[       type]: Function
[  arguments]: capitalize-region FROM TO
[    package]: editor
[    seealso]: downcase-region , upcase-region
[   referred]: capitalize-word
[       file]: builtin.l
[    section]: [W
[description]: 
[W̒Pcapitalize܂B
܂AP̐擪啶ɁAȊOɂ܂B


capitalize-word
[       type]: Function
[  arguments]: capitalize-word &optional (ARG 1)
[    package]: editor
[    seealso]: upcase-word , downcase-word , capitalize-region , capitalize-selection , forward-word
[       file]: cmds.l
[    section]: 
[description]: 
O̒P̐擪̕啶ɁAȊO̕ɕϊ܂B
[ESC c]
J[\P̓rɂꍇ́AJ[\ʒu̕啶ɁA
~̕ɕϊ܂B


car
[       type]: Function
[  arguments]: car LIST
[    package]: lisp
[    seealso]: first , safe-car
[   referred]: caaaar , caaadr , caaar , caadar , caaddr , caadr , caar , cadaar , cadadr , cadar , caddar , cadddr , caddr , cadr , cdaaar , cdaadr , cdaar , cdadar , cdaddr , cdadr , cdar , cddaar , cddadr , cddar , cdddar
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg̍ŏ̗vfԂ܂B

RXZ LIST ̍ŏ̃|C^Ԃ܂B LIST  nil ̏ꍇ car  
nil Ԃ悤A`Ă܂BXgłȂꍇAG[ɂȂ܂
XgȊOłG[ɂȂė~Ȃꍇɂ́Asafe-car gp܂B

gpF
  (car '(a b c))
  => a
  (car '())
  => nil
  (car "string")
  => sȃf[^^ł: "string": cons


case
[       type]: Macro
[  arguments]: case KEYFORM &rest FORMS
[    package]: lisp
[       file]: evalmacs.l
[    section]: \
[description]: 
Cswitch݂Ȃ̂łB

(case <L[>
  (<Xg1> <>`<>)
  (<Xg2> <>`<>)
       ...
  (<Xgn> <>`<>))

܂<L[>]Cꂪ<Xg>̂ǂꂩ̗vfƈv΁C
<Xg>ɑɕ]āCŌ̎̒lcase̒lƂĕ
Bǂ<Xg>̂ǂ̗vfɂvȂcase̒lnilłB
OƂāCŌ̃Xg(<Xgn>)tł΁Cuǂɂ
vȂ΁vӖB

<Xg1>`<Xgn>܂ł́Cꂼf[^̃XgŁC
͕]ȂBȂ킿lXgɂȂ鎮ł͂ȂCXĝ̂
ɓBvf̏ꍇ́CXg̑ɗvfɂĂB

gpF
  ;;; 4͂ďꍇ
  (setq x 4)
  => 4
  (case x
    (1 'one)
    (2 'two)
    (3 'three)
    ((4 5) 'four_or_five)
    (t 'large))
  => four_or_five


catch
[       type]: Special Form
[  arguments]: catch TAG {FORM}*
[    package]: lisp
[    seealso]: throw
[       file]: builtin.l
[    section]: \
[description]: 
throw𓊂邽߂̃xݒ肵܂B
C++tryɑ܂B

  C++  : try    throw
  Lisp : catch  throw

QlF
  G[֘A


cd
[       type]: Function
[  arguments]: cd DIRECTORY
[    package]: editor
[    seealso]: set-default-directory
[       file]: misc.l
[    section]: t@CVXe
[description]: 
obt@ƂĂfBNgC^NeBuɕύX܂B


cdaaar
[       type]: Function
[  arguments]: cdaaar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdaaar Ԃ܂B

  (cdaaar X) = (cdr (car (car (car X))))


cdaadr
[       type]: Function
[  arguments]: cdaadr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdaadr Ԃ܂B

  (cdaadr X) = (cdr (car (car (cdr X))))


cdaar
[       type]: Function
[  arguments]: cdaar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdaar Ԃ܂B

  (cdaar X) = (cdr (car (car X)))


cdadar
[       type]: Function
[  arguments]: cdadar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdadar Ԃ܂B

  (cdadar X) = (cdr (car (cdr (car X))))


cdaddr
[       type]: Function
[  arguments]: cdaddr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdaddr Ԃ܂B

  (cdaddr X) = (cdr (car (cdr (cdr X))))


cdadr
[       type]: Function
[  arguments]: cdadr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdadr Ԃ܂B

  (cdadr X) = (cdr (car (cdr X)))


cdar
[       type]: Function
[  arguments]: cdar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdar Ԃ܂B

  (cdar X) = (cdr (car X))


cddaar
[       type]: Function
[  arguments]: cddaar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cddaar Ԃ܂B

  (cddaar X) = (cdr (cdr (car (car X))))


cddadr
[       type]: Function
[  arguments]: cddadr X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cddadr Ԃ܂B

  (cddadr X) = (cdr (cdr (car (cdr X))))


cddar
[       type]: Function
[  arguments]: cddar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cddar Ԃ܂B

  (cddar X) = (cdr (cdr (car X)))


cdddar
[       type]: Function
[  arguments]: cdddar X
[    package]: lisp
[    seealso]: car , cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdddar Ԃ܂B

  (cdddar X) = (cdr (cdr (cdr (car X))))


cddddr
[       type]: Function
[  arguments]: cddddr X
[    package]: lisp
[    seealso]: cdr
[       file]: list.l
[    section]: Xg
[description]: 
cddddr Ԃ܂B

  (cddddr X) = (cdr (cdr (cdr (cdr X))))


cdddr
[       type]: Function
[  arguments]: cdddr X
[    package]: lisp
[    seealso]: cdr
[       file]: list.l
[    section]: Xg
[description]: 
cdddr Ԃ܂B

  (cdddr X) = (cdr (cdr (cdr X)))


cddr
[       type]: Function
[  arguments]: cddr X
[    package]: lisp
[    seealso]: cdr
[       file]: list.l
[    section]: Xg
[description]: 
cddr Ԃ܂B

  (cddr X) = (cdr (cdr X))


cdr
[       type]: Function
[  arguments]: cdr LIST
[    package]: lisp
[   referred]: caaadr , caadar , caaddr , caadr , cadaar , cadadr , cadar , caddar , cadddr , caddr , cadr , cdaaar , cdaadr , cdaar , cdadar , cdaddr , cdadr , cdar , cddaar , cddadr , cddar , cdddar , cddddr , cdddr , cddr , rest , safe-cdr
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg̓Ԗڈȍ~XgŕԂ܂B

RXZ LIST  2 Ԗڂ̃|C^Ԃ܂B LIST  nil ̏ꍇ cdr 
 nil Ԃ悤A`Ă܂BXgłȂꍇAG[ɂ
܂BXgȊOłG[ɂȂė~Ȃꍇɂ́Asafe-cdr
gp܂B

gpF
  (cdr '(a b c))
  => (b c)
  (cdr '())
  => nil
  (cdr "string")
  => sȃf[^^ł: "string": cons


ceiling
[       type]: Function
[  arguments]: NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: floor , truncate , round , fceiling
[       file]: builtin.l
[    section]: l
[description]: 
NUMBER𐳂̖Ɋۂ߂܂B
DIVISORȗꍇɂNUMBERȏ̍ŏ̐ɂȂ܂B

gpF  
  (ceiling 2.2)
  => 3
  (ceiling 2.8)
  => 3
  (ceiling -2.2)
  => -2  
  (multiple-value-list (ceiling 2.2))
  => (3 -0.8)


char
[       type]: Function
[  arguments]: char STRING INDEX
[    package]: lisp
[    seealso]: schar
[       file]: builtin.l
[    section]: 
[description]: 
STRINGINDEXԖڂ̕Ԃ܂B
INDEX0Ƃ܂B

gpF
  ;;; 擪Ō܂Ŏ擾B
  (char "foo" -1) => ͈͊O̒lł: -1
  (char "foo" 0)  => #\f
  (char "foo" 1)  => #\o
  (char "foo" 2)  => #\o
  (char "foo" 3)  => ͈͊O̒lł: 3


char-after
[       type]: Function
[  arguments]: char-after POINT &optional NOT-USED
[    package]: editor
[    seealso]: following-char , char-before
[       file]: builtin.l
[    section]: 
[description]: 
Jgobt@ POINT ʒu̕Ԃ܂B
(point-min)ȉ̒lw肳ꂽꍇ(point-min)̕ԂB
(point-max)ȏ̒lw肳ꂽꍇ #\NUL ԂB

  POINT    : INTEGER  MARKER Ń|Cgw
  NOT-USED : sgp

߂lF
  

gpF
  ;;; |Cg c ̈ʒu ESC ESC (char-after (point)) ꍇ
  abcdefg
    ^ ̃|Cg ESC ESC (char-after (point)) => #\c


char-before
[       type]: Function
[  arguments]: char-before POINT &optional NOT-USED
[    package]: editor
[    seealso]: char-after , preceding-char
[       file]: builtin.l
[    section]: 
[description]: 
Jgobt@ POINT ̑Öʒu̕Ԃ܂B
(point-max)ȏ̒lw肳ꂽꍇ(point-max)̑Öʒu̕ԂB
(point-min)ȉ̒lw肳ꂽꍇ #\NUL ԂB

  POINT    : INTEGER  MARKER Ń|Cgw
  NOT-USED : sgp

߂l:
  

gpF
  ;;; |Cg c ̈ʒu ESC ESC (char-before (point)) ꍇ
  abcdefg
    ^ ̃|Cg ESC ESC (char-before (point)) => #\b


char-code
[       type]: Function
[  arguments]: char-code CHAR
[    package]: lisp
[    seealso]: code-char , char-unicode , unicode-char , iso-code-char
[       file]: builtin.l
[    section]: 
[description]: 
CHAR ̕R[hԂ܂B
R[hƃLN^̊Ԃ̑ݕϊɂ́Acode-charg܂B

gpF
  (char-code #\a)
  => 97
  (code-char (char-code #\a))
  => #\a


char-code-limit
[       type]: Variable
[    package]: lisp
[    seealso]: *character-name-hash-table* , make-character-name-hash-table
[    section]: ϐƒ萔
[description]: 
R[ȟEl߂Ă萔(65536)łB
*character-name-hash-table* ݒ肷
(make-character-name-hash-table) ֐̒`ł̂ݎgpĂ܂B
xyzzy \[XŒ`Ă܂B


char-columns
[       type]: Function
[  arguments]: char-columns CHAR
[    package]: editor
[    seealso]: count-column , current-line-columns , *unicode-to-half-width*
[       file]: builtin.l
[    section]: 
[description]: 
 CHAR ̕Ԃ܂B

gpF
  (char-columns #\a)        => 1
  (char-columns #\)       => 2
  (char-columns #\asterisk) => 1
  ;;; UNICODE p\
  (setq *unicode-to-half-width* t)   => t
  (char-columns (unicode-char 180))  => 1
  ;;; UNICODE Sp\
  (setq *unicode-to-half-width* nil) => nil
  (char-columns (unicode-char 180))  => 2


char-downcase
[       type]: Function
[  arguments]: char-downcase CHAR
[    package]: lisp
[    seealso]: char-upcase , lower-case-p , string-downcase
[       file]: builtin.l
[    section]: 
[description]: 
CHARɂĕԂ܂B

gpF  
  (char-downcase #\A)
  => #\a


char-equal
[       type]: Function
[  arguments]: char-equal CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: equalp , char=
[       file]: builtin.l
[    section]: 
[description]: 
ׂđ啶֌WȂtAłȂnilԂ܂B

gpF  
  (char-equal #\A #\a)
  => t


char-greaterp
[       type]: Function
[  arguments]: char-greaterp CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char>
[       file]: builtin.l
[    section]: 
[description]: 
̕Sđ啶֌WȂ~ȂtAłȂnilԂ܂B

gpF
  (char-greaterp #\c #\b #\a)
  => t
  (char-greaterp #\c #\b #\b)
  => nil
  (char-greaterp #\b #\A)
  => t
  (char-greaterp #\B #\a)
  => t


char-lessp
[       type]: Function
[  arguments]: char-lessp CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char<
[       file]: builtin.l
[    section]: 
[description]: 
̕Sđ啶֌WȂȂtAłȂnilԂ܂B

gpF  
  (char-lessp #\a #\b #\c)
  => t
  (char-lessp #\a #\b #\b)
  => nil
  (char-lessp #\A #\b)
  => t
  (char-lessp #\a #\B)
  => t


char-name
[       type]: Function
[  arguments]: char-name C
[    package]: editor
[       file]: misc.l
[    section]: 
[description]: 
̉p̂Ԃ܂B
̉p̂͂ǂŒ`ꂽ̂Ȃ̂ł傤H

gpF
  ;;; 낢Ɖp̂Ă݂B
  (char-name #\x00)     => "null"
  (char-name #\x0a)     => "line_feed"
  (char-name #\x0d)     => "carriage_return"
  (char-name #\a)       => "latin_small_letter_a"
  (char-name #\)      => "hiragana_letter_ga"
  (char-name #\)      => "katakana_letter_wo"
  (char-name #\)      => nil 


char-not-equal
[       type]: Function
[  arguments]: char-not-equal CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char/=
[       file]: builtin.l
[    section]: 
[description]: 
ׂđ啶֌WȂȂtAłȂnilԂ܂B

gpF
  (char-not-equal #\a #\b #\c)
  => t
  (char-not-equal #\a #\A)
  => nil


char-not-greaterp
[       type]: Function
[  arguments]: char-not-greaterp CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char<=
[       file]: builtin.l
[    section]: 
[description]: 
̕Sđ啶֌WȂtAłȂnil
Ԃ܂B

gpF  
  (char-not-greaterp #\a #\B #\c)
  => t


char-not-lessp
[       type]: Function
[  arguments]: char-not-lessp CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char>=
[       file]: builtin.l
[    section]: 
[description]: 
̕Sđ啶֌WȂ~tAłȂnil
Ԃ܂B

gpF  
  (char-not-lessp #\c #\B #\a)
  => t


char-unicode
[       type]: Function
[  arguments]: char-unicode CHAR
[    package]: editor
[    seealso]: unicode-char , char-code
[   referred]: code-char
[       file]: builtin.l
[    section]: 
[description]: 
UNICODẼR[hlԂ܂B

gpF
  ;;; UNICODẼR[hl擾Ă݂B
  (char-unicode #\x00)  => 0
  (char-unicode #\a)    => 97
  (char-unicode #\)   => 28450


char-upcase
[       type]: Function
[  arguments]: char-upcase CHAR
[    package]: lisp
[    seealso]: char-downcase , upper-case-p , string-upcase
[       file]: builtin.l
[    section]: 
[description]: 
CHAR啶ɂĕԂ܂B

gpF  
  (char-upcase #\x)
  => #\X


char/=
[       type]: Function
[  arguments]: char/= CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char-not-equal
[       file]: builtin.l
[    section]: 
[description]: 
̕SēȂtAłȂnilԂ܂B

gpF  
  (char/= #\a #\b #\c)
  => t
  (char/= #\a #\b #\a)
  => nil
  (char/= #\a #\A)
  => t


char<
[       type]: Function
[  arguments]: char< CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char-lessp
[       file]: builtin.l
[    section]: 
[description]: 
̕SďȂtAłȂnilԂ܂B

gpF  
  (char< #\a #\b #\c)
  => t
  (char< #\a #\b #\b)
  => nil
  (char< #\A #\b)
  => t
  (char< #\a #\B)
  => nil


char<=
[       type]: Function
[  arguments]: char<= CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char-not-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
ׂ荇̊֌WׂďtAłȂnilԂ܂B

gpF  
  (char<= #\a #\b #\b #\c)
  => t
  (char<= #\a #\b #\c #\b)
  => nil


char=
[       type]: Function
[  arguments]: char= CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: eql , equal , char-equal
[       file]: builtin.l
[    section]: 
[description]: 
ׂ̕ētAłȂnilԂ܂B

gpF  
  (char= #\a #\a #\a)
  => t
  (char= #\a #\d)
  => nil
  (char= #\a #\A)
  => nil

QlF
  case-sensitive        case-insensitive
  ----                  ----
  char=                 char-equal
  char/=                char-not-equal
  char<                 char-lessp
  char>                 char-greaterp
  char<=                char-not-greaterp
  char>=                char-not-lessp


char>
[       type]: Function
[  arguments]: char> CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
̕Sč~ȂtAłȂnilԂ܂B

gpF  
  (char> #\c #\b #\a)
  => t
  (char> #\c #\b #\d)
  => nil
  (char> #\b #\A)
  => t
  (char> #\a #\B)
  => t


char>=
[       type]: Function
[  arguments]: char>= CHARACTER &rest MORE-CHARACTERS
[    package]: lisp
[    seealso]: char-not-lessp
[       file]: builtin.l
[    section]: 
[description]: 
ׂ荇̊֌Wׂč~tAłȂnilԂ܂B

gpF  
  (char>= #\c #\b #\b #\a)
  => t
  (char>= #\c #\b #\d)
  => nil


character
[       type]: Function
[  arguments]: character OBJECT
[    package]: lisp
[    seealso]: coerce
[       file]: builtin.l
[    section]: 
[description]: 
OBJECT\ȂcharacterɕϊĕԂ܂B

  (character 'x) == (coerce 'x 'character)

gpF
  (character 'x)        => #\x
  (character "A")       => #\A
  (character "1")       => #\1
  (character "10")      => ւ̕ϊ̓T|[gĂ܂: "10"


characterp
[       type]: Function
[  arguments]: characterp OBJECT
[    package]: lisp
[    seealso]: alpha-char-p , alphanumericp , digit-char-p , kana-char-p , kanji-char-p , standard-char-p , extended-alphabet-char-p , word-char-p
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT  character Ȃ t AȊOȂ nil Ԃ܂B


check-type
[       type]: Macro
[  arguments]: check-type PLACE TYPESPEC &optional STRING
[    package]: lisp
[       file]: condition.l
[    section]: f[^^
[description]: 
iڍוsj

gpF
  ;;; ň^`FbNĂ݂B
  (check-type n integer)


check-valid-pathname
[       type]: Function
[  arguments]: check-valid-pathname PATHNAME
[    package]: lisp
[    seealso]: file-exist-p , valid-path-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAME݂tAłȂnilԂ܂B

gpF
  ;;; ݂C:/xyzzy/Ƒ݂ȂC:/xyzzzy/ׂĂ݂B
  (check-valid-pathname "C:/xyzzy/")
  => t
  (check-valid-pathname "C:/xyzzzy/")
  => nil


cis
[       type]: Function
[  arguments]: cis Z
[    package]: lisp
[       file]: number.l
[    section]: l
[description]: 
Ίp Z ŐΒl 1 ̕fԂ܂B

  (cis Z) == (complex (cos Z) (sin Z))


clear-all-text-attributes
[       type]: Function
[  arguments]: clear-all-text-attributes
[    package]: editor
[    seealso]: delete-text-attributes , delete-text-attribute-point , set-text-attribute
[       file]: builtin.l
[    section]: eLXg
[description]: 
set-text-attribute Őݒ肵S܂


clear-all-text-colors
[       type]: Function
[  arguments]: clear-all-text-colors
[    package]: editor
[    seealso]: delete-text-attributes , set-text-color
[       file]: cmds.l
[    section]: eLXg
[description]: 
set-text-color ŕt܂B

⑫:
  ̊֐ Version 0.0.0.92 ɂ set-text-color ƂƂ obsolete 
  Ȃ܂B


clear-input
[       type]: Function
[  arguments]: clear-input &optional INPUT-STREAM
[    package]: lisp
[    seealso]: open
[       file]: builtin.l
[    section]: o
[description]: 
̓Xg[Ƀobt@OĂ͂NA܂B


clear-message
[       type]: Function
[  arguments]: clear-message
[    package]: editor
[    seealso]: message
[       file]: misc.l
[    section]: o
[description]: 
Xe[^Xo[̃bZ[W܂B


clear-minibuffer-message
[       type]: Function
[  arguments]: clear-minibuffer-message
[    package]: editor
[    seealso]: minibuffer-message , minibuffer-prompt
[       file]: misc.l
[    section]: ~jobt@
[description]: 
~jobt@ɕ\ꂽ܂B


clear-rectangle
[       type]: Function
[  arguments]: clear-rectangle P1 P2
[    package]: editor
[    seealso]: open-rectangle , clear-rectangle-selection , operate-on-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
P1  P2 Ŏw肳`̈ #\SPC ŏ㏑܂B


clear-rectangle-selection
[       type]: Function
[  arguments]: clear-rectangle-selection
[    package]: editor
[    seealso]: open-rectangle-selection , clear-rectangle , operate-on-rectangle-selection
[       file]: select.l
[    section]: [W
[description]: 
`IꂽZNV̗̈ #\SPC ŏ㏑܂B


clear-reverse-region
[       type]: Function
[  arguments]: clear-reverse-region
[    package]: editor
[    seealso]: reverse-region
[       file]: builtin.l
[    section]: [W
[description]: 
reverse-regionŔ]\ɖ߂܂B


clear-undo-boundary
[       type]: Function
[  arguments]: clear-undo-boundary &optional BUFFER
[    package]: editor
[    seealso]: undo , undo-boundary , kept-undo-information
[       file]: builtin.l
[    section]: obt@
[description]: 
UNDO񂩂璼߂̋E폜܂B

gpF
  (defun self-insert-space (&optional (arg 1))
    (interactive "*")
    (when (eq *last-command* 'self-insert-space)
      (clear-undo-boundary))
    (self-insert-command arg))
  (define-key ed::*lisp-mode-map* #\SPC 'self-insert-space)


close
[       type]: Function
[  arguments]: close STREAM &key :abort
[    package]: lisp
[    seealso]: open
[       file]: builtin.l
[    section]: o
[description]: 
w肳ꂽXg[N[Y܂B

  STREAM : N[YXg[w肵܂B
  :abort : ُIɎw肵܂B
        t       Xg[ɑ΂镛pƂ܂B
        nil     Xg[ʂɏI܂B


close-session
[       type]: Function
[  arguments]: close-session &optional NOASK (CREATE-NEW t) (FN #'write-file)
[    package]: editor
[    seealso]: ed::auto-save-session-file
[   referred]: close-session-dialog , ed::*auto-save-session-file* , toggle-session-auto-save
[       file]: session.l
[    section]: obt@
[description]: 
ׂẴt[ *scratch* ׂẴobt@폜܂B
ۑĂȂobt@Εۑ܂B [C-x 6 k]

ed::*auto-save-session-file*  non-nil łA݃ZbVJ
ȂΓɃZbVt@C㏑܂B

  NOASK      : nil ̏ꍇt@CƂɕۑ邩ǂmF
  CREATE-NEW : non-nil ł΍ŌɐVt[ЂƂ
  FN         : t@C̕ۑɎg֐


close-session-dialog
[       type]: Function
[  arguments]: close-session-dialog &optional NOASK
[    package]: editor
[    seealso]: close-session
[       file]: session.l
[    section]: obt@
[description]: 
close-session ƂقړłAύXꂽobt@ۑۂ
_CAO\ĕۑw肵܂B [C-x 6 K]

  NOASK      : nil ̏ꍇt@CƂɕۑ邩ǂmF


clrhash
[       type]: Function
[  arguments]: clrhash HASH-TABLE
[    package]: lisp
[    seealso]: make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[ȗSvf폜܂B

  HASH-TABLE : nbVe[uw肵܂B


code-char
[       type]: Function
[  arguments]: code-char CODE
[    package]: lisp
[    seealso]: char-code , unicode-char , iso-char-code , char-unicode
[       file]: builtin.l
[    section]: 
[description]: 
R[hCODE̕Ԃ܂B
LN^ƕR[hƂ̊Ԃ̑ݕϊɂ́A char-code g܂B

gpF  
  (code-char 110)
  => #\n


coerce
[       type]: Function
[  arguments]: coerce OBJECT TYPE
[    package]: lisp
[    seealso]: type-of
[   referred]: character , string
[       file]: typespec.l
[    section]: f[^^
[description]: 
OBJECT  TYPE ^ɕϊ܂B

TYPE ̓V{܂̓XgŁAꂼȉ̌^ɕϊ܂B
  'list          Xg
  'array         z
  'simple-array 
  'character     
  'float         Px_
  'short-float  
  'single-float 
  'double-float  {x_
  'long-float   
  'complex       f
  'function      ֐
Xg̏ꍇA̍ŏ̗vfŌ^܂܂B
2Ԗڈȍ~̗vf́Aŏ̗vf arrayAsimple-arrayAcomplex ̏ꍇ̂
ӖAꂼȉ̂悤ɓ삵܂B
  '(array ...)         make-sequence  TYPE Ɠ
  '(simple-array ...) 
  '(complex ...)       AԖڂ̗vf̌^ɕϊ
  
gp:
  (coerce "abc" 'list)                         ; 𕶎̃Xg
  => (#\a #\b #\c)
  (coerce #(1 2 3) 'list)                      ; zXg
  => (1 2 3)
  (coerce '(a b c) '(array t 1))               ; Xgz
  => #(a b c)
  (coerce "abc" '(array t 1))                  ; 𕶎̔z
  => #(#\a #\b #\c)
  (coerce '(#\a #\b #\c) '(array character 1)) ; ̃Xg𕶎
  => "abc"
  (coerce "abc" '(array character 1))          ; ӖȂ
  => "abc"

  (coerce "a" 'character)                      ; 𕶎
  => #\a
  
  (coerce 1 'float)
  => 1.0
  (coerce 1 'double-float)
  => 1.0d0
  (coerce 1.0 'complex)
  => #C(1.0 0.0)
  (coerce #C(1 2) '(complex float))            ; Px̕f
  => #C(1.0 2.0)
  
  (coerce 'let 'function)                      ; V{̊֐Ԃ
  => #<function: let>
  (coerce '(lambda (x) (* x 2)) 'function)     ; ֐邱Ƃ
  => #<lexical-closure: (anonymous)>
  (funcall (coerce '(lambda (x) (* x 2)) 'function) 12)
  => 24


command-apropos
[       type]: Function
[  arguments]: command-apropos STRING
[    package]: editor
[    seealso]: apropos
[       file]: help.l
[    section]: V{
[description]: 
w肵K\Ɉv interactive 錾Ă֐̈ꗗ\
܂BoChꂽL[΁Aɕ\܂B


command-execute
[       type]: Function
[  arguments]: command-execute COMMAND &optional HOOK
[    package]: editor
[    seealso]: call-interactively , interactive , execute-extended-command , call-last-kbd-macro , *prefix-args*
[       file]: builtin.l
[    section]: ]
[description]: 
GfB^̃R}hs܂B
 
  COMMAND  : ̏ꍇCCOMMAND L[{[h}NƂĎs܂B
             V{̏ꍇCCOMMAND  interactive Ɏs܂B
  HOOK     : COMMANDV{̏ꍇ̂ݎg܂B
             HOOK ɂ́C2֐w肵C1̓V{C
             2ɂ̓vtBbNXA[Mgꍇ 
             (list *prefix-value*) CȂ nil ܂B
             R}hsCHOOKs܂B
             ȏ̏ڍׂ͕słB

gpF
  ;;; (command-execute "^X^F")Əfind-filesĂ݂܂B
  (command-execute "^X^F")
 
  ;;; interactiveȃR}hsĂ݂܂B
  (command-execute 'next-line)

  ;;; interactivełȂR}hsĂ݂܂B
  (command-execute 'goto-bol)
  =>sȃR}hł: goto-bol

  ;;; HOOKgĂ݂܂B 
  (command-execute 'next-line #'(lambda (x y) (msgbox "~w\n~w" x y)))

  ;;; eCC-j  C-u C-j ŏL̃R}hsĂ݂B


command-keys
[       type]: Function
[  arguments]: command-keys COMMAND GLOBAL-KEYMAP LOCAL-KEYMAP &optional MINOR-MODE-KEYMAPS
[    package]: editor
[    seealso]: lookup-keymap
[       file]: builtin.l
[    section]: L[}bv
[description]: 
w肵֐ɃoChꂽL[̃XgԂ܂B
MINOR-MODE-KEYMAPS LOCAL-KEYMAP GLOBAL-KEYMAP̏ɗD悳܂B

gp:
  (command-keys 'undo *global-keymap* (local-keymap) (minor-mode-map))
  => (#\C-\\ #\End)


command-output-alternate-send-input
[       type]: Function
[  arguments]: command-output-alternate-send-input
[    package]: editor
[    seealso]: command-output-send-input
[   referred]: command-output-mode
[       file]: process.l
[    section]: vZX
[description]: 
݂̃obt@Ɋ֘AtꂽvZXɑ΂āA}[J[ƌݍs̍s
̊Ԃ̕ \r Ȃđ܂B

}[J[́AvZXŌɏo͂obt@̈ʒuɂĂ܂B


command-output-mode
[       type]: Function
[  arguments]: command-output-mode
[    package]: editor
[    seealso]: command-output-send-input , command-output-alternate-send-input
[   referred]: execute-subprocess
[       file]: process.l
[    section]: vZX
[description]: 
obt@ command-output-mode ɂ܂B
ۑundoL^ȂȂ܂B

܂Aȉ̂悤ɐݒ肳ꂽ *command-output-mode-map* L[}bv
ƂĎg܂B
  RET : command-output-send-input 
  C-j : command-output-alternate-send-input


command-output-send-input
[       type]: Function
[  arguments]: command-output-send-input &optional EOL
[    package]: editor
[    seealso]: command-output-alternate-send-input , marker-point , process-send-string
[   referred]: command-output-mode
[       file]: process.l
[    section]: vZX
[description]: 
݂̃obt@Ɋ֘AtꂽvZXɑ΂āA}[J[ƌݍs̍s
̊Ԃ̕ EOL Ȃđ܂B EOL ̃ftHg \n łB

}[J[́AvZXŌɏo͂obt@̈ʒuɂĂ܂B


commandp
[       type]: Function
[  arguments]: commandp OBJECT
[    package]: editor
[    seealso]: interactive , interactive-p
[       file]: builtin.l
[    section]: ֐
[description]: 
֐ interactive 錾Ă tԂAłȂnilԂ܂B


compare-buffer-substrings
[       type]: Function
[  arguments]: compare-buffer-substrings BUFFER1 START1 END1 BUFFER2 START2 END2 &optional CASE-FOLD
[    package]: editor
[    seealso]: compare-windows
[       file]: builtin.l
[    section]: 
[description]: 
BUFFER1  BUFFER2 ̎w肳ꂽԂ̓eׂ܂B
҂̓e^ꂽԂ̂Z̒̊ԓƂA
߂l̐Βl͂̒ + 1 łB
߂l 0 ƂȂ鎖͂܂B

  CASE-FOLD : non-nil ŁA啶Eʂ܂B


compile-file-pathname
[       type]: Function
[  arguments]: compile-file-pathname PATHNAME
[    package]: lisp
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
xyzzy ŃoCgRpC̏o̓t@CԂ܂B


compile-regexp
[       type]: Function
[  arguments]: compile-regexp REGEXP &optional CASE-FOLD
[    package]: editor
[    seealso]: compiled-regexp-source , compiled-regexp-case-fold-p , regexpp , compile-regexp ƈꉞł傤H
[       file]: builtin.l
[    section]: EK\
[description]: 
K\RpC܂B
K\̉͂sȂAȂ悤łB
nilȊOw肷(ʂtw肵܂)啶ʂ܂B

  REGEXP     : RpC鐳K\
  :case-fold : 啶ʂ邩H
        t       啶͋ʂȂB
        nil     啶B

scan-buffer̈ɃRpCꂽK\nꍇɂ́A
compile-regexpł̎w肪LɂȂ,scan-buffer̈ɂ:case-fold͖
܂B

gpF
  ;;; "P.P:"ƂK\RpCĂ݂B
  ;;; ^񒆂'.'͐K\ƂĈė~Ȃ̂ŁAregexp-quoteB
  (compile-regexp (concat "\\w+" (regexp-quote ".") "\\w+:"))
  => #<compiled regular expression: \w+\.\w+:>


compile-regexp ƈꉞł傤H
[       type]: Tips
[   referred]: compile-regexp
[    section]: EK\
[description]: 
x͂ȂȂ͂ł(^^; ܁A̒xłB

  (let ((tick (get-internal-real-time)))
    (dotimes (x 100000)
      (string-match "a" "a"))
    (- (get-internal-real-time) tick))
  => 3484
  
  (let ((tick (get-internal-real-time))
        (regexp (compile-regexp "a")))
    (dotimes (x 100000)
      (string-match regexp "a"))
    (- (get-internal-real-time) tick))
  => 2984


compile-regexp-keyword-list
[       type]: Function
[  arguments]: compile-regexp-keyword-list LIST
[    package]: editor
[    seealso]: regexp-keyword-list
[       file]: re-kwd.l
[    section]: EK\
[description]: 
regexp-keyword-listpɐK\̃RpCs܂B
w肷LISŤ`regexp-keyword-listQƂĉB


compiled-function-p
[       type]: Function
[  arguments]: compiled-function-p OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTcompiled code objectȂtAȊOȂnilԂ܂B

gpF
  ;;; cař^𒲂ׂĂ݂B
  (type-of #'car)
  => compiled-function
  (compiled-function-p #'car)
  => t


compiled-regexp-case-fold-p
[       type]: Function
[  arguments]: compiled-regexp-case-fold-p REGEXP
[    package]: editor
[    seealso]: compile-regexp
[   referred]: compiled-regexp-source
[       file]: builtin.l
[    section]: EK\
[description]: 
RpCς݂̐K\A啶ʂ悤ɂȂĂ
邩ǂ𔻒肵܂B

gpF
  (setq a (compile-regexp "a+bc*d" t))
  => #<compiled regular expression: a+bc*d>
  (compiled-regexp-case-fold-p a)
  => t


compiled-regexp-source
[       type]: Function
[  arguments]: compiled-regexp-source REGEXP
[    package]: editor
[    seealso]: compile-regexp , compiled-regexp-case-fold-p
[       file]: builtin.l
[    section]: EK\
[description]: 
RpCς݂̐K\猳̐K\𒊏o܂B

gpF
  (setq a (compile-regexp "a+bc*d" t))
  => #<compiled regular expression: a+bc*d>
  (compiled-regexp-source a)
  => "a+bc*d"


complement
[       type]: Function
[  arguments]: complement FN
[    package]: lisp
[    seealso]: not
[       file]: sequence.l
[    section]: V[PX
[description]: 
FN ƋťʁinotjԂ֐Å֐Ԃ܂B

gp:
  (funcall (complement 'oddp) 4)
  => t


completing-read
[       type]: Function
[  arguments]: completing-read PROMPT COMPLETIONS &key :case-fold :default :history :must-match
[    package]: editor
[    seealso]: read-string , interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[̓͂ǂݎ܂B

  PROMPT      : \vvg
  COMPLETIONS : ⊮͂̂߂̃Xg
  :case-fold  : non nilȂ啶ʂȂ
  :default    : l̎w
  :history    : 
                minibuffer-history-variablevpeBV{w肵܂
  :must-match : non nilȂCOMPLETIONSȊO󂯕tȂ


complex
[       type]: Function
[  arguments]: complex REALPART &optional IMAGPART
[    package]: lisp
[    seealso]: imagpart , realpart
[       file]: builtin.l
[    section]: l
[description]: 
w肳ꂽ(REALPART)Ƌ(IMAGPART)ŕf\܂B

gpF
  (setq a (complex 0 1))
  =>#C(0 1)

  (* a a)
  =>-1


complexp
[       type]: Function
[  arguments]: complexp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT  complex number Ȃ t AȊOȂ nil Ԃ܂B


concat
[       type]: Function
[  arguments]: concat &rest SEQ
[    package]: editor
[    seealso]: concatenate
[       file]: misc.l
[    section]: 
[description]: 
w肳ꂽA܂B

gpF
  ;;; concatgĂ݂B
  (setq foo "It's ")            => "It's "
  (setq bar "show time!!!")     => "show time!!!"
  (concat foo bar)              => "It's show time!!!"
  (concat "It's " "show " "time!!!")
  =>"It's show time!!!"


concatenate
[       type]: Function
[  arguments]: concatenate RESULT-TYPE &rest SEQUENCES
[    package]: lisp
[    seealso]: make-sequence , append , concat , vconcat
[   referred]: merge
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCES  RESULT-TYPE ̃V[PXVAԂ܂B

RESULT-TYPE ɂ make-sequence Ɠl̂̂gpł܂B
RESULT-TYPE ̒lɂāA܂ɂ͈ȉ̊֐Ɠ܂B
  'list   <--> append
  'string <--> concat
  'vector <--> vconcat

Ȃ SEQUENCES  RESULT-TYPE ̌^͕KvȂĂ܂܂B


concatenated-stream-streams
[       type]: Function
[  arguments]: concatenated-stream-streams CONCATENATED-STREAM
[    package]: lisp
[    seealso]: make-concatenated-stream
[       file]: builtin.l
[    section]: o
[description]: 
make-concatenated-streamōꂽCONCATENATED-STREAM̓͌̃Xg[̃
XgԂ܂B

gpF
  ;;; hoge̓͌XgœB
  (with-open-stream (foo (make-string-input-stream "foo"))
    (with-open-stream (bar (make-string-input-stream "bar"))
      (with-open-stream (hoge (make-concatenated-stream foo bar))
        (concatenated-stream-streams hoge))))
  => (#<string-input stream 48042632>
      #<string-input stream 48042544>)


cond
[       type]: Macro
[  arguments]: cond &rest FORMS
[    package]: lisp
[    seealso]: if
[       file]: evalmacs.l
[    section]: \
[description]: 
C Ȃǂ if ... else if ... ̂悤Ȃ̂łB

\͈ȉ̂悤ɂȂĂ܂B

(cond (<eXg1> <>`<>)
      (<eXg2> <>`<>)
        ...
      (<eXgn> <>`<>))

eXg^ɂȂŏ̐߂̎]܂B
͎̎ƓłB

(if <eXg1>
     (progn <>`<>)
   (if <eXg2>
        (progn <>`<>)
      ...
      (if <eXgn>
           (progn <>`<>)
         nil)))

eXg t w肷ƃftHgŎs߂wł܂B

܂ʂȏꍇƂāAeXǧ̎Ȃꍇɂ̓eXǧʂ߂l
ƂȂ܂B


conjugate
[       type]: Function
[  arguments]: conjugate NUMBER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
𕡑fԂ܂B


connect
[       type]: Function
[  arguments]: connect HOSTNAME SERVICE &key :encoding
[    package]: editor
[    seealso]: open-network-stream , xyzzyŒ񋟂ĂXg[̎
[   referred]: with-open-stream
[       file]: builtin.l
[    section]: o
[description]: 
zXg̃|[gƂTCPڑJ܂B
ΐڑւ̃Xg[Ԃ܂B

QlF
  ;;; http://www.yahoo.co.jp/擾Ă݂B
  (with-open-stream (stream (connect "www.yahoo.co.jp" 80))
    (format stream "GET / HTTP/1.0\n\n")
    (while (setq in (read-line stream nil))
      (insert in "\n")))


cons
[       type]: Function
[  arguments]: cons X Y
[    package]: lisp
[       file]: builtin.l
[    section]: Xg
[description]: 
VXgԂ܂B

ɁAVXgۂɗp֐łB X  carA 
Y  cdr ƂāARXZVA̐VRXZւ
|C^Ԃ܂B (ʏ̓Xgł) Y ̂^Cvł
Ă͂ȂȂƂ͂܂B

gpF
  (cons 1 '(2))
  => (1 2)
  (cons 1 '())
  => (1)
  (cons 1 2)
  => (1 . 2)


consp
[       type]: Function
[  arguments]: consp OBJECT
[    package]: lisp
[    seealso]: atom
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTconsȂtAȊOȂnilԂ܂B

  (consp x) == (typep x 'cons) == (not (typep x 'atom))

ӁF (consp '())  '() == nilȂ̂nilB


constantp
[       type]: Function
[  arguments]: constantp OBJECT
[    package]: lisp
[    seealso]: defconstant
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
IuWFNgconstantǂԂ܂B

  t     IuWFNgconstant
  nil   IuWFNgconstantłȂ

gpF
  ;;; defvar/defconstanẗႢ
  (defvar foo 2)
  => foo
  (defconstant bar 3)
  => bar
  (constantp 'foo)
  => nil
  (constantp 'bar)
  => t


continue-popup
[       type]: Function
[  arguments]: continue-popup
[    package]: editor
[    seealso]: popup-string
[       file]: builtin.l
[    section]: ̑
[description]: 
popup-stringőO\eēx\܂B


convert-encoding-from-internal
[       type]: Function
[  arguments]: convert-encoding-from-internal ENCODING INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM
[    package]: editor
[    seealso]: convert-encoding-to-internal , detect-char-encoding
[       file]: builtin.l
[    section]: ̑
[description]: 
^ꂽXg[R[hENCODINGɕϊ܂B

@ENCODING               : o̓Xg[̃GR[fBO
                           encoding.lɑʂɒ`Ă*encoding-euc-jp*Ȃ
  INPUT-STRING-OR-STREAM : ϊ镶܂̓Xg[
  OUTPUT-STREAM          : o͂Xg[

߂l͈ȉ̒ʂłB

   OUTPUT-STREAMnil̎(w肵ȂƂnilƂ݂Ȃ܂)
  t      Xg[ɏo͂Ƃ


convert-encoding-to-internal
[       type]: Function
[  arguments]: convert-encoding-to-internal ENCODING INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM
[    package]: editor
[    seealso]: convert-encoding-from-internal , detect-char-encoding
[       file]: builtin.l
[    section]: ̑
[description]: 
^ꂽXg[ENCODINGR[hɕϊ܂B

@ENCODING               : ̓Xg[̃GR[fBO
                           encoding.lɑʂɒ`Ă
                           *encoding-euc-jp*Ȃǂdetect-char-encoding
                           ߂l𗘗p̂ǂł傤
  INPUT-STRING-OR-STREAM : ϊ镶܂̓Xg[
  OUTPUT-STREAM          : o͂Xg[

߂l͈ȉ̒ʂłB

   OUTPUT-STREAMnil̎(w肵ȂƂnilƂ݂Ȃ܂)
  t      Xg[ɏo͂Ƃ


copy-alist
[       type]: Function
[  arguments]: copy-alist LIST
[    package]: lisp
[       file]: builtin.l
[    section]: Xg
[description]: 
AzXg̃Rs[Ԃ܂BႦ΂ȘAzXgRs[ꍇɁA
IWiƓ̂wĂ镔ɉĂ܂Bcopy-listł
ŏʂ̗vf̂̂IWiƋLĂ̂ɑ΂Acopy-alist͑
Kw̗vfLĂ܂B

IWiF
  '(((1 2) . #\a) ((3 4) . #\b))

copy-list F
  '(((1 2) . #\a) ((3 4) . #\b))
    ~~~~~~~~~~~~~ ~~~~~~~~~~~~~
copy-alistF
  '(((1 2) . #\a) ((3 4) . #\b))
     ~~~~~   ~~~   ~~~~~   ~~~

GNU Emacs Lisp Reference ManualɂƁARs[̘AzXgƂ͓Ɨ
ĘAzXg̏Cs悤ɂ邽߂ƂB̗łĂƂA
copy-listł͌̃Xg܂ŕςĂ܂܂B

gpF
  ;;; copy-listcopy-alisẗႢĂ݂B
  (setq a '((1 . #\a) (2 . #\b)))       => ((1 . #\a) (2 . #\b))
  (setq b (copy-list a))                => ((1 . #\a) (2 . #\b))
  (setq c (copy-alist a))               => ((1 . #\a) (2 . #\b))
  (rplacd (assoc 2 a) #\c)              => (2 . #\c)
  a                                     => ((1 . #\a) (2 . #\c))
  b                                     => ((1 . #\a) (2 . #\c))
  c                                     => ((1 . #\a) (2 . #\b))


copy-file
[       type]: Function
[  arguments]: copy-file FILE NEW-FILE &key :if-exists :copy-attributes :if-access-denied
[    package]: lisp
[    seealso]: rename-file
[   referred]: delete-file
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@CRs[܂B

  FILE             : Rs[̃t@Cw肵܂B
  NEW-FILE         : Rs[̃t@Cw肵܂B
  :copy-attributes : Rs[Ƃ̑w肵܂B
                     wł鑮get-file-infoQƂĉB
  :if-exists       : t@C݂Ȃꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
        :overwrite      ㏑܂B
        :newer          VΏ㏑܂B
  :if-access-denied : ANZXۂꂽꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
        :force          IɃt@C̃Rs[݂܂B

gpF
  ;;; [Jautoexec.bat }V VENUS /work/autoexec.batɃRs[B
  (copy-file "c:/autoexec.bat" "//VENUS/work/autoexec.bat"
             :if-exists :overwrite)


copy-keymap
[       type]: Function
[  arguments]: copy-keymap MAP
[    package]: editor
[       file]: keymap.l
[    section]: L[}bv
[description]: 
L[}bṽRs[Ԃ܂B

gpF
  ;;; gresreg.l
  ;;; query-replacẽL[}bvRs[
  ;;; query-gresreg̃L[}bvāAƏCB
  (unless *query-gresreg-map*
    (setq *query-gresreg-map* (copy-keymap *query-replace-map*))
    (define-key *query-gresreg-map* #\C-g '(throw . quit)))


copy-list
[       type]: Function
[  arguments]: copy-list LIST
[    package]: lisp
[    seealso]: copy-tree , copy-seq
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg̃Rs[Ԃ܂B
Rs[ƃIWiequalłAeqł͂܂BRs[ƃIWi
\ĂAԏʂ̃Xg̗vf͓̂LĂ܂B
ςƑς܂BIWiƓ̂wĂ镔ɉ
Ă܂B

IWiF
  '(((1 2) . #\a) ((3 4) . #\b))

copy-list F
  '(((1 2) . #\a) ((3 4) . #\b))
    ~~~~~~~~~~~~~ ~~~~~~~~~~~~~
gpF
  ;;; [A] eqł͂ȂƂĂ݂܂B
  (setq a '((1 2 3) (4 5 6)))   => ((1 2 3) (4 5 6))
  (setq b (copy-list a))        => ((1 2 3) (4 5 6))
  (eq a b)                      => nil
  (equal a b)                   => t
  ;;; [B] carmeqłB
  (eq (car a) (car b))          => t
  ;;; [C] caarςƕς邯ǁAcarςĂςȂB
  (progn (setf (caar a) 7) a)   => ((7 2 3) (4 5 6))
  b                             => ((7 2 3) (4 5 6))
  (progn (setf (car a) 8) a)    => (8 (4 5 6))
  b                             => ((7 2 3) (4 5 6))


copy-menu-items
[       type]: Function
[  arguments]: copy-menu-items OLD-MENU NEW-MENU
[    package]: editor
[   referred]: define-menu
[       file]: builtin.l
[    section]: j[
[description]: 
old-menu̍\new-menuɃgbvxŃRs[܂B

T䂳kF
  Ȃ݂ɃoOĂ܂Bold-menunew-menuꍇ̂ƂlĂ܂B


copy-readtable
[       type]: Function
[  arguments]: copy-readtable &optional FROM-READTABLE TO-READTABLE
[    package]: lisp
[    seealso]: *readtable*
[       file]: builtin.l
[    section]: o
[description]: 
[he[uRs[܂B

  FROM-READTABLE : Rs[ (ftHg *readtable*)
                   nil 𖾎Iɗ^ƃftHg̃[he[uRs[B
  TO-READTABLE   : Rs[Bȗ͐V쐬B


copy-rectangle
[       type]: Function
[  arguments]: copy-rectangle P1 P2
[    package]: editor
[    seealso]: kill-rectangle , copy-rectangle-selection
[   referred]: *rectangle-kill-buffer* , copy-rectangle-to-register
[       file]: rectangl.l
[    section]: [W
[description]: 
P1P2Ŏw肳`̈Rs[܂BRs[`̈yankɂ́A
yank-rectangleg܂B


copy-rectangle-selection
[       type]: Function
[  arguments]: copy-rectangle-selection
[    package]: editor
[    seealso]: kill-rectangle-selection , copy-rectangle , operate-on-rectangle-selection
[   referred]: copy-rectangle-selection-to-clipboard
[       file]: select.l
[    section]: [W
[description]: 
}EXŋ`IꂽZNV̗̈Rs[܂Byankɂ
yank-rectangle-selectiong܂Ayank-rectanglełsłB
Rs[e*kill-ring*ƂNbv{[hƂႤ̈Ɋi[Ă
悤łB


copy-rectangle-selection-to-clipboard
[       type]: Function
[  arguments]: copy-rectangle-selection-to-clipboard
[    package]: editor
[    seealso]: kill-rectangle-selection-to-clipboard , copy-rectangle-selection , copy-to-clipboard
[       file]: select.l
[    section]: [W
[description]: 
}EXŋ`IꂽZNV̗̈Nbv{[hɃRs[܂B


copy-rectangle-to-register
[       type]: Function
[  arguments]: copy-rectangle-to-register R START END &optional DELETE
[    package]: editor
[    seealso]: copy-rectangle , kill-rectangle , insert-register
[       file]: register.l
[    section]: [W
[description]: 
START  END Ŏw肳`̈WX^ R փRs[܂B[C-x r r]
DELETE  non-nil ȂΓɗ̈폜܂B
Rs[`̈ yank ɂ́A insert-register g܂B 


copy-region-as-kill
[       type]: Function
[  arguments]: copy-region-as-kill FROM TO
[    package]: editor
[    seealso]: kill-region
[       file]: region.l
[    section]: [W
[description]: 
[WRs[āALOɒǉ܂B[ESC w]


copy-region-to-clipboard
[       type]: Function
[  arguments]: copy-region-to-clipboard FROM TO
[    package]: editor
[    seealso]: copy-to-clipboard
[       file]: region.l
[    section]: [W
[description]: 
w肳ꂽ[WNbv{[hɃRs[܂B

  FROM : [W̊Jnʒuw肵܂B
  TO   : [W̏Iʒuw肵܂B


copy-selection
[       type]: Function
[  arguments]: copy-selection
[    package]: editor
[    seealso]: yank-selection , kill-selection
[   referred]: *selection-ring*
[       file]: select.l
[    section]: [W
[description]: 
Iꂽ̈Rs[āA*selection-ring*̐擪ɒǉ܂B [F8]
ǉeyank-selectionœ\t܂B


copy-selection-to-clipboard
[       type]: Function
[  arguments]: copy-selection-to-clipboard
[    package]: editor
[    seealso]: copy-to-clipboard
[       file]: select.l
[    section]: [W
[description]: 
I͈͂Nbv{[hɓ]܂B[C-Insert]

gpF
  ;;; 1. JISɕϊĕۑ
  ;;; 2. [t@C]-[J]ŕGR[fBO[VtgJIS]ɂĊJ
  ;;;    i܂̓ȂǂŊJHj
  ;;; 3. IăRs[
  (defun tojiscopy ()
    (interactive)
    (let ((ocode *kanji-expected-code*)
          (tempfile (concat (default-directory) "tempfile.txt")))
      (save-excursion
        (set-buffer-kanji-fileio-code 1)
        (write-region (point-min) (point-max) tempfile nil)
        (switch-to-buffer "*JIS*"))
      (pop-to-buffer "*JIS*")
      (setq *kanji-expected-code* 0)
      (find-file tempfile)
      (setq *kanji-expected-code* ocode)
      (selection-whole-buffer)
      (copy-selection-to-clipboard)))


copy-seq
[       type]: Function
[  arguments]: copy-seq SEQUENCE
[    package]: lisp
[    seealso]: copy-list , copy-string , make-vector
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCẼRs[쐬ĕԂ܂BSEQUENCEƂequalpeqł͂܂B

  (copy-seq x) == (subseq x 0)


copy-string
[       type]: Function
[  arguments]: copy-string STRING
[    package]: lisp
[    seealso]: substring , copy-seq
[       file]: builtin.l
[    section]: 
[description]: 
STRING̃Rs[Ԃ܂B

gpF
  ;;; Psetqł͓IuWFNgɂȂĂB
  (setq foo "abc")              => "abc"
  (setq bar foo)                => "abc"
  (eq foo bar)                  => t

  ;;; Rs[ƕʂ̃IuWFNgɂȂB
  (setq bar (copy-string foo))  => "abc"
  (eq foo bar)                  => nil


copy-symbol
[       type]: Function
[  arguments]: copy-symbol SYMBOL &optional COPY-PROPS
[    package]: lisp
[    seealso]: uninterned
[       file]: builtin.l
[    section]: V{
[description]: 
OuninternedSYMBOL̃Rs[Ԃ܂B
COPY-PROPSnon-nilȂA`lAvpeBXgRs[܂B


copy-syntax-table
[       type]: Function
[  arguments]: copy-syntax-table FROM-SYNTAX-TABLE TO-SYNTAX-TABLE
[    package]: editor
[    seealso]: make-syntax-table
[       file]: builtin.l
[    section]: V^bNX
[description]: 
FROM-SYNTAX-TABLE  TO-SYNTAX-TABLE փRs[܂B


copy-to-clipboard
[       type]: Function
[  arguments]: copy-to-clipboard STRING
[    package]: editor
[    seealso]: get-clipboard-data , copy-region-to-clipboard , copy-selection-to-clipboard , copy-rectangle-selection-to-clipboard , kill-region-to-clipboard , kill-selection-to-clipboard , kill-rectangle-selection-to-clipboard , yank-to-clipboard , paste-from-clipboard , paste-rectangle-from-clipboard
[       file]: builtin.l
[    section]: VXe
[description]: 
w肳ꂽNbv{[hɃRs[܂B

  STRING : Nbv{[hɃRs[镶w肵܂B


copy-to-register
[       type]: Function
[  arguments]: copy-to-register R START END &optional DELETE
[    package]: editor
[    seealso]: insert-register , append-to-register
[       file]: register.l
[    section]: [W
[description]: 
START  END Ŏw肳郊[WWX^ R փRs[܂B[C-x r s]
DELETE  non-nil ȂΓɃ[W폜܂B

Rs[eLXg yank ɂ́A insert-register g܂B 


cos
[       type]: Function
[  arguments]: cos RADIANS
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
]֐̒lԂ܂B


cosh
[       type]: Function
[  arguments]: cosh Z
[    package]: lisp
[       file]: number.l
[    section]: l
[description]: 
oȐ]֐vZ܂B 


count
[       type]: Function
[  arguments]: count ITEM SEQUENCE &key :from-end :test :test-not :start :end :key
[    package]: lisp
[    seealso]: count-if , count-if-not , si:*tree-count
[       file]: sequence.l
[    section]: V[PX
[description]: 
ITEMƂ̃eXg𖞑SEQUENCE̗vfԂ܂Bʂ͔񕉂̐łB

  :from-end : ̊֐Ƃ̌݊̂߂ɗpӂꂽ̂ŁAʂɉe܂B
  :test     : eXgs2Zq
  :start    : eXgJnʒu
  :end      : eXg̏Iʒu


count-buffers
[       type]: Function
[  arguments]: count-buffers &optional ALL
[    package]: editor
[    seealso]: count-modified-buffers
[       file]: builtin.l
[    section]: obt@
[description]: 
Sobt@̐Ԃ܂B

  ALL : " *Completion*"" *Minibuf0*"̐擪󔒂̃obt@邩H
        t       擪󔒂̃obt@B
        nil     擪󔒂̃obt@͐ȂB

gpF
  ;;; obt@̐𐔂Ă݂B
  (count-buffers)
  => 20
  (count-buffers t)
  => 23


count-column
[       type]: Function
[  arguments]: count-column STRING &optional START BUFFER
[    package]: editor
[    seealso]: char-columns , current-column
[       file]: builtin.l
[    section]: |WV
[description]: 
 STRING o͂ꍇ̏o͌̌ʒuԂ܂B
START  BUFFER ̓^ǔ̕vZɉe^܂B

  STRING : Ώە
  START  : o͊JnƂ錅ʒu
        nil      ʒu 0 ̏o
        INTEGER  ʒu INTEGER ̏o (0 ̏ꍇ range-error)
  BUFFER : o̓obt@
        nil      ^uƂ (tab-column) ̒lp܂B
                 (tab-column (selected-buffer)) ̒lł͂܂B
        BUFFER   ^uƂ (tab-column BUFFER) ̒lp܂B

߂lF
  INTEGER    STRING o͌̌ʒu

⑫F
  s "\n" ͌ʒȕƂĂ͓A 2 ƂĈ܂B


count-if
[       type]: Function
[  arguments]: count-if TEST SEQUENCE &key :from-end :start :end :key
[    package]: lisp
[    seealso]: count , count-if-not
[       file]: sequence.l
[    section]: V[PX
[description]: 
TEST𖞑SEQUENCE̗vfԂ܂Bʂ͔񕉂̐łB

  :from-end : ̊֐Ƃ̌݊̂߂ɗpӂꂽ̂ŁAʂɉe܂B
  :test     : eXgs2Zq
  :start    : eXgJnʒu
  :end      : eXg̏Iʒu


count-if-not
[       type]: Function
[  arguments]: count-if-not TEST SEQUENCE &key :from-end :start :end :key
[    package]: lisp
[    seealso]: count , count-if
[       file]: sequence.l
[    section]: V[PX
[description]: 
TEST𖞑ȂSEQUENCE̗vfԂ܂Bʂ͔񕉂̐łB

  :from-end : ̊֐Ƃ̌݊̂߂ɗpӂꂽ̂ŁAʂɉe܂B
  :test     : eXgs2Zq
  :start    : eXgJnʒu
  :end      : eXg̏Iʒu


count-windows
[       type]: Function
[  arguments]: count-windows &optional MINIBUF
[    package]: editor
[   referred]: other-window
[       file]: window.l
[    section]: EBhE
[description]: 
EBhE̐Ԃ܂B

  MINIBUF : tO̓~jobt@EBhE𐔂邩ǂłB
        t       ~jobt@𐔂B
        nil     ~jobt@𐔂ȂB


count-xyzzy-instance
[       type]: Function
[  arguments]: count-xyzzy-instance
[    package]: editor
[       file]: builtin.l
[    section]: vZX
[description]: 
݋Nxyzzy̐Ԃ܂B


create-archive
[       type]: Function
[  arguments]: create-archive ARCHIVE-FILE FILES BASE-DIRECTORY
[    package]: editor
[    seealso]: extract-archive , delete-file-in-archive
[   referred]: list-archive
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
A[JCu쐬܂B

  ARCHIVE-FILE   : 쐬/ǉ鏑Ƀt@Cw肵܂Bw肵t@
                   C݂ΒǉAȂΐVK쐬܂BɃt
                   @C쐬fBNgw肷ꍇ́Atp
                   XŎw肵܂B
  FILES          : A[JCut@C̃Xgw肵܂BtpX
                   Ŏw肷Kv܂B
  BASE-DIRECTORY : ƂȂfBNgw肵܂B

gpF
  ;;; foo.lzh  c:/tmp/a.c, c:/tmp/b.c ǉ܂B
  (create-archive "foo.lzh"
                  '("c:/tmp/a.c" "c:/tmp/b.c")
                  "c:/tmp")


create-directory
[       type]: Function
[  arguments]: create-directory DIRNAME &key :if-exists
[    package]: lisp
[    seealso]: delete-directory
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
fBNg쐬܂B

  DIRNAME    : 쐬Ώۂ̃fBNg
  :if-exists : fBNg݂ĂƂ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂At Ԃ܂B

߂l͍쐬łǂɂ܂B

  t   fBNg̍쐬ɐ
  nil fBNg̍쐬Ɏs

gpF
  (create-directory "C:/xyzzy/testdir")
  => t


create-file-buffer
[       type]: Function
[  arguments]: create-file-buffer FILENAME
[    package]: editor
[    seealso]: get-file-buffer , create-new-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
t@CQƂobt@쐬ĕԂ܂B


create-menu
[       type]: Function
[  arguments]: create-menu &optional TAG
[    package]: editor
[    seealso]: create-popup-menu , define-menu , set-menu , use-local-menu
[   referred]: add-menu-item
[       file]: builtin.l
[    section]: j[
[description]: 
Vɍ쐬̃j[Ԃ܂B

  TAG : ʗp̃^Ow肵܂B

j[̒g͋Ȃ̂ŁAȉ̊֐œo^Kv܂B
g𓮓IɍKv΁A define-menu gpǂłB

  add-menu-item         : ڂǉ܂B
  add-menu-separator    : Zp[^ǉ܂B
  add-popup-menu        : |bvAbvj[ǉ܂B
  insert-menu-item      : ڂ}܂B
  insert-menu-separator : Zp[^}܂B
  insert-popup-menu     : |bvAbvj[}܂B

쐬j[͈ȉ̊֐Ŏg܂B

  set-menu       : W̃j[ƂĐݒ肵܂B
  use-local-menu : obt@Ƀ[Jȃj[ƂĐݒ肵܂B


create-new-buffer
[       type]: Function
[  arguments]: create-new-buffer NAME
[    package]: editor
[    seealso]: create-file-buffer , get-buffer-create , *create-buffer-hook* , find-buffer , obt@̓\
[   referred]: buffer-name , find-name-buffer , new-file
[       file]: builtin.l
[    section]: obt@
[description]: 
ONAMẼobt@쐬ĕԂ܂B̖Õobt@݂
΁Aname<1>, name<2>...ƔԍtOɂȂ܂B

gpF
  (create-new-buffer "test")
  => #<buffer: test>
  (create-new-buffer "test")
  => #<buffer: test<2>>


create-popup-menu
[       type]: Function
[  arguments]: create-popup-menu &optional TAG
[    package]: editor
[    seealso]: define-popup-menu , track-popup-menu , create-menu
[       file]: builtin.l
[    section]: j[
[description]: 
Vɍ쐬|bvAbvj[Ԃ܂B|bvAbvj[Ƃ
g邱Ƃ΁Acreate-menuō쐬ꂽj[𓯂łB

  TAG : ʗp̃^Ow肵܂B

j[̒g͋Ȃ̂ŁAcreate-menuƓ悤ɓo^Kv܂B
g𓮓IɍKv΁Adefine-popup-menugpǂłB

쐬|bvAbvj[͈ȉ̊֐Ŏg܂B

  insert-popup-menu  : ̃j[Ƀ|bvAbvj[ǉ܂B
  track-popup-menu   : |bvAbvj[̏ŕ\܂B


create-shortcut
[       type]: Function
[  arguments]: create-shortcut SRC DEST &rest REST
[    package]: editor
[    seealso]: resolve-shortcut
[   referred]: create-shortcut-to-desktop
[       file]: files.l
[    section]: t@CVXe
[description]: 
V[gJbg쐬܂B

  SRC  : V[gJbgwpXw肵܂B
  DEST : V[gJbg쐬pXw肵܂B
  REST : 쐬V[gJbgւ̃p[^^邱Ƃo܂B
     :description        hbOI[o̎vpeB\Ɍ
     :arguments          R}hC
     :working-directory  ƃfBNg
     :show               EBhȄԂ̎w
                            :show      W̃TCYŋN
                            :maximize  ő剻ԂŋN
                            :minimize  ŏԂŋN

gpF
  ;;; X^[gj[ɃV[gJbg쐬B
  (create-shortcut (merge-pathnames "xyzzy.exe" (si:system-root)) (get-special-folder-location :start-menu))
  => t
  (delete-file (merge-pathnames "xyzzy.exe.lnk" (get-special-folder-location :start-menu)))
  => t

  ;;; 郁j[xyzzyo^B
  (create-shortcut (merge-pathnames "xyzzy.exe" (si:system-root)) (get-special-folder-location :send-to))
  => t
  (delete-file (merge-pathnames "xyzzy.exe.lnk" (get-special-folder-location :send-to)))
  => t


create-shortcut-to-desktop
[       type]: Function
[  arguments]: create-shortcut-to-desktop PATH &rest REST
[    package]: editor
[    seealso]: create-shortcut
[       file]: files.l
[    section]: t@CVXe
[description]: 
fXNgbv PATH ւ̃V[gJbg܂B


create-tab-bar
[       type]: Function
[  arguments]: create-tab-bar BAR CALLBACK
[    package]: editor
[    seealso]: tab-bar-add-item , tab-bar-list-items , tab-bar-modify-item , tab-bar-select-item
[   referred]: create-tool-bar , tab-bar-delete-item , tab-bar-find-item
[       file]: builtin.l
[    section]: j[
[description]: 
^uo[̎ʎqBARƁA^uIꂽƂsR[obN֐
CALLBACKw肵āA^uo[쐬܂BCALLBACḰAe^u̍쐬ɐ
肵V{n܂B

gpF
  (progn
    (defun a-func (a) (msgbox "~A ~A" a (type-of a)))
    (define-command-bar 'a-bar "a bar")
    (create-tab-bar 'a-bar 'a-func)
    (show-command-bar 'a-bar)
    (tab-bar-add-item 'a-bar '1st "- 1st -" "1st item")
    (tab-bar-add-item 'a-bar '2nd "- 2nd -" "2nd item"))
  => t  
  (progn
    (tab-bar-delete-item 'a-bar '1st)
    (tab-bar-delete-item 'a-bar '2nd)
    (delete-tool-bar 'a-bar)
    (delete-command-bar 'a-bar))
  => t


create-tool-bar
[       type]: Function
[  arguments]: create-tool-bar NAME BITMAP ITEMS
[    package]: editor
[    seealso]: define-command-bar , create-tab-bar
[   referred]: delete-tool-bar
[       link]: lisp/cmdbar.l
[       file]: builtin.l
[    section]: j[
[description]: 
c[o[NAME쐬܂Bc[o[ɕ\rbg}bvt@C̃t
pXBITMAPƁAc[o[̍ITEMSw肵܂BITEMS͈ȉ̌`ŋL
q܂Bڂ̑ւ:sepw肷ƃZp[^\ł܂B

`F
  ((c[`bv1 ACR̔ԍ1 s֐1 Ԑp1)
   (c[`bv2 ACR̔ԍ2 s֐2 Ԑp2)
    ...
   (c[`bvN ACR̔ԍN s֐N ԐpN))

⑫F
  ACR̔ԍF
        16x16̗̈ЂƂ̃ACRƂ݂ȂāArbg}bvt@C
        0x[X̔ԍŎw肵܂B
  ԐpF
        {^̏ԂɈˑĕύX邩w肵܂B
        :modified              ҏWĂ 
        :selection             s[hIA[hIĂ
        :modify-selection      ҏW\ȃobt@ōs[hI
                               [hIĂ
        :rectangle             `IĂ
        :modify-rectangle      ҏW\ȃobt@ŋ`IĂ
        :any-selection         IĂ
        :modify-any-selection  ҏW\ȃobt@őIĂ
        :clipboard             ҏW\ȃobt@ŃNbv{[hɒlĂ
        :undo                  UNDOłԂȂ
        :redo                  hDłԂȂ
        ֐ (function)        ֐Ԃlɂ
            :disable           {^Ȃ 
            :check             {^Ăւ񂾏 
            LȊO           ʂ̉ 
        LȊO               w肵ȂƂ̓Ŗɉ 
        OHKUBO HiroshĩTCg
          http://ohkubo.s53.xrea.com/xyzzy/memo.html

gpF
(create-tool-bar 'abc-tool-bar
 (merge-pathnames "toolbar.bmp" (etc-path))
 '(("line-number" 0 toggle-line-number)
   ("vscroll-bar" 1 toggle-vscroll-bar)
   ("mode-line" 2 toggle-mode-line)
   :sep
   ("function-bar" 3 toggle-function-bar)
   ("fold-line" 4 toggle-fold-line)
   ("read-only" 5 toggle-read-only)))


ctl-x-4-map
[       type]: Variable
[    package]: editor
[    seealso]: ctl-x-4-prefix
[       file]: keymap.l
[    section]: L[}bv
[description]: 
C-x 4 ɑL[V[PX̃oCfBOi[L[}bvłB


ctl-x-4-prefix
[       type]: Function
[  arguments]: ctl-x-4-prefix
[    package]: editor
[    seealso]: ctl-x-4-map
[       file]: keymap.l
[    section]: L[}bv
[description]: 
C-x 4 vtBbNXłB [C-x 4]
ftHgł
  C-x 4 b      switch-to-buffer-other-window
  C-x 4 f      find-file-other-window
̓ݒ肳Ă܂B

ctl-x-4-prefix ̊֐Z͕ʂ̃R}hł͂Ȃ ctl-x-4-map ƂL
[}bvێĂ܂B


ctl-x-6-map
[       type]: Variable
[    package]: editor
[    seealso]: ctl-x-6-prefix
[       file]: pframe.l
[    section]: L[}bv
[description]: 
C-x 6 ɑL[V[PX̃oCfBOi[L[}bvłB


ctl-x-6-prefix
[       type]: Function
[  arguments]: ctl-x-6-prefix
[    package]: editor
[    seealso]: ctl-x-6-map
[       file]: pframe.l
[    section]: L[}bv
[description]: 
C-x 6 vtBbNXłB [C-x 6]
ftHgł̓t[֌W̃R}ho^Ă܂B

ctl-x-6-prefix ̊֐Z͕ʂ̃R}hł͂Ȃ ctl-x-6-map ƂL
[}bvێĂ܂B


ctl-x-map
[       type]: Variable
[    package]: editor
[    seealso]: ctl-x-prefix
[       file]: keymap.l
[    section]: L[}bv
[description]: 
C-x ɑL[V[PX̃oCfBOi[L[}bvłB


ctl-x-prefix
[       type]: Function
[  arguments]: ctl-x-prefix
[    package]: editor
[    seealso]: ctl-x-map
[       file]: keymap.l
[    section]: L[}bv
[description]: 
C-x vtBbNXłB [C-x]

ctl-x-prefix ̊֐Z͕ʂ̃R}hł͂Ȃ ctl-x-map ƂL[}
bvێĂ܂B

Ql:
  ;;; keymap.l
  (defvar ctl-x-map (make-keymap))
  (setf (symbol-function 'ctl-x-prefix) ctl-x-map)


current-column
[       type]: Function
[  arguments]: current-column
[    package]: editor
[    seealso]: current-virtual-column , goto-column
[   referred]: count-column , current-line-columns , what-cursor-position
[       file]: builtin.l
[    section]: |WV
[description]: 
݂̌ʒuԂ܂B


current-line-columns
[       type]: Function
[  arguments]: current-line-columns
[    package]: editor
[    seealso]: current-column , char-columns , goto-column
[       file]: builtin.l
[    section]: |WV
[description]: 
݂̕\šԂ܂B
s (#\LFD)  2 ƈ܂B


current-line-number
[       type]: Function
[  arguments]: current-line-number
[    package]: editor
[    seealso]: current-virtual-line-number
[   referred]: get-window-start-line
[       file]: builtin.l
[    section]: |WV
[description]: 
݂̕s̍sԍԂ܂B


current-menu
[       type]: Function
[  arguments]: current-menu &optional BUFFER
[    package]: editor
[   referred]: get-menu , use-local-menu
[       file]: builtin.l
[    section]: j[
[description]: 
ݕ\Ă郁j[Ԃ܂Buse-local-menugpĂ
obt@*app-menu*Ƃ͈Ⴄ̂擾܂B


current-virtual-column
[       type]: Function
[  arguments]: current-virtual-column
[    package]: editor
[    seealso]: current-column , goto-virtual-column
[   referred]: goto-column
[       file]: builtin.l
[    section]: |WV
[description]: 
J[\ʒu̕\Ԃ܂B
ۂ̕\\s^sɂ͈ˑ܂B
(current-virtual-column)


current-virtual-line-number
[       type]: Function
[  arguments]: current-virtual-line-number
[    package]: editor
[    seealso]: current-line-number , goto-virtual-line
[   referred]: get-window-start-line
[       file]: builtin.l
[    section]: |WV
[description]: 
݂̃|Cg\sŉsڂԂ܂B


current-window-configuration
[       type]: Function
[  arguments]: current-window-configuration
[    package]: editor
[    seealso]: set-window-configuration
[   referred]: save-window-configuration-to-register
[       file]: builtin.l
[    section]: EBhE
[description]: 
݂̃EBhȄԂԂ܂B
łEBhȄԂƂ́Aʂ̕ԁA\Ăobt@
w܂BEBhȄԂset-window-configurationŐݒ肷邱Ƃo
܂B

gpF
  ;;; ʂ̏Ԃɖ߂B
  (split-window)
  => t
  (setq winconf (current-window-configuration))
  => (window-configuration #<window> ......  
  (delete-other-windows)
  => t
  (set-window-configuration winconf)


cwd
[       type]: Function
[  arguments]: cwd
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
xyzzy.exe̍ƃfBNgԂ܂BvpeB̍ƃtH_(S)
fBNgԂ̂Ǝv܂B

gpF 
  (cwd)
  =>"D:/WINNT/"


dabbrev-expand
[       type]: Function
[  arguments]: dabbrev-expand &optional ARG
[    package]: editor
[    seealso]: dabbrev-popup
[   referred]: *dabbrev-search-this-buffer-only* , *dabbrevs-no-undo*
[       file]: dabbrev.l
[    section]: eLXg
[description]: 
I̓WJɂԂɕ\܂B[C-x /]


dabbrev-popup
[       type]: Function
[  arguments]: dabbrev-popup
[    package]: editor
[    seealso]: dabbrev-expand , popup-list
[       file]: dabbrev.l
[    section]: eLXg
[description]: 
dabbrev-expand̃|bvAbvXgłłB[C-x \]


dde-execute
[       type]: Function
[  arguments]: dde-execute CHAN DATA
[    package]: editor
[    seealso]: dde-poke , dde-request , dde-terminate
[   referred]: dde-initiate
[       file]: builtin.l
[    section]: VXe
[description]: 
DDE EXECUTE s܂B CHAN  DDE `lADATA ͑ɂ
킷R}hłBR}h̓éÃ}jAɏ]Ă
Bdde-execute  t Ԃ܂B

  CHAN : `lw肵܂B
  DATA : f[^w肵܂B

ȂADDE ֐ł͈ȉ̗O\܂BKvłΗO
ĂB

  dde-timeout        ^CAEg܂B
  dde-busy           DDE T[o BUSY łB
  dde-low-memory     T[osԂł
  dde-no-conv        DDE Θbmł܂
  dde-not-processed  gUNV̎sɎs܂
  dde-server-died    T[o[I܂
  storage-error      ܂
  dde-error          悭킩ȂǁAƂɂG[ł


dde-initiate
[       type]: Function
[  arguments]: dde-initiate SERVICE TOPIC
[    package]: editor
[    seealso]: dde-execute , dde-poke , dde-terminate
[       file]: builtin.l
[    section]: VXe
[description]: 
DDE Θbm܂B SERVICE ̓T[rXA TOPIC ̓gsbNŁA
ꂼꕶ^łBȂɂw肷邩͒ʐM鑊̃}jA
QƂĂBɏIꍇADDE `lԂ܂B
ȍ~̒ʐMł͂DDE `lgpĂB


dde-poke
[       type]: Function
[  arguments]: dde-poke CHAN ITEM DATA
[    package]: editor
[    seealso]: dde-execute , dde-request , dde-terminate
[   referred]: dde-initiate
[       file]: builtin.l
[    section]: VXe
[description]: 
DDE POKE s܂B

  CHAN : `lw肵܂B
  ITEM : iڍוsj
  DATA : f[^𕶎Ŏw肵܂B

 CHAN  DDE `lADATA ͑ɂ킷łB̓
éÃ}jAɏ]ĂBdde-poke  t Ԃ܂B


dde-request
[       type]: Function
[  arguments]: dde-request CHAN DATA RESULT-TYPE
[    package]: editor
[    seealso]: dde-execute , dde-poke , dde-terminate
[       file]: builtin.l
[    section]: VXe
[description]: 
DDE REQUEST s܂B

  CHAN        : `lw肵܂B
  DATA        : f[^w肵܂B
  RESULT-TYPE : ߂ľ^w肵܂B

 CHAN  DDE `lADATA ͑ɂ킷łB̓
éÃ}jAɏ]ĂB߂l DDE ̑肪Ԃ
Ԃ܂ARESULT-TYPE ̎wɂăf[^̉߂ȉ̂悤ɂ
܂B

  :text   : ʏ̕Ԃ܂B
  :binary : Ȃǂ𖳎ĕԂĂf[^̂܂ܕŕԂ܂B
  :int8
  :int16
  :int32  : f[^ꂼ 8, 16, 32 rbg̔zƂ݂ȂĐ̃
            XgŕԂ܂Bz̗vf 1 ̂Ƃ͐lԂ܂B

߂l^̎ẃA DDE ŗVڂƎvčȂ̂ŁAʏ
w肵Ȃč\܂B


dde-terminate
[       type]: Function
[  arguments]: dde-terminate CHAN
[    package]: editor
[   referred]: dde-execute , dde-initiate , dde-poke , dde-request
[       file]: builtin.l
[    section]: VXe
[description]: 
DDE ΘbI܂B CHAN  DDE `lłBɏI
 tAłɑΘbIĂꍇ nil Ԃ܂B

  CHAN : `lw肵܂B


decf
[       type]: Macro
[  arguments]: decf PLACE &optional (DELTA 1)
[    package]: lisp
[    seealso]: incf
[       file]: setf.l
[    section]: l
[description]: 
ϐfNg

gpF
  ;;; ϐx̒lfNgB
  (setq x 1)    => 1
  (decf x)      => 0
  x             => 0


declaim
[       type]: Macro
[  arguments]: declaim &rest DECL-SPECS
[    package]: lisp
[    seealso]: declare , proclaim
[       file]: typespec.l
[    section]: ϐƒ萔
[description]: 
ϐXyVϐɂ܂Bproclaim ̃}NłłB


declare
[       type]: Misc
[    package]: lisp
[    seealso]: special
[   referred]: declaim , proclaim
[    section]: ϐƒ萔
[description]: 
Common Lisp̋@\ŁAuϐ𓮓I bind vƐ錾鎖łB
Emacs Lispł͂Iɂ bind łȂ̂ő݂܂B

  (declare (special ϐ))

Ⴂ}܂B

  ;;; ϐ x          ϐ    Common Lisp/xyzzy lispF
  (setq x 0)              x 0             ϐxQƂB
                            (+ 0 12)ƂȂ
  ;;; ֐ bar                                  
  (defun bar (x)          (bar 34)      Emacs LispF
    (foo 12))             x 34        ĂяoX^bN
                              [ƂxQƂB
  ;;; ֐ foo                                (+ 34 12)ƂȂB
  (defun foo (y)          (foo 12)    
     (+ x y))    ...    y 12          
                              
                          (+ x y)   

ƂƂ(bar 34)ƌĂяoƁAÂLispł(Emacs Lisp܂ށj
̎_ x = 34, y = 12ƌ܂BƂ낪ACommon Lispxyzzy lispł
̎_ x = 0,  y = 12ƌ܂B

Lisp̓C^[v^̂ŁAIoCfBOł悩񂾂ǁA
RpC鎞ɁAȂɂƖ肪Common Lisp
ł́AÓIoCfBOɕύXɂȂ܂B

łAƁAÂR[hڐÂςɂȂ̂ŁA

                          ϐ    
                          x 0               
                          
  ;;; ֐ bar                                    
  (defun bar (x)          (bar 34)    Common Lisp/xyzzy lispF
    (declare (special x)) x 34        ϐł͂Ȃ
    (foo 12))               X^bNxQƂB
                                            (+ 34 12)ƂȂB
                          (foo 12)  
                          y 12        
                            
                          (+ x y)   

ƏĂƌÂLisp(Emacs Lisp)̂悤ɓƂB


decode-escape-sequence
[       type]: Function
[  arguments]: decode-escape-sequence STRING REGEXPP
[    package]: editor
[       link]: [xyzzy:04201]
[       file]: builtin.l
[    section]: 
[description]: 
GXP[vV[PXfR[h܂B

  STRING FfR[hGXP[vV[PX
  REGEXPPFSTRING K\ۂw肵܂B

gpłGXP[vV[PX͈ȉ̒ʂłB
  \t     ^u
  \n     s
  \r     A
  \f     
  \v     ^u
  \xNN   2܂ł16i
  \XNNNN 4܂ł16i

gpF
  ;;; [\thoge]Ƃ6fR[h5ɂB
  "\\thoge"
  => "\\thoge"
  (decode-escape-sequence "\\thoge" nil)
  => "  hoge"
  (length "\\thoge")
  => 6
  (length (decode-escape-sequence "\\thoge" nil))
  => 5


decode-mime-header
[       type]: Function
[  arguments]: decode-mime-header
[    package]: editor
[       file]: encdec.l
[    section]: ̑
[description]: 
ݍs牺RFC822wb_TMIMEfR[h܂B


decode-universal-time
[       type]: Function
[  arguments]: decode-universal-time UNIVERSAL-TIME &optional TIME-ZONE
[    package]: lisp
[    seealso]: format-date-string , encode-universal-time
[   referred]: file-write-time , format-date , get-decoded-time , get-universal-time , set-file-write-time
[       file]: builtin.l
[    section]: tE
[description]: 
jo[T^C`̎Ԃɕϊ܂B

  UNIVERSAL-TIME : jo[T^C`̎Ԃw肵܂B
  TIME-ZONE      : ^C][w肵܂B

ϊꂽ͑lŕԂ܂Bmultiple-value-***ñ}NŎ󂯎
܂傤B烆jo[T^C`̎Ԃɕϊɂ́A
encode-universal-timegp܂B

gpF
  ;;; .xyzzy̍ŏIXV(2003/3/30 9:34:25)擾B
  (multiple-value-list
   (decode-universal-time
    (file-write-time ".xyzzy")))
  => (25 34 9 30 3 2003 6 nil -9)

QƁF
  timestmp.l


default-directory
[       type]: Function
[  arguments]: default-directory &optional BUFFER
[    package]: editor
[    seealso]: set-default-directory
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
obt@ƂĂfBNgԂ܂B

  BUFFER : obt@w肵܂B
           w肪Ȃ΃Jgobt@ɂȂ܂B

̃obt@find-file Ƃɍŏɕ\fBNĝƂłB
̃fBNg M-x: cd  set-default-directoryŕύX邱Ƃł
܂B

gpF
  ;;; ftHgfBNgړĂ݂B
  (default-directory)
  => "C:/applications/xyzzy/site-lisp/"
  (cd "../..")
  => t
  (default-directory)
  => "C:/applications/"


default-value
[       type]: Function
[  arguments]: default-value SYMBOL
[    package]: lisp
[    seealso]: symbol-value , setq-default
[       file]: builtin.l
[    section]: V{
[description]: 
V{̃ftHg̒lԂ܂B
V{obt@[JłȂȂ΁Asymbol-valueƓlԂ܂B
V{obt@[J̎ɃftHg̒lȂꍇɂ́AG[
ɂȂ܂BftHg̒lsetq-defaultŎw肵܂B

gpF
  ;;; V{ftHg̒lȂꍇ
  (make-local-variable 'foo)    => t
  (setq foo 123)                => 123
  (default-value 'foo)          => ϐ`Ă܂: foo

  ;;; obt@[JȃV{̏ꍇ
  (defvar-local bar 234)        => bar
  (setq bar 345)                => 345
  (default-value 'bar)          => 234


defconstant
[       type]: Macro
[  arguments]: defconstant NAME VALUE &optional DOC
[    package]: lisp
[    seealso]: constantp , defvar
[       file]: evalmacs.l
[    section]: ϐƒ萔
[description]: 
萔錾܂B

gpF
  ;;; encoding.l̒
  (defconstant *eol-crlf* 1)
  => *eol-crlf*


define-abbrev-table
[       type]: Function
[  arguments]: define-abbrev-table TABNAME &optional DEFS
[    package]: editor
[    seealso]: *abbrev-table-name-list* , *local-abbrev-table* , *global-abbrev-table*
[       file]: abbrev.l
[    section]: eLXg
[description]: 
abbrev-table`܂B

  TABNAME : abbrev-table̖OɂV{
  DEFS    : ÓI̓WJ̒`̃Xg

܂ATABNAME*abbrev-table-name-list*ɓo^AҏWt@Co͂
삪\ɂȂ܂B

gp:
  ;;; c-mode.l̒`
 (defvar *c-mode-abbrev-table* nil)
 (unless *c-mode-abbrev-table*
   (define-abbrev-table '*c-mode-abbrev-table*))


define-command-bar
[       type]: Function
[  arguments]: define-command-bar SYM NAME &optional EDGE X Y W
[    package]: editor
[    seealso]: delete-command-bar
[   referred]: create-tool-bar
[       file]: cmdbar.l
[    section]: j[
[description]: 
ȉ͎łB

c[o[^uo[𑍏̂ăc[o[ƌĂԂ悤łB쐬Ƃc
[o[̃Xg𑀍삷Ƃ͑Stool-barn̊֐g܂BPɕ\
邾Ȃ΁Ashow-tool-bargΉ\łB

Aj[[\]-[c[o[]̈ꗗɒǉꍇɂ́A
command-barn̊֐g܂Bdefine-command-barœo^c[o[́A
[\]-[c[o[]\𐧌䂷邱Ƃ\łB\߁A
define-command-barŒ`SYMɑΉAc[o[E^uo[
Kv܂B

ȉ̓^uo[𑀍삷ꍇ̗łB

  (progn
    (defun a-func (a) (msgbox "~A ~A" a (type-of a)))
    (define-command-bar 'a-bar "a bar")
    (create-tab-bar 'a-bar 'a-func)
    (show-command-bar 'a-bar)
    (tab-bar-add-item 'a-bar '1st "- 1st -" "1st item")
    (tab-bar-add-item 'a-bar '2nd "- 2nd -" "2nd item"))

  (progn
    (tab-bar-delete-item 'a-bar '1st)
    (tab-bar-delete-item 'a-bar '2nd)
    (delete-tool-bar 'a-bar)
    (delete-command-bar 'a-bar))

܂A[Ũc[o[Ȃǂ쐬ꍇɂ́Adelete-command-barō폜
菇l邱Ƃ߂܂BR}ho[́iV{j
qXgϐɊi[܂B̎́ic[o[^uo[jȂƂA
[\]-[c[o[]ɎcĂ܂܂B̂悤ȂƂ́A蓮ō
Kv܂B

悤ȘbŁAR}ho[ɂ͊֐w肵ĂāAォ{̂
ǂݍ݂ꍇɂ́Aautoloadŏo܂B{̂̏ɎԂ|ꍇ
ɂ́Â悤ɕقǂƎv܂B

gpF
  ------------------------------------------------
  ;;; .xyzzy
  (progn
    (define-command-bar 'a-bar "a bar")
    (autoload 'a-bar "a-bar.l"))
  ------------------------------------------------

  ------------------------------------------------
  ;;; a-bar.l
  (progn
    (create-tab-bar 'a-bar 'a-func)
    (show-command-bar 'a-bar)
    (tab-bar-add-item 'a-bar '1st "- 1st -" "1st item")
    (tab-bar-add-item 'a-bar '2nd "- 2nd -" "2nd item"))
  ------------------------------------------------


define-condition
[       type]: Macro
[  arguments]: define-condition NAME (PARENT-TYPE) &rest BODY
[    package]: lisp
[    seealso]: handler-case , error , G[֌W , make-condition
[       file]: condition.l
[    section]: G[
[description]: 
VRfBV`܂B
V`RfBV error œ
handler-case ŏł܂B

RfBV͍\̂łĂ܂B
eƂȂRfBVɃXbg`ĂꍇA
VRfBVɂ̃Xbgp܂B

  NAME        : RfBV̖O
  PARENT-TYPE : eƂȂRfBV
  BODY
    vf  RfBVɒǉXbg̖ÕXg
    ȍ~  ȉ̂ǂꂩ car ƂĎXg
      :documentation  RfBV̐ݒ肵܂B
      :report         G[񍐗p̊֐w肵܂B
      :important      important ȍ\̂ɂȂHiڍוsj

gp:
  ;; lisp/condition.l 
  (define-condition check-type-error (type-error)
    (string place)
    (:report (lambda (c s)
               (format s "`~A'̒l`~S'~:[~S~;~:*~A~]ł͂܂"
                       (check-type-error-place c)
                       (check-type-error-datum c)
                       (check-type-error-string c)
                       (check-type-error-expected-type c)))))

  ;; Œ`Ă݂
  (define-condition my-error (error)
    (string) ; VXbg :string ǉ
    (:documentation "Œ`RfBV")
    (:report (lambda (c s) ; c ̓RfBVAs ͏o̓Xg[
               (format s "G[ł: ~A"
                       (my-error-string c))))
    (:important t))
  => t
  (error 'my-error :string "test")
  => G[ł: test
  (documentation 'my-error 'type)
  => "Œ`RfBV"


define-history-variable
[       type]: Macro
[  arguments]: define-history-variable NAME &optional (INITIAL-VALUE nil sv) DOC
[    package]: editor
[    seealso]: register-history-variable , unregister-history-variable
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
qXgϐ`܂B

  NAME          : qXgϐw肵܂B
  INITIAL-VALUE : lݒ肵܂B
  DOC           : ϐ̐w肵܂B

qXgϐƂ́Axyzzy̗グ܂ŒlێĂ(lisp
lɂ)֗ȕϐłBqXgϐȂƊe}NƂɓƎ̕ۑ@
ƂȂƂ܂񂪁AqXgϐ̂Ő錾邾ŕϐ̏
ۑ邱Ƃ\ȗD̂łB

AU쐬qXgϐ͂܂łcĂ܂̂ŁA
svɂȂed::*history-variable-list*mFŁA
unregister-history-variableō폜ĉB

gpF
  ;;; grepd.l
  (define-history-variable *grep-directory-history* nil)
  (define-history-variable *grep-file-history* nil)


define-key
[       type]: Function
[  arguments]: define-key KEYMAP KEY COMMAND
[    package]: editor
[    seealso]: undefine-key , global-set-key , local-set-key , substitute-key-definition , make-keymap , L[\gp\ , e팾L[}bv
[   referred]: use-keymap
[       file]: builtin.l
[    section]: L[}bv
[description]: 
L[}bṽL[ɃR}h蓖Ă܂B

  KEYMAP  : L[}bv
  KEY     : o^L[
  COMMAND : sR}h

gpF
  ;;; Ctrl-X f̃L[蓖Ăς
  (define-key ctl-x-map #\f 'my-find-file)
  => t 
  ;;; Esc-f ̃L[蓖Ăς
  (define-key esc-map #\f 'my-find-file)
  => t
  ;;; Ctrl-C ãL[蓖Ăς
  (define-key spec-map #\a 'my-find-file)
  => t


define-menu
[       type]: Macro
[  arguments]: define-menu &body BODY
[    package]: editor
[    seealso]: create-menu , add-menu-item , insert-menu-item , add-menu-separator , insert-menu-separator , copy-menu-items , delete-menu , get-menu , set-menu , use-local-menu , define-popup-menu
[   referred]: get-menu-position
[       file]: menu.l
[    section]: j[
[description]: 
ŒIȃj[`܂B
`@ define-popup-menu QƂĉBIɃj[𐶐
ɂ create-menu QƂĉB define-menu Őj[
add-menu-item  insert-menu-item Ȃǂōڂǉ邱Ƃ\łB


define-popup-menu
[       type]: Macro
[  arguments]: define-popup-menu &body BODY
[    package]: editor
[    seealso]: create-popup-menu , track-popup-menu , add-popup-menu , insert-popup-menu , define-menu
[   referred]: add-menu-separator , insert-menu-separator
[       file]: menu.l
[    section]: j[
[description]: 
ŒIȃ|bvAbvj[`܂B

  BODY : j[̒`Lq܂B

BODYC`LBNFŏƈȉ̗lɂȂ܂B

  POPUP-DEF : {MENU-ITEM}*

  MENU-ITEM : :sep
            : (:sep [TAG])
            | (:separator [TAG])
            | (:popup tag name {POPUP-DEF}*)
            | (:item tag name [COMMAND [INIT]])

  TAG       : j[ڂʂCӂ̃IuWFNgłB
              ^OmeqŔr܂

  COMMAND   : j[ڂIꂽƂɎsR}hłB

  INIT      : j[JOɕ]AԂlɂăj[
              Ԃݒ肳܂BCӂSwł܂A܂薳
              ȂƂ͂ȂłB̒lƂĈӖ̂lɂ͈ȉ
              ̂̂܂B

        :modified     Jgobt@ύXĂȂΊDF\
        :undo         undos\łΊDF\
        :redo         redos\łΊDF\
        :selection    Jgobt@̃eLXgIł邩`I
                      łΊDF\
        :rectangle    Jgobt@̃eLXgIł邩`ȊO
                      ̑IłΊDF\
        :clipboard    Nbv{[hłΊDF\
        :check        `FbN
        :disable      DF\
        ̑        gp\

gpF
  ;;; niftylog.l
  (define-popup-menu
    (:item nil "bZ[Wǂ񂾂Ƃɂ(&R)"
     'log-read-article)
    (:item nil "bZ[WǂłȂƂɂ(&N)"
     'log-unread-article)
    (:item nil "Xbhǂ񂾂Ƃɂ(&T)"
     'log-read-thread)
    (:item nil "XbhǂłȂƂɂ(&H)"
     'log-unread-thread)
    (:item nil "j[XO[vǂ񂾂Ƃɂ(&G)")
    (:item nil "j[XO[vǂłȂƂɂ(&P)"))
  => #<menu 48698340>


defmacro
[       type]: Macro
[  arguments]: defmacro NAME (&rest LAMBDA-LIST) &body BODY
[    package]: lisp
[    seealso]: macroexpand , ``'(backquote)
[   referred]: macrolet
[       file]: evalmacs.l
[    section]: }N
[description]: 
}N`܂B

gpF
  ;;; cadr}NŒ`ꍇ
  (defmacro cadr (x)
    (list 'car (list 'cdr x)))
  => cadr
  (macroexpand '(cadr y))
  => (car (cdr y))

QlF
  --- T䂳̐ [xyzzy:03975] ---
  
  }N 2 ]֐݂Ȃ̂ƎvĂ
  ԈႢȂł傤( 1 ڂ̕]̂Ƃɂ͈
  ]͂Ȃ)BȒPȗƁA
  
    (defmacro foo ()
      '(+ 1 2))
  
  ̂悤ɒ` (foo) ]ƁA1 ڂ̕]
  (+ 1 2) ԂAɕ] 3 ԂAƂȂ
  ܂BꍇlɁA
  
    (defmacro bar (n)
      (list '+ 1 n))
  
    (bar 3)
    -> (+ 1 3)
    => 4
  
  ƂȂ܂B
  
  | (M (any1) (any2) (any3)) ƌĂяoƁA
  |     (progn
  |       (m-setup)
  |       (any1)
  |       (any2)
  |       (any3)
  |       (m-cleanup))
  | ƌĂ΂̂Ɠ悤삷̂͂ǂǂłH
  
  ̏ꍇA 3 Ȃ̂ŁAȂ܂B
  
    (defmacro M (a b c)
      (list 'progn '(m-setup) a b c '(m-cleanup)))
  
    (M (any1) (any2) (any3))
    -> (progn (m-setup) (any1) (any2) (any3) (m-cleanup))
    => ?
  
  ӂ`A͉ł肾낤ĂȂƂ́Aʏ̊
  Ɠl &rest Ŏ󂯂Ă΂킯łˁB
  
    (defmacro M2 (&rest args)
      (append '(progn) '((m-setup)) args '((m-cleanup))))
  
    (M2 (any1) (any2) (any3))
    -> (progn (m-setup) (any1) (any2) (any3) (m-cleanup))
    => ?
  
  Ȃ݂ɁA1 ڂǂ̂悤ɕ]Ă邩(}N
  WJ)ɂ macroexpand g܂B
  
    (macroexpand '(M2 (any1) (any2) (any3)))
    => (progn (m-setup) (any1) (any2) (any3) (m-cleanup))
  
  Gȃ}N`ƁAlist  append  cons  
  quote ႲᏑ̂߂ǂ`AƂ
  Ńev[ggƂł܂Bڂ͖ʓ|
  Ȃ̂ł܂(^^; ̗ev[ggď
  Ƃ̂悤ɂȂ܂B
  
    (defmacro M (a b c)
      `(progn
         (m-setup)
         ,a ,b ,c
         (m-cleanup)))
  
    (defmacro M2 (&rest args)
      `(progn
         (m-setup)
         ,@args
         (m-cleanup)))


defpackage
[       type]: Macro
[  arguments]: defpackage PACKAGE-NAME &rest OPTIONS
[    package]: lisp
[    seealso]: make-package , find-package , use-package , delete-package , in-package , package-name , package-nicknames , pbP[W
[   referred]: *package* , list-all-packages
[       file]: package.l
[    section]: pbP[W
[description]: 
VpbP[W܂B

  :internal-size  V{̃nbVTCY
  :external-size  OV{̃nbVTCY

:internal-size y :external-size ̑傫́Ao^V{
1/3炢̒lłł傤B̒lȂƂāAVV
{o^łȂł͂Ȃ̂ŁAċCɂKv͂Ȃł傤B
nbV[`F[āA(intern̂݁jƒxȂ邾
B͑fIԂł傤B

gpF

  ;;; henmiƂpbP[WB
  ;;; lisp, editoruseĂ܂B
  (defpackage "henmi"
     (:use "lisp" "editor")
     (:internal-size 200)
     (:external-size 10))

݊:
  :internal-size, :external-size commonɂ͂ȂB


defparameter
[       type]: Macro
[  arguments]: defparameter NAME VALUE &optional DOC
[    package]: lisp
[    seealso]: defvar
[       file]: evalmacs.l
[    section]: ϐƒ萔
[description]: 
O[oȃXyVϐ錾Aw肵lɐݒ肵܂B
defvar ɎĂ܂AVALUE ͏ȗł܂B
܂ NAME łɒlꍇł VALUE ]AʂϐlƂ
ݒ肳܂B


defstruct
[       type]: Macro
[  arguments]: defstruct NAME-AND-OPTIONS &rest REST
[    package]: lisp
[       file]: struct.l
[    section]: ϐƒ萔
[description]: 
\̂`܂BCstructɑ܂B
IvVƂĈȉ̂̂wł܂B
ȉAxxxx ̕ɂ͍\̖܂B

  :conc-name         ʏAxxxx-Xbg ƂO֐ŕϐ
                     ANZX܂A̖OύX܂Bxxxx- 
                     ̕ɑ閼Ow肵܂B
  :constructor       w肵RXgN^𐶐܂B
                      :constructor 錾邱Ƃł܂B ɂ
                       RXgN^ (ϐ1 ϐ2 ... ϐn)
                     ̗lɎw肵܂B&key  &optionalgpA
                     Xbg̃ftHglƂ͈قȂftHglwł
                     B
                     RXgN^𖾎IɐĂAxyzzy̏ꍇAÖٓI
                     RXgN^Ă܂܂A̓CLtL2
                     ƈقȂ܂B
                     ȏ̏ڍׂ͕słB
  :copier            Rs[֐w肵̂ɕύX܂BقȂ铮
                     ֐wł킯ł͂܂B
                     Rs[֐́AV\̃IuWFNgăXbg
                     Rs[܂BV̍\̂ŊeXbǵAIuWFN
                     gL܂B
  :predicate         w肳ꂽ\̂ł邩ۂ𒲂ׂ֐w肵܂B
                     ̖OqVXe܂B
                     ftHǵA xxxx-p łB
  :include           ̍\̖w肷邱ƂŁA\̂p܂B
                     p\̂ɂϐ̐錾A̍\̂ł錾
                     Ă̂ƂĈ܂B
                     ȏ̏ڍׂ͕słB
  :print-function    IuWFNg print 鎞Ɏg֐w肵܂B
                     format֐ ~A ȂǂŃIuWFNgvg鎞ɌĂяo
                     ֐ς܂Bw肷֐3̈ƂA
                     ɃIuWFNgAXg[AiڍוsjƂ܂B
                     3́Apretty printɊւl܂B
                     :print-function w肳ȂꍇA #S \Ńvg
                     ܂B
  :type              iڍוsj
  :named             iڍוsj
  :initial-offset    iڍוsj

:
  NAME-AND-OPTIONS   IvVw肵ȂƂ͍\̖AIvVw肷
                     Ƃ́A
                       (\̖ (IvV1 l1) (IvV2 l2) ... )
                     ̗lɎw肵܂B
  REST               \̂̃Xbgw肵܂BXbĝ݂A
                       (Xbg ftHgl :type ^Cv :read-only tO) 
                     ̗lɏĂЂƂ̃Xbg`܂B 
                     :type  :read-only ́AtɂĂЕ݂̂ł\܂B
                     Xg`ŏꍇA납珇ɏȗł܂B
                     ^Cv́A̍\̂̃IuWFNgł邩ǂ𒲂ׂ
                     q̐ɎgƂł܂Axyzzy ł͎gĂȂ
                     悤łB

ɃIvVw肵Ȃ make-xxxx, copy-xxxx, xxxx-p, xxxx-ϐ Ƃ֐
悤łB 

  make-xxxx     ftHg̃RXgN^
  copy-xxxx     ftHg̃Rs[֐
  xxxx-p        w肳ꂽ\̂ł邩ۂ𒲂ׂ֐
  xxxx-ϐ   ϐւ̃ANZX֐

`F
  ;;; struct.l̒`
  (defmacro defstruct (name-and-options &rest rest)
    (eval-when (:compile-toplevel :load-toplevel :execute)
      (defstruct-helper name-and-options rest)))

gpF
  ;;; FTPT[o\\̂̏ꍇ
  ;;; l\ߎw肷邱Ƃ\
  (defstruct ftpsvr 
     anonymous hostname (port 80))
  => #<structure-definition: ftpsvr>
  (setq f1 (make-ftpsvr))
  => #S(ftpsvr anonymous nil hostname nil port 80)
  (setq f2 (make-ftpsvr  :anonymous t :hostname "ftp.world.com"))
  => #S(ftpsvr anonymous t hostname "ftp.world.com" port 80)
  (setq f3 #S(ftpsvr anonymous nil hostname "localhost"))
  => #S(ftpsvr anonymous nil hostname "localhost" port 80)

  ;;; l\\̂̏ꍇ
  (defstruct person
     (name nil :type string)
     age
     (bloodtype "A"))
  => #<structure-definition: person>
  (setq p1 (make-person :name "Mike" :age 19))
  => #S(person name "Mike" age 19 bloodtype "A")
  (person-name p1)
  => "Mike"
  (setq p2 (copy-person p1))
  => #S(person name "Mike" age 19 bloodtype "A")
  (setf (person-bloodtype p1) "O")
  => "O"
  (person-bloodtype p1)
  => "O"
  (person-bloodtype p2)
  => "A"

  ;;; ҂\\̂̏ꍇ
  (defstruct (patient
             (:conc-name p-)
             (:print-function
              (lambda (o s p)
                (format s "<patient ~A ~D ~A>" (p-name o) (p-age o) (p-sicks o))))
              (:include person))
     (sicks nil :type (or nil list))
     id)
  => #<structure-definition: patient>
  (setq p3 (make-patient :name "Lucy" :age 18 :sicks '("")))
  => #S(patient name "Lucy" age 18 bloodtype "A" sicks ("") id nil)
  (format nil "~A" p3)
  => "<patient Lucy 18 ()>"


deftype
[       type]: Macro
[  arguments]: deftype NAME (&rest LAMBDA-LIST) &rest BODY
[    package]: lisp
[    seealso]: si:canonicalize-type , subtypep , typep , ^ꗗ
[       file]: typespec.l
[    section]: f[^^
[description]: 
NAME ƌÕf[^^`܂B
`f[^^ typep  subtypep ȂǂŎgƂł܂B
 typep Ŏgꍇɂ́AgpO si:canonicalize-type 
邱ƂKvȂ悤łB

gp:
  ;; lisp/typespec.l 
  ;; mod Ƃ^`
  (deftype mod (n)
    `(integer 0 ,(1- n))) ; 0 ȏ n ̐
  (typep 3 (si:canonicalize-type '(mod 5)))
  => t

  ;; ^Ă݂
  (deftype odd ()
    `(and integer
          (satisfies oddp)))
  (typep 3 (si:canonicalize-type 'odd))
  => t
  (subtypep 'odd 'integer)
  => t
  => t


defun
[       type]: Macro
[  arguments]: defun NAME (&rest LAMBDA-LIST) &body BODY
[    package]: lisp
[    seealso]: lambda
[       file]: evalmacs.l
[    section]: ֐
[description]: 
֐`܂BNAME łɊ֐`ꍇ͏㏑܂B
BODY ̐擪 documentation  interactive 錾܂߂邱Ƃł܂B


defvar
[       type]: Macro
[  arguments]: defvar NAME &optional (INITIAL-VALUE () SV) DOC
[    package]: lisp
[    seealso]: defparameter , defvar-local , defconstant
[       file]: evalmacs.l
[    section]: ϐƒ萔
[description]: 
O[oȃXyVϐ錾܂B
錾ꂽϐ̓_Ci~bNȃXR[v悤ɂȂ܂B
INITIAL-VALUE ^ꂽꍇANAME ϐƂĂ̒lȂ
INITIAL-VALUE ]ǍʂϐlƂĐݒ肵܂B


defvar-local
[       type]: Macro
[  arguments]: defvar-local NAME INITIAL-VALUE &optional DOC
[    package]: editor
[    seealso]: make-local-variable , setq-default , local-variable-p , buffer-local-value , defvar
[       file]: misc.l
[    section]: ϐƒ萔
[description]: 
ϐNAMEobt@ɈقȂl悤ɂ܂B֘A֐ƂāA
defvar/make-local-variable܂Aꂼ@\قȂ܂B
defvar-localdefvarƈقȂAXyVϐƂ͂ȂȂ̂ŒӂKvłB

  defvar              : XyVϐB
  defvar-local        : Sobt@ŕϐƎ̒l悤ɂB
  make-local-variable : ̃obt@ŕϐƎ̒l悤ɂB

܂Adefvar-localł͂̕ϐ̓[Jϐɂ͂ȂȂ悤łBo
bt@setqď߂ă[JɂȂilocal-variable-ptɂȂj悤
łB

gpF
  ;;; defvardefvar-localgă_Ci~bNLVJmFB
  (defvar var 3)
  => var  
  (defvar-local var-local 3)
  => var-local
  
  (defun foo () (let ((var 4) (var-local 4)) (bar)))
  => foo
  (defun bar () (format nil "var : ~S, var-local : ~S" var var-local))
  => bar
  
  (foo)
  => "var : 4, var-local : 3"
(defvar-local *dabbrevs-case-fold* nil)


delete
[       type]: Function
[  arguments]: delete ITEM SEQUENCE &key :from-end :test :test-not :start :end :count :key
[    package]: lisp
[    seealso]: remove , delete-if , delete-if-not , delete-duplicates
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒ITEMƈv̂폜V[PXԂ܂B
 SEQUENCE ͔j󂳂܂B

  :count    : 폜镶𐧌܂B
  :from-end : :countw肳ꂽꍇɂ݈̂Ӗ܂B
         nil    SEQUENCE̐擪폜܂B
         t      SEQUENCĚ폜܂B

gpF
  ;;; removedeletegĂ݂B
  (setq foo "abcabcdef")        => "abcabcdef"
  (remove #\b foo)              => "acacdef"
  foo                           => "abcabcdef"
  (delete #\b foo)              => "acacdef"
  foo                           => "acacdef"


delete-all-pseudo-frames
[       type]: Function
[  arguments]: delete-all-pseudo-frames &optional (CREATE-NEW t)
[    package]: editor
[    seealso]: delete-pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
t[ׂč폜܂B

  CREATE-NEW : ׂč폜ɁAVt[邩ǂ
        t        
        nil      Ȃ

et[ƂɃXbg deleted-fn ɓo^ꂽ֐s܂B


delete-backward-char
[       type]: Function
[  arguments]: delete-backward-char &optional (N 1)
[    package]: editor
[    seealso]: delete-backward-char-or-selection , delete-char
[   referred]: backward-delete-char-untabify , backward-delete-char-untabify-or-selection
[       file]: cmds.l
[    section]: eLXg
[description]: 
J[\̕w蕶폜܂B


delete-backward-char-or-selection
[       type]: Function
[  arguments]: delete-backward-char-or-selection &optional (N 1)
[    package]: editor
[    seealso]: delete-char-or-selection
[   referred]: delete-backward-char
[       file]: cmds.l
[    section]: eLXg
[description]: 
ZNV΃ZNVŜAłȂ΃J[\̌
폜܂B[C-h]


delete-blank-lines
[       type]: Function
[  arguments]: delete-blank-lines
[    package]: editor
[       file]: cmds.l
[    section]: eLXg
[description]: 
J[\̂s܂͂̎̍s̑Oɑs폜܂B[C-x C-o]
̋sꍇ͉sc܂B

ȂsƂ͔pXy[Xу^û݂ȂŝƂłB


delete-buffer
[       type]: Function
[  arguments]: delete-buffer BUFFER
[    package]: editor
[    seealso]: *before-delete-buffer-hook* , *delete-buffer-hook* , kill-buffer , deleted-buffer-p
[   referred]: delete-window
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@폜܂Akill-bufferƈႢΘbIɍ폜邩ǂ͕
܂Bkill-bufferIɂdelete-buffergĂ܂B

delete-bufferł͈ȉ̓̃tbNԂɎs܂B

  *before-delete-buffer-hook*
        delete-bufferp邩ǂ𐧌䂵܂Bo^ꂽ֐
        łnilԂdelete-buffer𒆎~܂B

  *delete-buffer-hook*
        delete-bufferobt@ŉsꍇɎgp܂B


delete-char
[       type]: Function
[  arguments]: delete-char &optional (N 1)
[    package]: editor
[    seealso]: delete-char-or-selection , delete-backward-char
[       file]: cmds.l
[    section]: eLXg
[description]: 
w蕶폜܂B


delete-char-or-selection
[       type]: Function
[  arguments]: delete-char-or-selection &optional (N 1)
[    package]: editor
[    seealso]: delete-char , delete-selection
[   referred]: delete-backward-char-or-selection
[       file]: cmds.l
[    section]: eLXg
[description]: 
ZNVőI𒆂Ȃ΃ZNVŜAłȂ΃J[\̈
u̕폜܂Bdelete-charƂ̓ZNV̓삪قȂ܂B
[C-d], [Delete]


delete-command-bar
[       type]: Function
[  arguments]: delete-command-bar SYM
[    package]: editor
[    seealso]: define-command-bar
[       file]: cmdbar.l
[    section]: j[
[description]: 
c[o[폜܂B


delete-directory
[       type]: Function
[  arguments]: delete-directory DIRNAME &key :if-does-not-exist :if-access-denied
[    package]: lisp
[    seealso]: delete-file , create-directory
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
fBNg폜܂B

  DIRNAME            : 폜fBNgw肵܂B
  :if-does-not-exist : fBNg݂Ȃꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
  :if-access-denied  : ANZXۂꂽꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
        :force          Iɍ폜݂܂B

폜łǂŖ߂lς܂B

  t   폜ɐ
  nil 폜Ɏs

gpF
  (delete-directory "C:/xyzzy/testdir")
  => t


delete-duplicates
[       type]: Function
[  arguments]: delete-duplicates SEQUENCE &key :from-end :test :test-not (:start 0) (:end (length SEQUENCE)) (:key #'identity)
[    package]: lisp
[    seealso]: delete , remove-duplicates
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE ̒dvf폜V[PXԂ܂B
delete lA SEQUENCE ͔j󂳂܂B

 :from-end  non-nil ȂV[PX̏I肩dvf폜Ă܂B


delete-file
[       type]: Function
[  arguments]: delete-file FILE &key :if-does-not-exist :if-access-denied :recycle
[    package]: lisp
[    seealso]: delete-directory , rename-file , copy-file
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@C폜܂B

  FILE               : 폜t@Cw肵܂B
  :if-does-not-exist : t@C݂Ȃꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
  :if-access-denied  : ANZXۂꂽꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
        :force          Iɍ폜݂܂B

폜łǂŖ߂lς܂B

  t   폜ɐ
  nil 폜Ɏs

gpF  
  (delete-file "C:/xyzzy/test.txt")
  => t


delete-file-in-archive
[       type]: Function
[  arguments]: delete-file-in-archive ARCHIVE-FILE &rest FILES
[    package]: editor
[    seealso]: create-archive , extract-archive
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
A[JCuw肵t@C폜܂B

  ARCHIVE-FILE : A[JCuw肵܂B
  FILES        : 폜t@Cw肵܂B

gpF
  ;;; c:/tmp/foo.lzh  xyz.c 폜܂B
  (delete-file-in-archive "c:/tmp/foo.lzh" "xyz.c")


delete-hook
[       type]: Function
[  arguments]: delete-hook HOOK FN
[    package]: editor
[    seealso]: add-hook
[       file]: misc.l
[    section]: [h
[description]: 
tbNϐ֐폜܂B

  HOOK : tbNϐ̃V{w肵܂B
  FN   : ֐̃V{w肵܂B


delete-horizontal-spaces
[       type]: Function
[  arguments]: delete-horizontal-spaces
[    package]: editor
[    seealso]: just-one-space
[       file]: cmds.l
[    section]: eLXg
[description]: 
s̃J[\ʒȗŐ󔒂폜܂B[ESC \]


delete-if
[       type]: Function
[  arguments]: delete-if PREDICATE SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: remove-if , delete , delete-if-not
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒PREDICATE𖞂̂폜V[PXԂ܂B
 SEQUENCE ͔j󂳂܂B


delete-if-not
[       type]: Function
[  arguments]: delete-if-not PREDICATE SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: remove-if-not , delete , delete-if
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒PREDICATE𖞂Ȃ̂폜V[PXԂ܂B
 SEQUENCE ͔j󂳂܂B


delete-indentation
[       type]: Function
[  arguments]: delete-indentation &optional ARG
[    package]: editor
[    seealso]: just-one-space , newline-and-indent
[       file]: cmds.l
[    section]: 
[description]: 
Cfg폜O̍sƘA܂B[ESC ^]
AsƂśApXy[Xŋ؂܂B

  ARG : Asw肵܂B
        t   s̃Cfg폜A݂̍sɘA܂B
        nil ݂̍s̃Cfg폜AO̍sɘA܂B


delete-last-ime-composition
[       type]: Function
[  arguments]: delete-last-ime-composition
[    package]: editor
[       file]: kanji.l
[    section]: 
[description]: 
IME ϊł΁AOɕϊ폜܂B[C-c C-d]


delete-marker
[       type]: Function
[  arguments]: delete-marker MARKER
[    package]: editor
[    seealso]: unset-marker
[   referred]: process-marker
[       file]: builtin.l
[    section]: |WV
[description]: 
}[J[폜܂B
IuWFNg̓}[J[ƂĎgȂȂ܂B
ꍇ tAłɍ폜Ăꍇ nil Ԃ܂B

gpF
  (delete-marker m)
  => t
  m
  => #<deleted-marker 128914348>


delete-menu
[       type]: Function
[  arguments]: delete-menu MENU TAG-OR-POSITION &optional TAG-OR-POSITION-P
[    package]: editor
[   referred]: define-menu
[       file]: builtin.l
[    section]: j[
[description]: 
j[獀ړ폜܂B

  MENU              : 폜郁j[w肵܂B
  TAG-OR-POSITION   : ^O͈ʒuw肵܂B
  TAG-OR-POSITION-P : TAG-OR-POSITION̈^OƂĉ߂邩ʒu
                      ĉ߂邩߂܂B
           nil     TAG-OR-POSITION̓^O\V{
           non-nil TAG-OR-POSITION͈ʒu\l
  
^Ow肵ꍇɂ̓j[ċAIɌŏɌڂ폜
܂B ^O݂Ȃꍇ⃁j[ڐȏ̈ʒuw肵ꍇ
́A폜Ɏs܂B

߂l͈ȉ̂ƂłB

  t   폜ɐB
  nil 폜ɎsB


delete-other-windows
[       type]: Function
[  arguments]: delete-other-windows
[    package]: editor
[    seealso]: delete-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
݃J[\EBhEȊÕEBhE폜܂B [C-x 1]
A݃J[\EBhE~jobt@EBhȄꍇ͑
EBhE폜܂B

߂lF
  t     EBhE̍폜Ɋւ炸 t Œ


delete-package
[       type]: Function
[  arguments]: delete-package PACKAGE
[    package]: lisp
[    seealso]: make-package , defpackage , pbP[W
[   referred]: find-package
[       file]: builtin.l
[    section]: pbP[W
[description]: 
pbP[W폜܂B

gpF
  ;;; test ppbP[W
  (defpackage "test")
  => #<package: test>
  (find-package "test")
  => #<package: test>
  ;;; test pbP[W폜
  (delete-package "test")
  => t
  (find-package "test")
  => nil


delete-pseudo-frame
[       type]: Function
[  arguments]: delete-pseudo-frame &optional (FRAME ed::*current-pseudo-frame*)
[    package]: editor
[    seealso]: new-pseudo-frame , delete-all-pseudo-frames
[   referred]: ed::pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
t[폜܂B[C-x 6 0]
Ō̂ЂƂ폜ꍇAɐVt[܂B

  FRAME : 폜t[

FRAME ̃Xbg deleted-fn Ɋ֐ݒ肳ĂꍇAFRAME 폜O funcall ܂B


delete-rectangle
[       type]: Function
[  arguments]: delete-rectangle P1 P2
[    package]: editor
[    seealso]: kill-rectangle , delete-rectangle-selection , operate-on-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
P1  P2 Ŏw肳`̈폜܂B


delete-rectangle-selection
[       type]: Function
[  arguments]: delete-rectangle-selection
[    package]: editor
[    seealso]: kill-rectangle-selection , delete-rectangle , operate-on-rectangle-selection
[       file]: select.l
[    section]: [W
[description]: 
`IꂽZNV̗̈폜܂B


delete-region
[       type]: Function
[  arguments]: delete-region FROM TO
[    package]: editor
[       file]: builtin.l
[    section]: [W
[description]: 
w肳ꂽ͈͂폜܂B


delete-text-attribute-point
[       type]: Function
[  arguments]: delete-text-attribute-point POINT
[    package]: editor
[    seealso]: delete-text-attributes
[   referred]: clear-all-text-attributes , find-text-attribute-point
[       file]: builtin.l
[    section]: eLXg
[description]: 
POINT ̈ʒũeLXg폜܂B
eLXĝ POINT ̈ʒu͈͂Ɋ܂ނ̂폜܂B


delete-text-attributes
[       type]: Function
[  arguments]: delete-text-attributes TAG &key :test :test-not :key
[    package]: editor
[    seealso]: delete-text-attribute-point , delete-text-attributes-if , clear-all-text-attributes , set-text-attribute
[   referred]: clear-all-text-colors , delete-text-attributes-if-not
[       file]: builtin.l
[    section]: eLXg
[description]: 
set-text-attributeŎw肵^Ȏ܂


delete-text-attributes-if
[       type]: Function
[  arguments]: delete-text-attributes-if TEST &key :key
[    package]: editor
[    seealso]: delete-text-attributes-if-not , delete-text-attributes
[       file]: builtin.l
[    section]: eLXg
[description]: 
eLXĝA^O TEST 𖞂ׂ̂č폜܂B


delete-text-attributes-if-not
[       type]: Function
[  arguments]: delete-text-attributes-if-not TEST &key :key
[    package]: editor
[    seealso]: delete-text-attributes-if , delete-text-attributes
[       file]: builtin.l
[    section]: eLXg
[description]: 
eLXĝA^O TEST 𖞂Ȃׂ̂č폜܂B


delete-tool-bar
[       type]: Function
[  arguments]: delete-tool-bar NAME
[    package]: editor
[    seealso]: create-tool-bar
[       file]: builtin.l
[    section]: j[
[description]: 
c[o[NAME폜܂B
R}ho[Ƃēo^Ăꍇɂ́A[\]-[c[o[]Ɏc[c
Ă܂܂̂ŁAdelete-command-barō폜Kv܂B


delete-trailing-spaces
[       type]: Function
[  arguments]: delete-trailing-spaces
[    package]: editor
[       file]: cmds.l
[    section]: eLXg
[description]: 
|Cg̘AXy[X폜܂B


delete-window
[       type]: Function
[  arguments]: delete-window
[    package]: editor
[    seealso]: set-window , delete-other-windows , minibuffer-window-p , delete-buffer , deleted-buffer-p
[       file]: builtin.l
[    section]: EBhE
[description]: 
݃J[\EBhE폜܂B [C-x 0]
~jobt@EBhE͍폜ł܂B
܂A~jobt@EBhEȊÕEBhẼ݂EBhÊ݂̏ꍇ
 simple-error 𔭐܂B

EBhE폜́Aȉ̏̂AłDx̍𖞂~j
obt@EBhEȊÕEBhË̗LÃEBhE
set-window ܂B
  1. 폜EBhE̍ӂƁAEӂvEBhE
  2. 폜EBhẺEӂƁAӂvEBhE
  3. 폜EBhȄӂƁAӂvEBhE
  4. 폜EBhE̒ӂƁAӂvEBhE

߂lF
  t     EBhE폜
  nil   EBhE폜s

⑫F
  xyzzy 0.2.2.233 ł (delete-buffer X) ɑ΂ (deleted-buffer-p X)
  ݂܂A(delete-window X) ɑ΂ (deleted-window-p X) ͑
  ܂B
  ;;; deleted-buffer-p ͂ deleted-window-p ̒`
  (in-package "editor")
  (export '(deleted-window-p))
  (defun deleted-window-p (window)
    (unless (windowp window)
      (error 'lisp::type-error :datum window :expected-type 'window))
    (handler-case
        (progn
          (window-buffer window)
          t)
      (program-error (c)
        nil)))


deleted-buffer-p
[       type]: Function
[  arguments]: deleted-buffer-p BUFFER
[    package]: editor
[    seealso]: delete-buffer
[   referred]: delete-window , kill-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@폜Ă邩ǂ𒲂ׂ܂B
BUFFERɂ̓obt@^̂̂wł܂B

  t   w肳ꂽobt@͊ɍ폜Ă܂B
  nil w肳ꂽobt@͖폜Ă܂B


denominator
[       type]: Function
[  arguments]: denominator RATIONAL
[    package]: lisp
[    seealso]: numerator , /
[       file]: builtin.l
[    section]: l
[description]: 
̕Ԃ܂B


deposit-field
[       type]: Function
[  arguments]: deposit-field NEWBYTE BYTESPEC INTEGER
[    package]: lisp
[    seealso]: ldb , dpb
[       file]: number.l
[    section]: l
[description]: 
w肳ꂽtB[h NEWBYTE ̓tB[h̓eŒul
܂B

gpF
  (format nil "~2,'0x" (deposit-field #x0f (byte 4 4) #xa7))
  =>"07"
  (format nil "~2,'0x" (deposit-field #xaa (byte 4 4) #x0f))
  =>"af"


describe-bindings
[       type]: Function
[  arguments]: describe-bindings
[    package]: editor
[       file]: keymap.l
[    section]: L[}bv
[description]: 
Jgobt@̃L[蓖Ĉꗗ\܂B


describe-function
[       type]: Function
[  arguments]: describe-function SYMBOL
[    package]: editor
[    seealso]: describe-variable
[       file]: help.l
[    section]: V{
[description]: 
w肳ꂽ֐̈ docstring \܂B


describe-key
[       type]: Function
[  arguments]: describe-key KEY
[    package]: editor
[    seealso]: describe-key-briefly
[       file]: help.l
[    section]: L[}bv
[description]: 
w肵L[ɃoChꂽ֐ docstring \܂B


describe-key-briefly
[       type]: Function
[  arguments]: describe-key-briefly KEY &optional ARG
[    package]: editor
[    seealso]: describe-key
[       file]: help.l
[    section]: L[}bv
[description]: 
w肵L[ɃoChꂽ֐\܂B[C-x ?]

  KEY : L[
  ARG : o(\)ǂɂ邩
        nil     : Xe[^Xo[ɕ\
        non-nil : obt@ɁuL[ (֐)ṽtH[}bgŕo


describe-variable
[       type]: Function
[  arguments]: describe-variable SYMBOL
[    package]: editor
[    seealso]: describe-function
[       file]: help.l
[    section]: V{
[description]: 
w肳ꂽϐ݂̌̒lA(constant or special) docstring \
܂B


detect-char-encoding
[       type]: Function
[  arguments]: detect-char-encoding STRING-OR-STREAM
[    package]: editor
[    seealso]: set-stream-encoding , stream-encoding , convert-encoding-from-internal , convert-encoding-to-internal
[   referred]: map-char-encoding-region
[       file]: builtin.l
[    section]: eLXg
[description]: 
STRING-OR-STREAM ̕GR[fBO𔻒肵܂B


dialog
[       type]: Function
[  arguments]: dialog X Y W H &rest CONTROLS
[    package]: lisp
[    seealso]: dialog-box
[    section]: _CAO
[description]: 
_CAO`܂B

  X Y      : _CAO̕\ʒuw肵܂B
  W H      : _CAȎ傫w肵܂B
  CONTROLS : Rg[w肵܂B

Rg[xyzzyō쐬͖̂ʓ|Ȃ̂ŁAVisualC++̃\[X쐬
ŁAizuĕϊ@pӂĂ܂BVobt@ 
*.rct@CKvȕĂŁA

  M-x convert-dialog-template-buffer

obt@Ilisp`ɕϊ܂B


dialog-box
[       type]: Function
[  arguments]: dialog-box TEMPLATE INITIAL-VALUE CHECK-OR-DISABLE
[    package]: editor
[    seealso]: dialog , file-name-dialog , directory-name-dialog , drive-dialog
[       file]: builtin.l
[    section]: _CAO
[description]: 
_CAO{bNX\܂B_CAOdialogŒ`ꂽ̂g܂B

  TEMPLATE :
      lisp̌`ŋLqꂽ_CAOev[gw肵܂B
      ڍׂ́A֐dialogQƂĂB

  INITIAL-VALUE :
      GfBg{bNXɓAȂǂw肵܂B
      Ɏw肵Ȃꍇnilł܂܂B

  CHECK-OR-DISABLE :
      `FbN{bNX̏IԂw肵܂B
      Ɏw肵Ȃꍇnilł܂܂B

߂l͑lȂ̂ŁA multiple-value-bind Ŏ󂯎Kv܂B1
ڂ̖߂ĺAcancel{^ꂽnilAok{^ꂽtԂ܂B
  
gpF
  ;;; eXgp̃_CAO`܂B
  (setq *test-dialog-template*
    `(dialog 0 0 300 100 
             (:caption "ɂ")
             (:font 9 "lr oSVbN")
             (:control
              (:static nil nil #x50020003 7 7 18 21)
              (:static nil ,(concat "XYZZY version "
                                    (software-version))
               #x50020000 34 7 92 8)
              (:static nil "Copyright (C) 1996, 97 T.Kamei"
               #x50020000 34 17 92 8)
              (:button IDOK "OK" #x50010001 52 35 36 14))))

  ;;; eXgp̃_CAO\܂B
  (defun test-dialog ()
    (interactive)
    (dialog-box *test-dialog-template* nil nil)
    t)


digit-argument
[       type]: Function
[  arguments]: digit-argument RAW &optional ARG
[    package]: editor
[    seealso]: universal-argument , negative-argument
[       file]: cmds.l
[    section]: ֐
[description]: 
ɑR}hɑOun܂B[ESC 0 ... ESC 9]


digit-char
[       type]: Function
[  arguments]: digit-char WEIGHT &optional (RADIX 10)
[    package]: lisp
[    seealso]: digit-char-p
[       file]: builtin.l
[    section]: 
[description]: 
RADIX Ƃꍇ WEIGHT ̕\̕Ԃ܂B
̗łƁA (digit-char 12 16) 16i\Lꍇ12́A
#\C ɂȂ܂BWEIGHT  RADIX ȏɂȂ nil Ԃ܂B

gpF
  (digit-char 7)
  => #\7
  (digit-char 12)
  => nil
  (digit-char 12 16)
  => #\C
  (digit-char 6 2)
  => nil
  (digit-char 1 2)
  => #\1


digit-char-p
[       type]: Function
[  arguments]: digit-char-p CHAR &optional (RADIX 10)
[    package]: lisp
[    seealso]: digit-char , characterp
[       file]: builtin.l
[    section]: 
[description]: 
CHAR Ȃ炻̐10i\ł̒lAłȂ nil Ԃ܂B

  RADIX : 

gpF  
  (digit-char-p #\1)
  => 1
  (digit-char-p #\a)
  => nil
  (digit-char-p #\a 16)
  => 10
  (digit-char-p #\RET)
  => nil


ding
[       type]: Function
[  arguments]: ding
[    package]: editor
[    seealso]: undefined
[       file]: builtin.l
[    section]: ̑
[description]: 
炵܂Hiڍוsj

gpF
  ;;; 炷B
  (ding)
  => nil


directory
[       type]: Function
[  arguments]: directory PATHNAME &key :absolute :recursive :wild :depth :file-only :show-dots :count :directory-only :callback :file-info
[    package]: lisp
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
ΏۃfBNg̃t@CXgœ܂B

  PATHNAME        : fBNg̃pXłB
  :absolute       : ʂtpXŎ擾܂B
  :recursive      : TufBNgΏۂƂ邩𐧌䂵܂B
        t               TufBNg̒܂Ō
        nil             TufBNg̒܂ł͌Ȃ
  :wild           : ChJ[hwłBXgłłB
  :depth          : :recursive w肷Ƃ̍ċA̐[łB
  :file-only      : t@C܂B
  :show-dots      : fBNgƂ"./""../"܂B
  :count          : \t@Č𐧌܂B
  :directory-only : fBNg܂B
  :callback       : t@Cɂ funcall ܂B
                    funcall ʂXgɂĕԂ܂B
  :file-info      : t@C̑擾܂B
                    get-file-info Ŏ擾ł̂ƓłB

gpF
  ;;;  "../"͏oǁA"./"oȂꍇ
  (delete "./" (directory ... :show-dots t) :test #'string=)

  ;;; "C:/"̔zꗗ\B
  (directory "C:/" :callback #'(lambda (x) (print x)))

  ;;; t@C̃\[gi啶ʗLj
  (sort (directory ...) #'string<)

  ;;; t@C̃\[gi啶ʗLj
  (sort (directory ...) #'string-lessp)


directory-name-dialog
[       type]: Function
[  arguments]: directory-name-dialog &key :title :default
[    package]: editor
[    seealso]: file-name-dialog , read-directory-name
[   referred]: dialog-box , drive-dialog
[       file]: builtin.l
[    section]: _CAO
[description]: 
fBNgw肷_CAO\܂B
[U[w肵fBNgԂ܂B
  
  :title   : _CAÕ^Cg
  :default : \fBNg

gpF
  ;;; ~jobt@fBNgǂݎB
  (directory-name-dialog)
  => "C:/applications/xyzzy/site-lisp"


directory-namestring
[       type]: Function
[  arguments]: directory-namestring PATHNAME
[    package]: lisp
[    seealso]: pathname-directory , file-namestring , remove-trail-slash
[   referred]: merge-pathnames
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMẼfBNgԂ܂B

gpF  
  (directory-namestring "C:/xyzzy/xyzzy.exe")
  => "C:/xyzzy/"
  (directory-namestring "~/test.txt")
  => "C:/HOME/"
  (directory-namestring "/usr/local/bin")
  => "C:/usr/local/"


display-first-tab-char
[       type]: Variable
[    package]: editor
[    seealso]: display-rest-tab-char
[       file]: defs.l
[    section]: 
[description]: 
^u̕\Ɏgp镶ݒ肵܂Bŏ̕
display-first-tab-charŐݒ肵Aȍ~̕
display-rest-tab-charŐݒ肵܂B
xyzzy 0.2.2.215`

gpF
  (setq-default display-first-tab-char #\rightwards_arrow_to_bar)
  (setq-default display-rest-tab-char nil)


display-newline-char
[       type]: Variable
[    package]: editor
[       file]: defs.l
[    section]: 
[description]: 
s̕\Ɏgp镶ݒ肵܂B
  p  w肵ŕ\
  nil       󔒂ŕ\
  LȊO  ]̕ŕ\

gpF
  (setq-default display-newline-char #\downwards_arrow_with_tip_leftwards)


display-rest-tab-char
[       type]: Variable
[    package]: editor
[    seealso]: display-first-tab-char
[       file]: defs.l
[    section]: 
[description]: 
^u̕\Ɏgp镶ݒ肵܂B
ڂ display-first-tab-char QƂĂB


do
[       type]: Macro
[  arguments]: do (&rest VARLIST) (&optional END-TEST &rest RESULT) &body BODY
[    package]: lisp
[   referred]: do*
[       file]: evalmacs.l
[    section]: \
[description]: 
(do ((var1 init1 step1)
     (var2 init2 step2)
            ...
     (varm initm stepm))
    (end-test result1 result2 ... resultm) 
   declaration1
       ...
   declarationN)

(do ((<ϐ1> <l1> <Xebv1>)
     (<ϐ2> <l2> <Xebv2>)
              ...
     (<ϐm> <lm> <Xebvm>))
    (<<I> <㎮1> ... <㎮p>) 
   <1>
   ...
   <n>)


<ϐ1>`<ϐm>܂łǏϐƂC<I>^
ɂȂ܂do{̂<1>`<n>JԂsB<
ϐ1>`<ϐm>܂ł͕ϐ\LŁCdo̒ŋǏIɎg
ϐw肷Bdo]Ƃ́C܂<l1>`
<lm>܂ł]C̒leǏϐɃoChB
̌ŁC<I>]ClnilłΖ{̂sB
<Xebv1>`<Xebvm>܂ł]Ă̒leǏ
ϐɑĂ<I>]B<I>
̒lnilȊOɂȂ܂ŌJԂB<I>̒lnilȊOɂȂ
C<I>ɑ<㎮1>`<㎮p>]C
̍Ō̎̒ldo̒lƂB

döʌ`́C

(block nil
  (let ((<ϐ1> <l1> <Xebv1>)
        (<ϐ2> <l2> <Xebv2>)
                 ...
        (<ϐm> <lm> <Xebvm>))
    (tagbody
      loop
      (when <I>
        (return (progn <㎮1> ... <㎮p>)))
      <1>
      ...
      <n>
     (psetq <ϐ1> <Xebv1>
              ...
            <ϐm> <Xebvm>)
      (go loop))))

ƓlłB(loop Ƃ^O͑ł͎gĂȂ̂Ƃ)


do*
[       type]: Macro
[  arguments]: do* (&rest VARLIST) (&optional END-TEST &rest RESULT) &body BODY
[    package]: lisp
[    seealso]: do , let , let*
[       file]: evalmacs.l
[    section]: \
[description]: 
doƓ悤Ƀ[vsB
doƂǁAletlet*̈Ⴂ̂悤ɁAǏϐ̏ƍX
V̕@ɂBdoletgċǏϐĂ邽߁ASĂ̏
lvZĂǏϐoCh邪Cdo*łlet̑let*
gĂB܂psetq̂setqgB

do*̈ʌ`́A

(block nil
  (let* ((<ϐ1> <l1> <Xebv1>)
         (<ϐ2> <l2> <Xebv2>)
                  ...
         (<ϐm> <lm> <Xebvm>))
    (tagbody
      loop
      (when <I>
        (return (progn <㎮1> ... <㎮p>)))
      <1>
      ...
      <n>
     (setq <ϐ1> <Xebv1>
              ...
           <ϐm> <Xebvm>)
      (go loop))))

ƓlłB(loop Ƃ^O͑ł͎gĂȂ̂Ƃ)


do-all-symbols
[       type]: Macro
[  arguments]: do-all-symbols (VAR &optional RESULT-FORM) &body BODY
[    package]: lisp
[    seealso]: with-package-iterator
[   referred]: do-external-symbols , do-symbols
[       file]: package.l
[    section]: pbP[W
[description]: 
SV{񋓂܂B

  VAR         : 񋓂ꂽV{i[ϐw肵܂B
  RESULT-FORM : iڍוsj
  BODY        : stH[w肵܂B

gpF
  ;;; V{񋓂ĕϐE֐E}NEpbP[Wo͂Ă݂B
  (do-all-symbols (sym)
    (and (or (boundp sym)
             (fboundp sym))
         (format t "~:[ ~;V~]~:[ ~;F~]~:[ ~;M~] ~A ~S~%"
                 (boundp sym)
                 (fboundp sym)
                 (macro-function sym)
                 (package-name (symbol-package sym))
                 sym)))


do-completion
[       type]: Function
[  arguments]: do-completion FROM TO TYPE &optional COMPL WORD LAST-CHAR (POPUP-P *POPUP-COMPLETION-LIST-DEFAULT*)
[    package]: editor
[       file]: complete.l
[    section]: eLXg
[description]: 
eLXg̕⊮܂B
ڍׂ*do-completionQƂĉB

gpF
  ;;; J[\̒ÕpX⊮܂B
  (do-completion (point) 
                 (progn (skip-syntax-spec-backward "^ ") (point))
                 :file-name)


do-events
[       type]: Function
[  arguments]: do-events
[    package]: lisp
[    seealso]: refresh-screen , sit-for , sleep-for
[       file]: builtin.l
[    section]: ̑
[description]: 
̓rɁAWindows̃CxgĂ邨܂Ȃ炵B

gpF
  ;;; CxgĂ݂B
  (do-events)
  => nil


do-external-symbols
[       type]: Macro
[  arguments]: do-external-symbols (VAR &optional (PACKAGE () SV) RESULT-FORM) &body BODY
[    package]: lisp
[    seealso]: do-all-symbols , do-symbols
[       file]: package.l
[    section]: \
[description]: 
do-symbols ƎĂ܂AOV{݂̂ɑ΂ČJԂs܂B


do-symbols
[       type]: Macro
[  arguments]: do-symbols (VAR &optional (PACKAGE () SV) RESULT-FORM) &body BODY
[    package]: lisp
[    seealso]: do-external-symbols , do-all-symbols , dolist
[       file]: package.l
[    section]: \
[description]: 
V{ׂĂɂČJԂs܂B
ƂĂ dolist ɎĂ܂B

do-all-symbols ƈē̃pbP[WT܂Bmɂ̓pbP
[W̊OV{EV{сÃpbP[W use Ă
pbP[W̊OV{ΏۂɂȂ܂B

  VAR           : BODY sɊeV{ɑϐ
  PACKAGE       : V{TpbP[W (ftHg *package*)
  RESULT-FORM   : do-symbols ̖߂l
  BODY          : JԂ̖{


dolist
[       type]: Macro
[  arguments]: dolist (VAR LISTFORM &optional (RESULTFORM ''())) &body BODY
[    package]: lisp
[   referred]: do-symbols
[       file]: evalmacs.l
[    section]: \
[description]: 
Xg̒JԂs܂B

  (dolist (<ϐ> <Xg> <l>)
    <1> ... <n>)

܂<Xg>]B̌ナXg̗vfƂɕϐ̗vf
oChāC{̂<1>`<n>܂ł]B{̎̕]
SĂ̗vfɑ΂ďIƁC<l>]Cdolist̒lƂĕԂB
܂<l>͏ȗłC̏ꍇdolist̒lnilłB

dolisẗʌ`́C
  
  (do* ((temp <Xg> (cdr temp))
        (<ϐ> (car temp) (car temp)))
      ((endp temp) <l>)
    <1>
    ...
    <n>)
  
ƓlłB

gpF
  (let ((result nil))
    (dolist (item '("Lois" "Charley" "David") (nreverse result))
      (push (length item) result)))
  => (4 7 5)


dotimes
[       type]: Macro
[  arguments]: dotimes (VAR COUNTFORM &optional (RESULTFORM ''())) &body BODY
[    package]: lisp
[       file]: evalmacs.l
[    section]: \
[description]: 
(dotimes (<ϐ> <> <l>)
  <1> ... <n>)

w肳ꂽ񐔂JԂs܂B

܂<>]܂B̒lnƂƁA0`n-1܂ł̂ꂼ
lɑ΂āA<ϐ>̐lɃoChāA{̂<1>`<n>
܂ł]܂BȂ킿{̎nJԂ܂B{̎̕]
nJԂƁA<l>]Adotimes̒lƂĕԂ܂B
܂<l>͏ȗłȀꍇdotimes̖߂lnilłB

dotimes̈ʌ`́A

(do* ((temp <>)
      (<ϐ> 0 (1+ <ϐ>)))
    ((>= <ϐ> temp) <l>)
  <1>
  ...
  <n>)

ƓlłB


double-float-p
[       type]: Function
[  arguments]: double-float-p OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT  double-float Ȃ t AȊOȂ nil Ԃ܂B


down-list
[       type]: Function
[  arguments]: down-list &optional ARG NO-ERRORS
[    package]: editor
[    seealso]: backward-sexp , backward-list , up-list
[       file]: builtin.l
[    section]: |WV
[description]: 
J[\Oɂ ARG ̊ʂ̌Ɉڂ܂B[ESC C-d]

  (setq lst '(a b c)) ; 
       ^
  (setq lst '(a b c)) ; 
              ^

OɊʂȂꍇA
NO-ERRORS  nil ̏ꍇɂ̓G[A t ̏ꍇɂ nil Ԃ܂B
܂A߂ɂ銇ʂȂ悤łB

  (defun test () (setq lst '(a b c))) ;  ARG = 2  down-list 
     ^                                ; G[ɂȂ


downcase-region
[       type]: Function
[  arguments]: downcase-region FROM TO
[    package]: editor
[    seealso]: downcase-word , capitalize-region , upcase-region
[       file]: builtin.l
[    section]: [W
[description]: 
[W̒Pɂ܂B[C-x C-l]


downcase-word
[       type]: Function
[  arguments]: downcase-word &optional (ARG 1)
[    package]: editor
[    seealso]: upcase-word , capitalize-word , downcase-region , downcase-selection , string-downcase
[       file]: cmds.l
[    section]: 
[description]: 
J[\ʒuP̖܂łɕϊ܂B[ESC l]


dpb
[       type]: Function
[  arguments]: dpb NEWBYTE BYTESPEC INTEGER
[    package]: lisp
[    seealso]: ldb , deposit-field
[   referred]: byte
[       file]: number.l
[    section]: l
[description]: 
w肳ꂽtB[h NEWBYTE ŒulԂ܂B

gpF
  (format nil "~2,'0x" (dpb #x0f (byte 4 4) #xa7))
  =>"f7"
  (format nil "~2,'0x" (dpb #x0a (byte 4 4) #x0f))
  =>"af"


drive-dialog
[       type]: Function
[  arguments]: drive-dialog &optional DRIVE
[    package]: editor
[    seealso]: file-name-dialog , directory-name-dialog
[   referred]: dialog-box
[       file]: builtin.l
[    section]: _CAO
[description]: 
hCuĨ_CAO\܂BDRIVEŏ\hCuI
ł܂BIhCũhCuLN^ŕԂ܂B

gpF
  (drive-dialog)
  => #\R


dump-xyzzy
[       type]: Function
[  arguments]: dump-xyzzy &optional FILENAME
[    package]: editor
[    seealso]: xyzzy-dumped-p , version-up-xyzzy
[   referred]: si:dump-image-path
[       file]: builtin.l
[    section]: VXe
[description]: 
_vt@CFILENAMEɂč쐬܂B
ɍ쐬ĂĂ㏑܂B
FILENAMEȗ̃t@ĆHimFj


echo-stream-input-stream
[       type]: Function
[  arguments]: echo-stream-input-stream ECHO-STREAM
[    package]: lisp
[    seealso]: make-echo-stream
[       file]: builtin.l
[    section]: o
[description]: 
make-echo-streamōꂽECHO-STREAM̓͌̃Xg[Ԃ܂B


echo-stream-output-stream
[       type]: Function
[  arguments]: echo-stream-output-stream ECHO-STREAM
[    package]: lisp
[    seealso]: make-echo-stream
[       file]: builtin.l
[    section]: o
[description]: 
make-echo-streamōꂽECHO-STREAM̏o͐̃Xg[Ԃ܂B


ed::*auto-save-session-file*
[       type]: Variable
[    package]: editor
[    seealso]: toggle-session-auto-save , close-session
[       file]: session.l
[    section]: obt@
[description]: 
ZbV̎ۑtOłB

  nil     : ۑȂ
  non-nil : ۑ


ed::*last-search-regexp*
[       type]: Variable
[    package]: editor
[   referred]: re-search-backward-again , re-search-forward-again
[    section]: EK\
[description]: 
O̐K\p^[ۑĂ܂B


ed::*last-search-string*
[       type]: Variable
[    package]: editor
[   referred]: search-backward-again , search-forward-again
[       file]: search.l
[    section]: EK\
[description]: 
ǑꂪۑĂ܂B


ed::*register-alist*
[       type]: Variable
[    package]: editor
[    seealso]: ed::get-register , ed::set-register
[       file]: register.l
[    section]: ϐƒ萔
[description]: 
WX^Ɋi[ĂlێϐB
g (name . datum) ̌`̘AzXgłB
emacs ƈႢ name ɂ͂ǂȕł悤łB

datum ƂĂ(ʏ)ȉ̂̂gpł܂B
  }[J[
  
  `̈(̃Xg)
  window configuration


ed::build-summary-function
[       type]: BufferLocal
[    package]: editor
[    seealso]: list-function
[    section]: ֐
[description]: 
obt@̊֐̈ꗗ擾܂Bsyъ֐vfɎX
gœ܂Blist-functionŎgpĂ܂B

gpF
  ; listfn.lŕ]
  (funcall ed::build-summary-function)
  => ((10 "lisp-build-summary-of-functions") (39 "lisp-maketags"))


ed::find-file-internal
[       type]: Function
[  arguments]: find-file-internal FILENAME &optional NOWARN (KANJI-CODE nil SVAR) NEWLINE-CODE NOMSG
[    package]: editor
[    seealso]: find-file , *find-file-hooks* , *before-find-file-hook* , *find-file-file-not-found-hook* , *find-file-auto-mode-function* , buffer-read-only
[       file]: files.l
[    section]: t@CVXe
[description]: 
t@CJ܂Bfind-filefind-file-internalpĎĂ܂B
find-filẽ͕t@CJ@\܂A̃t@CJ
ł΁A̕łB

  FILENAME : t@C


ed::get-register
[       type]: Function
[  arguments]: get-register R
[    package]: editor
[    seealso]: ed::set-register , view-register
[   referred]: ed::*register-alist*
[       file]: register.l
[    section]: ̑
[description]: 
WX^ R ̒lԂ܂BĂȂꍇ̖߂l nil łB


ed::get-selection-start-end
[       type]: Function
[  arguments]: get-selection-start-end
[    package]: editor
[   referred]: selection-start-end
[       file]: select.l
[    section]: |WV
[description]: 
ZNV̊JnʒuƏIʒu𑽒lŕԂ܂B
A`IԂłnilԂ܂B


ed::map-selection
[       type]: Function
[  arguments]: map-selection FN
[    package]: editor
[       file]: select.l
[    section]: |WV
[description]: 
ZNV̊JnʒuƏIʒuɂĊ֐Ăяo܂B

  FN : Ăяo֐w肵܂BĂяoɂ͊JnʒuƏIʒun
       ܂̂ŁÂ悤Ȋ֐I/FɂĂȂ΂Ȃ܂B

gpF
  ;;;
  (defun map-test ()
    (interactive)
    (ed::map-selection #'(lambda (start end) (message (format nil "~s ~s" start end)))))

⑫F
  editorpbP[WGNX|[gĂȂ̂ŁAed::Kv܂B
  I̊JnʒuƏIʒu𐳊mɓn̂ŁAO֌WɒӂĉB


ed::pseudo-frame
[       type]: Struct
[    package]: editor
[    seealso]: new-pseudo-frame , select-pseudo-frame , delete-pseudo-frame , *select-pseudo-frame-hook*
[       link]: http://xyzzy.s53.xrea.com/qanda/wiki.cgi?p=e1d59f7af8a5ebd071340560b6ed41a2 , http://xyzzy.s53.xrea.com/wiki/index.php?QuickTour%2Fframe
[       file]: pframe.l
[    section]: EBhE
[description]: 
t[ pseudo-frame Ƃ\̂ƂāApframe.l Œ`Ă܂B
̍\͈̂ȉ̂悤ȃXbgĂ܂B
  name        : t[̖O
  winconf     : ̃t[ɂEBhȄ
  save-p      : ZbVۑɂ̃t[ۑ邩ǂ
  selected-fn : ̃t[IƂɎs֐
  deleted-fn  : ̃t[폜ƂɎs֐

t[V쐬ɂ new-pseudo-frame g΂悭A
winconf ȊÕXbg new-pseudo-frame ̈ƂĎwł܂B
winconf ̓t[쐬ړɎIɐݒ肳܂B

selected-fn  delete-fn ɐݒ肳ꂽ֐ funcall ɂČĂяo܂B
*select-pseudo-frame-hook* ƈقȂAt[ƂɈقȂ֐蓖Ă邱Ƃł܂B
܂Aselected-fn ̊֐ *select-pseudo-frame-hook* Ɏs܂B


ed::set-register
[       type]: Function
[  arguments]: set-register R VALUE
[    package]: editor
[    seealso]: ed::get-register , view-register
[   referred]: ed::*register-alist*
[       file]: register.l
[    section]: ̑
[description]: 
WX^ R ɒl VALUE i[܂B


ed::toggle-mode
[       type]: Function
[  arguments]: toggle-mode VAR ARG SV
[    package]: editor
[   referred]: toggle-trace-on-error
[       file]: cmds.l
[    section]: [h
[description]: 
}Ci[[h̏Ԃ\ϐVARݒ肵܂B
SVnilȂΏԂ͔]܂B
ARGnilȂΖɂȂ܂B
ARG񕉐lnon-nilȂΗLɂȂ܂B


eighth
[       type]: Function
[  arguments]: eighth X
[    package]: lisp
[    seealso]: nth
[       file]: list.l
[    section]: Xg
[description]: 
list  8 Ԗڂ̗vfԂ܂B

  (eighth X) = (nth 7 X)

gpF
  (eighth '(1 2 3 4 5 6 7 8 9 0))
  => 8


eject-media
[       type]: Function
[  arguments]: eject-media DRIVE
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
DRIVEɎw肵hCuCWFNg܂B
DRIVE̓LN^Ŏw肵܂B
gpF
  (setq a (merge-pathnames "xyzzy.exe" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.exe"
  
  (eject-media (svref a 0)) ; CWFNgs\ȃhCu
  =>w肳ꂽfoCX͖łB 

  (eject-media #\P)
  =>t
(svref (default-directory) 0))


elt
[       type]: Function
[  arguments]: elt SEQUENCE INDEX
[    package]: lisp
[    seealso]: nth
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCEINDEXԖڂ̗vfԂ܂B
INDEX0Ƃ܂BȂnilԂ܂B


emacs-write-file
[       type]: Function
[  arguments]: emacs-write-file FILENAME
[    package]: editor
[    seealso]: save-buffer , write-file
[   referred]: *default-write-file-directory*
[       file]: files.l
[    section]: t@CVXe
[description]: 
obt@̓e FILENAME ɏ݂܂B
Ƀobt@уobt@Ɋ֘Atꂽt@CύX܂B


enable-post-buffer-modified-hook
[       type]: Function
[  arguments]: enable-post-buffer-modified-hook ENABLE &optional BUFFER
[    package]: editor
[    seealso]: post-buffer-modified-hook-enabled-p , post-buffer-modified-hook
[       link]: [xyzzy:06354]
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
post-buffer-modified-hookLEɂ܂B
Jgobt@̒l̂ݕύX܂B

  ENABLE  : non-nil Lɂ܂
            nil     ɂ܂
  BUFFER  : Lɂobt@w肵܂B
            ȗnil^ꍇ̓Jgobt@w肵Ƃ݂Ȃ܂B


encode-universal-time
[       type]: Function
[  arguments]: encode-universal-time SECOND MINUTE HOUR DAY MONTH YEAR &optional TIME-ZONE
[    package]: lisp
[    seealso]: decode-universal-time , format-date-string
[       file]: builtin.l
[    section]: tE
[description]: 
烆jo[T^C`̎Ԃɕϊ܂u1900N11000b
w肳ꂽ܂ŕbvjo[T^C`̎ԂƌĂт܂B

  SECOND    : b
  MINUTE    : 
  HOUR      : 
  DAY       : 
  MONTH     : 
  YEAR      : N
  TIME-ZONE : ^C][w肵܂BGMT̍̎Ԃw肷悤łB
              ȗƑIĂ^C][Ƃ̍gp܂B
              ʂGMTJSTƂ̍-9()ƂȂ܂B

jo[T^C`̎Ԃւ̕ϊdecode-universal-timegp܂B

gpF
  (encode-universal-time 0 0 0 1 1 1900)    => -32400
  (encode-universal-time 0 0 0 1 1 1900 0)  => 0
  (encode-universal-time 0 0 0 1 1 1900 -9) => -32400
  (encode-universal-time 0 30 18 24 4 2003) => 3260165400

QƁF
  timestmp.l


end-of-buffer
[       type]: Function
[  arguments]: end-of-buffer
[    package]: editor
[    seealso]: beginning-of-buffer , set-mark-command , selection-end-of-buffer
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\obt@̖Ɉړ܂B[ESC >]
J[\ʒuɂ̓}[Nݒ肵܂B

}[NύXȂ߂ɂ
(goto-char (point-max))g܂B


end-of-defun
[       type]: Function
[  arguments]: end-of-defun &optional (ARG 1)
[    package]: editor
[    seealso]: beginning-of-defun
[       file]: sexp.l
[    section]: ֐
[description]: 
J[\֐`̖Ɉړ܂B[ESC C-e]


end-of-line
[       type]: Function
[  arguments]: end-of-line
[    package]: editor
[    seealso]: beginning-of-line
[   referred]: selection-end-of-line
[       file]: cmds.l
[    section]: |WV
[description]: 
ݍs̏IɈړ܂B[C-e], [C-Right]


end-of-virtual-line
[       type]: Function
[  arguments]: end-of-virtual-line
[    package]: editor
[    seealso]: goto-virtual-eol
[   referred]: selection-end-of-virtual-line
[       file]: cmds.l
[    section]: |WV
[description]: 
\s̍sɈړ܂B
goto-virtual-eol  interactive łłB


endp
[       type]: Function
[  arguments]: endp OBJECT
[    package]: lisp
[    seealso]: null
[       file]: builtin.l
[    section]: Xg
[description]: 
OBJECT 󂩂ǂԂ܂B
Xg̏I𔻒肷̂Ɏgp܂B null ƈقȂA
ႦΕw肷ƃG[𔭐܂B

  󃊃Xgnil   t
  łȂXg        nil
  ȊO              G[

gpF
  ;;; nullƂ̈ႢĂ݂B
  (endp "foo")  => sȃf[^^ł: t: list
  (endp nil)    => t
  (null "foo")  =>nil
  (null nil)    => t


enlarge-window
[       type]: Function
[  arguments]: enlarge-window &optional EXTEND VERTICAL
[    package]: editor
[    seealso]: shrink-window , enlarge-window-horizontally
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE̍sEύX܂B[C-x z], [C-x ^]
VERTICALw肵Ȃꍇɂ͍sύX܂B

  EXTEND   : 傫sEw肵܂Bw肷ƏȂ܂B
  VERTICAL : Eŝǂݒ肷邩w肵܂B
        t       ύXB
        nil     sύXB

gpF
  ;;; EBhEύXĂ݂B
  (enlarge-window 2 t)  => t
  (enlarge-window 100)  => ύXł܂ 


enlarge-window-horizontally
[       type]: Function
[  arguments]: enlarge-window-horizontally &optional (ARG 1)
[    package]: editor
[    seealso]: shrink-window-horizontally , enlarge-window
[       file]: window.l
[    section]: EBhE
[description]: 
J[\̂EBhE̕傫܂B[C-x }]

gpF
  ;;; lister̃}[WEBhE̕ꍇ
  (enlarge-window-horizontally (- *lister-margin* (window-width)))


enum-buffers
[       type]: Function
[  arguments]: enum-buffers FN
[    package]: editor
[    seealso]: buffer-list
[       file]: builtin.l
[    section]: obt@
[description]: 
֐nilȊOԂ܂Ńobt@񋓂܂B

gpF
  ;;; obt@񋓂B
  (enum-buffers #'(lambda (x) (and (yes-or-no-p "~S" x) x)))
  => #<buffer:  *Completion*>


eobp
[       type]: Function
[  arguments]: eobp
[    package]: editor
[    seealso]: bobp
[       file]: builtin.l
[    section]: |WV
[description]: 
|Cgobt@̍Ōɂ邩ǂׂ܂B

gpF
  ;;; obt@̍Ō܂ŃJ[\ЂƂЂƂi߂H
  (while (not (eobp))
    (forward-char))


eolp
[       type]: Function
[  arguments]: eolp
[    package]: editor
[    seealso]: bolp
[       file]: builtin.l
[    section]: |WV
[description]: 
J[\sɂ邩ǂׂ܂B

  t     J[\sɂ
  nil   J[\͍sɂ͂Ȃ


eq
[       type]: Function
[  arguments]: eq X Y
[    package]: lisp
[    seealso]: eql , equal , equalp
[       file]: builtin.l
[    section]: f[^^
[description]: 
X  Y IuWFNgȂtAłȂȂnilԂ܂Bl╶
ɑ΂Ă͌㓯łtƂȂۏ؂͂܂Bxyzzył́Alt
ƂȂ邪łnilƂȂ悤ɎĂ悤łB

gpF
  ;;; eqŔrĂ݂B
  (eq 'foo 'foo)        => t    ; dl
  (eq 2 2)              => t    ; nˑ
  (eq "foo" "foo")      => nil  ; nˑ
  (eq '(1 2) '(1 2))    => nil  ; nˑ


eql
[       type]: Function
[  arguments]: eql X Y
[    package]: lisp
[    seealso]: eq , equal , equalp , char=
[   referred]: make-hash-table
[       file]: builtin.l
[    section]: f[^^
[description]: 
X  Y IuWFNgA^̐l܂͕^Œl
܂BtAłȂnilԂ܂BeqƂ͈قȂAlƂ
ē𔻒f܂BAg܂ł͌Ȃ̂ŕ͑ΏۊOƂȂ
܂B

gpF
  ;;; eqlŔrĂ݂B
  (eql 'foo 'foo)       => t    ; dl
  (eql 2 2)             => t    ; dl
  (eql "foo" "foo")     => nil  ; nˑ
  (eql '(1 2) '(1 2))   => nil  ; nˑ


equal
[       type]: Function
[  arguments]: equal X Y
[    package]: lisp
[    seealso]: eq , eql , equalp , = , char= , string=
[       file]: builtin.l
[    section]: f[^^
[description]: 
X  Y \ĂtAłȂnilԂ܂B

gpF
  ;;; equalŔrĂ݂B
  (equal 'foo 'foo)     => t    ; dl
  (equal 2 2)           => t    ; dl
  (equal "foo" "foo")   => t    ; dl
  (equal '(1 2) '(1 2)) => t    ; dl


equalp
[       type]: Function
[  arguments]: equalp X Y
[    package]: lisp
[    seealso]: eq , eql , equal , = , char-equal , string-equal
[       file]: builtin.l
[    section]: f[^^
[description]: 
equalƓ悤 X  Y r܂B
Aꕔ̍قe܂B
ႦΕE̔rł͑啶Əʂ܂B

gpF
  ;;; equalpŔrĂ݂B
  (equalp "Foo" "foo")  => t


erase-buffer
[       type]: Function
[  arguments]: erase-buffer BUFFER
[    package]: editor
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̓e폜܂B
ȉ̓eNA܂B
  Eobt@̃eLXg
  EύXtO
  ECt
  Erestriction
  EUNDO


error
[       type]: Function
[  arguments]: error DATUM &rest ARGS
[    package]: lisp
[    seealso]: handler-case , ignore-errors , unwind-protect , G[֌W , stack-trace , make-condition , si:*condition-string , si:*throw-error
[   referred]: define-condition , quit
[       file]: handler.l
[    section]: G[
[description]: 
O𔭐܂B

O͏ʂ̊KwŃnhO邱Ƃł܂B
nhO̕@handler-caseQƂĉB


esc-map
[       type]: Variable
[    package]: editor
[    seealso]: meta-prefix
[       file]: keymap.l
[    section]: L[}bv
[description]: 
ESC ɑL[V[PX̃oCfBOi[L[}bvłB


etc-path
[       type]: Function
[  arguments]: etc-path
[    package]: editor
[    seealso]: *etc-path*
[       file]: misc.l
[    section]: VXe
[description]: 
*etc-path*Ԃ܂B


eval
[       type]: Function
[  arguments]: eval FORM
[    package]: lisp
[       file]: builtin.l
[    section]: ]
[description]: 
FORM ]܂B


eval-buffer
[       type]: Function
[  arguments]: eval-buffer BUFFER
[    package]: editor
[    seealso]: eval-region
[       file]: lispmode.l
[    section]: ]
[description]: 
obt@Ŝ]܂B
eval-region gĎĂ܂B


eval-expression
[       type]: Function
[  arguments]: eval-expression X
[    package]: editor
[    seealso]: interactive
[       file]: cmds.l
[    section]: ]
[description]: 
lisp  X ]܂B[ESC ESC]
ΘbIɌĂяoꂽꍇ̓~jobt@œ͂ꂽ]܂B


eval-region
[       type]: Function
[  arguments]: eval-region FROM TO &optional STREAM
[    package]: editor
[    seealso]: eval-buffer
[       file]: lispmode.l
[    section]: ]
[description]: 
[WɏꂽLispR[h]܂B

gpF
  (eval-region from to (selected-buffer))


eval-when
[       type]: Special Form
[  arguments]: eval-when ({SITUATION}*) {FORM}*
[    package]: lisp
[       file]: builtin.l
[    section]: ]
[description]: 
ЂƂƂŌƁAtH[]邩ĂƂłB

̗ႾƁAdefine-dll-entry Ȃǂ̃}N̓RpCɓWJ
Ȃ΂ȂȂ̂łAdefine-dll-entry  foreign Œ
`Ă̂ŁAforeign [hĂȂƃ}Nł邱
ƂFł܂B(eval-when ...) ȂAP (require 
"foreign") ƁARpCɂ͒PȂ֐R[Ƃ݂Ȃ
Ă܂߁A}NWJȂȂĂ܂܂B̂
ɁAeval-when ŃRpCƂ foreign [hƎw
Ă킯łB


          \[X                       \[XiƓj
              (eval)                     (compile)
      LispC^[v^           LispRpC
                                         
                                        *.lc
                                            (load)
                                   LispC^[v^

Cꂾ maxƂ̂}NłˁB

#define max(a,b)   ((a>b)?a:b)

ȂB

int foo(int x, int y)
{
   return max(x, y);
}
ƏA
int foo(int x, int y)
{
   return ((x> y) ? x : y);
}

̂ƓłˁB
b̓发ƃvvZbTWJĂARpC
ƏĂƎv܂B

lispƂȂɂȂł

----    test.l ---------

(defmacro macro-max (a b)
  `(if (> ,a ,b) ,a ,b))

(defun foo (x y)
  (macro-max x y))

------------------------

M-x byte-compile-fileĂƂɁA
(defmacro macro-maxẮARpCłȂ
eval(C^[v^]jƂȂƂȂB

łȂfoôƂŁARpCOɃ\[XWJłȂB

 eval-when (compile)ȂłB
悭킩ȂARSĂΑvƂ^^;

(eval-when (:compile-toplevel :load-toplevel :execute)

Common Lisp̎dlł́A eval, load, compile
,Ǝv܂B

eval        --- C^[v^Ƀ[hƂeval
compile     --- compileeval
load        --- compile*.lc [hƂeval

(eval-when (:compile-toplevel :load-toplevel :execute)
āA܂ŁAxyzzyIWiƎvĂ܂B

łalleglohelp݂ĂA
(eval-when (:compile-toplevel :load-toplevel :execute)
Ă܂ˁB^^;
m܂łB

| Common Lisp̎dlł́A eval, load, compile
| ,Ǝv܂B

CLtL1 ł͂łACLtL2 ŕς܂B


evenp
[       type]: Function
[  arguments]: evenp INTEGER
[    package]: lisp
[    seealso]: oddp
[       file]: builtin.l
[    section]: l
[description]: 
INTEGERȂtAłȂnilԂ܂B

gpF  
  (evenp 2)
  => t
  (evenp 0)
  => t
  (evenp 1)
  => nil


every
[       type]: Function
[  arguments]: every PREDICATE SEQUENCE &rest MORE-SEQUENCES
[    package]: lisp
[    seealso]: some , notevery
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE̐擪̗vf珇ԂPREDICATEKpĂAPREDICATE
nil ԂƁAnilɕԂ܂B
SĂ̗vfPREDICATE𖞂ꍇA t Ԃ܂B

MORE-SEQUNCES^ꂽASEQUENCE̒ōłẐ̏I܂Ŏs܂B


exchange-point-and-mark
[       type]: Function
[  arguments]: exchange-point-and-mark
[    package]: editor
[    seealso]: mark , goto-last-modified-line , goto-last-mouse-point
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\ƃ}[N̈ʒuւ܂B[C-x C-x]


execute-extended-command
[       type]: Function
[  arguments]: execute-extended-command COMMAND &optional RAW ARG
[    package]: editor
[    seealso]: command-execute , repeat-complex-command
[       file]: misc.l
[    section]: ]
[description]: 
~jobt@R}hΘbIɓ͂Ďs܂B[ESC x]


execute-region
[       type]: Function
[  arguments]: execute-region FROM TO
[    package]: editor
[       file]: process.l
[    section]: vZX
[description]: 
[W̓eob`t@CƂĎs܂B


execute-shell-command
[       type]: Function
[  arguments]: execute-shell-command COMMAND &optional INFILE OUTPUT ENVIRON DIRECTORY
[    package]: editor
[    seealso]: call-process , execute-subprocess , shell-execute
[   referred]: pipe-command
[       file]: process.l
[    section]: vZX
[description]: 
OvOs܂BʂxyzzyɎ荞݂܂B

  COMMAND    : sR}hIvVtŎw肵܂B
  INFILE     : W͂gpOvOłΓ̓t@C
               w肵܂B
  OUTPUT     : Wo͂o͂obt@w肵܂B
  ENVIRON    : ݒ肷ϐAzXg`œn܂B
                (("HOME" . "C:/applications/xyzzy/")
                 ("TOPDIR" . "C:/spool/"))
  DIRECTORY  : sfBNgw肵܂B

̃R}h call-process gĎĂ܂B
call-processƂ͈ĕWo͂obt@ɏo͂܂Bo͂obt@͊
Sɔj󂳂܂̂ŒӂĂB
OvOƂĎsȂꍇ́C execute-subprocess g܂B

gpF
  ;;; R}hvvghelp\Ă݂B
  (execute-shell-command "help" nil (selected-buffer))


execute-subprocess
[       type]: Function
[  arguments]: execute-subprocess CMD &optional ARG BUFNAME ENVIRON DIRECTORY
[    package]: editor
[    seealso]: make-process , execute-shell-command , filter-region , command-output-mode , shell-command-line
[       file]: process.l
[    section]: vZX
[description]: 
vO BUFFNAME Ŏw肵obt@Ŏs܂B[C-x &]
ʂ́C BUFFNAME Ŏw肳ꂽobt@ɕ\܂B

  CMD        : sR}hIvVtŎw肵܂B
  ARG        : (ڍוs)
  BUFNAME    : ֘Atobt@w肵܂BftHg "*Command Output*" łB
               w肵obt@݂ȂƂCVobt@܂B
  ENVIRON    : ݒ肷ϐAzXg`œn܂B
                  (("HOME" . "C:/applications/xyzzy/")
                   ("TOPDIR" . "C:/spool/"))
  DIRECTORY  : sfBNgw肵܂B 

w肳ꂽobt@ command-output-mode ɂȂ܂B

gpF
  ;;; cmd.exe obt@Ŏs܂B VvȃVFƂē삵܂B
  (execute-subprocess "cmd.exe")
  =>#<buffer: *Command Output*>


exp
[       type]: Function
[  arguments]: exp NUMBER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
Rΐ̒ e  NUMBER ̐lԂ܂B

gpF
  ;;; Rΐ̒ e Ƃ̓\Ă݂B
  (exp 1)
  => 2.718282
  (exp 2)
  => 7.389056


expand-abbrev
[       type]: Function
[  arguments]: expand-abbrev
[    package]: editor
[    seealso]: abbrev-mode
[   referred]: *global-abbrev-table* , *local-abbrev-table* , *pre-abbrev-expand-hook*
[       file]: abbrev.l
[    section]: eLXg
[description]: 
J[\ʒuŐÓI̓WJs܂B[C-x ']
abbrev-mode ̎ self-insert-command łs܂B


export
[       type]: Function
[  arguments]: export SYMBOLS &optional PACKAGE
[    package]: lisp
[    seealso]: pbP[W , use-package , ǂ̊֐̓ɉ̂ł傤H
[   referred]: unexport
[       file]: builtin.l
[    section]: pbP[W
[description]: 
V{pbP[W̊OQƂł悤ɂ܂B

Ŏw肳ꂽ V{iϐ֐j̓pbP[WGNX|[gA
ʂ̃pbP[WCqŎQƂł悤ɂȂ܂BACq
ŎQƂɂ́Aʂ̃pbP[Wuse-packageĂȂƂ܂
B
                   use  system
                              
  lisp          user
                      
    editor      
                              
                        

̐}͂ǂ̃pbP[Wuse-pakcageĂ邩Ă܂B
pbP[Wuse鑼̃pbP[Wpackage-use-listgĊmF邱
ł܂BuseŕAlispeditoruse-packageĂ܂B

si:system-rootsystemexportĂ܂Ausersystem
use-packageĂȂ̂ŏCqKvłB

  ;;; system-rootsystemexportĂ邱ƂmFB
  (find-symbol "system-root" "system")
  => system:system-root
     :external

̂usersystem-rootgpꍇɂ(si:system-root)ƂĂ
oɂȂ܂B

gpF
    ;;; Ŏw肳ꂽ aset, file-name-sans-versions, ...
    ;;; GNX|[gAʂ̃pbP[WQƂł悤ɂȂB
    (export '(aset file-name-directory file-name-nondirectory
          file-name-sans-versions))


expt
[       type]: Function
[  arguments]: expt BASE-NUMBER POWER-NUMBER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
ׂ悵܂B

gpF  
  (expt 2 10)
  => 1024
  (expt 10 3)
  => 1000


extended-alphabet-char-p
[       type]: Function
[  arguments]: extended-alphabet-char-p CHAR
[    package]: editor
[    seealso]: characterp
[    section]: f[^^
[description]: 
CHAR (ISO8859)̒P\𔻒肵܂B


extract-archive
[       type]: Function
[  arguments]: extract-archive ARCHIVE-FILE TO-DIRECTORY &rest FILES
[    package]: editor
[    seealso]: create-archive , delete-file-in-archive
[   referred]: find-file-in-archive
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
A[JCuWJ܂B

ARCHIVE-FILE : WJA[JCuw肵܂B
TO-DIRECTORY : WJfBNgw肵܂B
FILES        : WJt@Cw肵܂Bw肵Ȃꍇ́ASẴt
               @CWJ܂B

gpF
  ;;; d:/foo.lzh  c:/tmp ɓWJ܂B
  (extract-archive "d:/foo.lzh" "c:/tmp")


fast-scroll-down
[       type]: Function
[  arguments]: fast-scroll-down
[    package]: editor
[    seealso]: fast-scroll-up , scroll-window
[       file]: cmds.l
[    section]: obt@
[description]: 
ɉXN[܂B[C-Up]


fast-scroll-up
[       type]: Function
[  arguments]: fast-scroll-up
[    package]: editor
[    seealso]: fast-scroll-down , scroll-window
[       file]: cmds.l
[    section]: obt@
[description]: 
ɏXN[܂B[C-Down]


fboundp
[       type]: Function
[  arguments]: fboundp SYMBOL
[    package]: lisp
[    seealso]: boundp , fmakunbound , macro-function
[       file]: builtin.l
[    section]: V{
[description]: 
V{Ɋ֐`Ă邩ǂԂ܂B

gpF
  (fboundp 'car)
  => t
  (fboundp 't)
  => nil


fceiling
[       type]: Function
[  arguments]: fceiling NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: ceiling
[       file]: builtin.l
[    section]: l
[description]: 
ceiling Ɠł_Ԃ܂B


featurep
[       type]: Function
[  arguments]: featurep FEATURE
[    package]: lisp
[    seealso]: *features*
[       file]: evalmacs.l
[    section]: VXe
[description]: 
FEATURE  *features* ̗vfł΂ȍ~̃XgԂ܂B
łȂ nil Ԃ܂B

gpF
 ;;; process.l 
 (let ((shell (if (featurep :windows-nt) "cmd.exe" "command.com")))
   (defvar *shell* shell)
   (defvar *eshell* shell))


ffloor
[       type]: Function
[  arguments]: ffloor NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: floor
[       file]: builtin.l
[    section]: l
[description]: 
floor Ɠł_Ԃ܂B


fifth
[       type]: Function
[  arguments]: fifth X
[    package]: lisp
[    seealso]: nth
[       file]: list.l
[    section]: Xg
[description]: 
list  5 Ԗڂ̗vfԂ܂B

  (fifth X) = (nth 4 X)

gpF
  (fifth '(1 2 3 4 5 6 7 8 9 0))
  => 5


file-directory-p
[       type]: Function
[  arguments]: file-directory-p PATHNAME
[    package]: lisp
[    seealso]: file-exist-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMEfBNgȂtAłȂnilԂ܂B

gpF  
  (file-directory-p "C:/xyzzy/")
  => t
  (file-directory-p "C:/xyzzy/xyzzy.exe")
  => nil
  (file-directory-p "~/")
  => t


file-executable-p
[       type]: Function
[  arguments]: file-executable-p PATHNAME
[    package]: lisp
[    seealso]: file-exist-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
ĵst@CłAtԂȂCB
PATHNAMEst@CۂԂ܂B

  t    st@CłB
  nil  st@Cł͂ȂB


file-exist-p
[       type]: Function
[  arguments]: file-exist-p PATHNAME
[    package]: lisp
[    seealso]: check-valid-pathname , file-readable-p , file-writable-p , file-executable-p , file-directory-p , file-write-time
[   referred]: valid-path-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAME݂tAłȂnilԂ܂B

gpF  
  (file-exist-p "C:/xyzzy/xyzzy.exe")
  => t
  (file-exist-p "~/")
  => t


file-length
[       type]: Function
[  arguments]: file-length PATHNAME
[    package]: lisp
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
w肳ꂽt@C̑傫oCgPʂŕԂ܂B

  PATHNAME : t@Cw肵܂B

gpF
  (file-length "C:/xyzzy/xyzzy.exe")
  => 977408


file-name-dialog
[       type]: Function
[  arguments]: file-name-dialog &key :char-encoding :eol-code :filter :filter-index :title :default :extension :save :multiple :must-exist :explorer :hide-read-only :initial-directory
[    package]: editor
[    seealso]: directory-name-dialog , open-file-dialog , read-directory-name
[   referred]: dialog-box , drive-dialog
[       file]: builtin.l
[    section]: _CAO
[description]: 
t@Cw肷_CAO\܂B
[U[w肵t@CԂ܂BlŕԂ܂B
iڍוsj

  :char-encoding        R[hwv_Ej[\
  :eol-code             sR[hwv_Ej[\
  :filter               t@C̎ރXg
  :filter-index         iڍוsj
  :title                _CAÕ^Cg
  :default              ftHg̃t@C
  :initial-directory    \fBNg
  :extension            iڍוsj
  :save                 non nilȂt@CtĕۑH
  :multiple             non nilȂ畡t@Cw
  :must-exist           non nilȂ瑶݂Ȃt@CwłȂ
  :explorer             iڍוsj
  :hide-read-only       Read Onlyȃt@C\ȂH

gpF
  ;;; ^CgFooɂāAI\ȃ_CAO\B
  (file-name-dialog :title "Foo"
                    :multiple t
                    :filter '(("ׂẴt@C(*.*)" . "*.*")))
  => ("C:/applications/xyzzy/xyzzycli.exe")


file-namestring
[       type]: Function
[  arguments]: file-namestring PATHNAME
[    package]: lisp
[    seealso]: pathname-name , directory-namestring
[   referred]: merge-pathnames , namestring , pathname-type
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMẼt@C̕Ԃ܂B
  
gpF
  (file-namestring "C:/xyzzy/xyzzy.exe")
  => "xyzzy.exe"
  (file-namestring "C:/Windows/")
  => ""

{c̏ꍇF
  ;;; {ćAȂ̂`Ă炵B
  (defun file-name-directory (filename)
    (directory-namestring filename))

  (defun file-name-nondirectory (filename)
    (file-namestring filename))

  (defun file-name-sans-versions (name)
    "Return FILENAME sans backup versions or strings.
  This is a separate procedure so your site-init or startup file can
  redefine it."
    (substring name 0
             (or (string-match "\\.~[0-9]+~\\'" name)
                 (string-match "~\\'" name)
                 (length name))))


file-newer-than-file-p
[       type]: Function
[  arguments]: file-newer-than-file-p FILE1 FILE2
[    package]: editor
[    seealso]: file-write-time
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@C̍ŏIXVr܂B
߂l͈ȉ̂ƂłB

  t   file1̕VAfile2B
  nil file2̕VAfile1AԍÂꂩB


file-position
[       type]: Function
[  arguments]: file-position FILE-STREAM &optional POSITION
[    package]: lisp
[    seealso]: buffer-stream-point , buffer-stream-set-point
[       file]: builtin.l
[    section]: o
[description]: 
FILE-STREAM݈̌ʒu擾EύX܂B
POSITIONȗƁAFILE-STREAM݈̌ʒuԂ܂B
POSITIONw肷ƁAFILE-STREAM݈̌ʒuύX܂B

  FILE-STREAM : o͂Xg[w肵܂B
  POSITION    : Xg[̐擪̈ʒuw肵܂B
                0ƂCfbNXłB

POSITIONɂ͕̐lw肷邱Ƃ͂ł܂B
܂AXg[̏I[zlw肷ƁA
̊ԂNULl߂܂B

gpF
  ;;; "01234567"Əo͌Aړ"abc"Əo͂܂B
  (setq foo (open "abc.txt" :direction :output))
  => #<file-output stream: C:/applications/xyzzy/abc.txt>
  (princ "0123456" foo)         => "0123456"
  (file-position foo 10)        => t
  (princ "abc" foo)             => "abc"
  (close foo)                   => t


file-property
[       type]: Function
[  arguments]: file-property PATHNAME
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMẼt@C̃vpeB\܂B
gpF
  (setq a (merge-pathnames "xyzzy.exe" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.exe"

  (file-property a)
  =>t


file-readable-p
[       type]: Function
[  arguments]: file-readable-p PATHNAME
[    package]: lisp
[    seealso]: file-writable-p , file-exist-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMEǂݎ\ȂtAłȂnilԂ܂B

gpF
  (file-readable-p "C:/xyzzy/xyzzy.exe")
  => t
  (file-readable-p "~/")
  => nil


file-visited-p
[       type]: Function
[  arguments]: file-visited-p &optional BUFFER
[    package]: editor
[       file]: builtin.l
[    section]: obt@
[description]: 
BUFFER t@CƂ t ƂȂ܂B
ftHgł BUFFER  ݂̃obt@łB


file-writable-p
[       type]: Function
[  arguments]: file-writable-p PATHNAME
[    package]: lisp
[    seealso]: file-readable-p , file-exist-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAME݉\t@CȂtAłȂnilԂ܂B

gpF  
  (file-writable-p "C:/xyzzy/xyzzy.exe")
  => t
  (file-writable-p "~/")
  => nil


file-write-time
[       type]: Function
[  arguments]: file-write-time FILENAME
[    package]: lisp
[    seealso]: set-file-write-time , file-newer-than-file-p , decode-universal-time , format-date-string , file-exist-p , get-universal-time
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@C̍ŏIXVjo[T^C`ŕԂ܂B

  FILENAME : t@Cw肵܂B
             tpXłȂ(default-directory)̑΃pXɂȂ܂B

gpF
  ;;; .xyzzy̍ŏIXVԂ܂B
  (file-write-time ".xyzzy")
  => 3076147256


filer
[       type]: Function
[  arguments]: filer &optional PATH ALLOW-MULTIPLE-SELECT-P CAPTION DUAL-WINDOW-P MODELESSP
[    package]: editor
[    seealso]: *filer-primary-directory* , *filer-secondary-directory*
[   referred]: *filer-directories* , *filer-echo-filename* , *filer-guide-text* , *filer-mark-file-size-unit* , *filer-modal* , *filer-path-masks* , *filer-primary-file-mask* , *filer-secondary-file-mask* , *filer-use-recycle-bin* , *modal-filer-save-size* , open-filer
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CJ܂B

  PATH      : t@Cŏɕ\fBNgw肵܂B
  ALLOW-MULTIPLE-SELECT-P
            : t@C𕡐I\ɂ邩ǂw肵܂B
  CAPTION   : t@C̃EBhẼ^Cgw肵܂B
  DUAL-WINDOW-P
            : ʃt@CŊJǂw肵܂B
  MODELESSP : [hX_CAOŃt@CJǂw肵܂B
              [hX̏ꍇɂ͕ҏWt@C\ł܂B

Iʂ𑽒lŕԂ܂B

  ŏ̖߂l̓[UIt@C̃XgԂ܂B
  ̖߂lOK{^tACANCEL{^nilԂ܂B

gpF
  ;;; multiple-value-bindŃt@C󂯎B
  (multiple-value-bind (files bool)
       (filer "c:/" t "title" nil)
       (when bool
         (msgbox "~{~S~%~}" files)))
  => :ok


filer-calc-directory-byte-size
[       type]: Function
[  arguments]: filer-calc-directory-byte-size
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂđIfBNg̃t@CTCY̍vvZ܂B


filer-calc-directory-size
[       type]: Function
[  arguments]: filer-calc-directory-size
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂđIfBNg̃fBXNgpʂvZ܂B


filer-cancel
[       type]: Function
[  arguments]: filer-cancel
[    package]: editor
[    seealso]: filer-close
[       file]: filer.l
[    section]: t@C
[description]: 
t@C܂B
uv{^uLZ{^vƂƓʂ܂B

(defun filer-cancel ()
 (filer-close nil))
ƒ`Ă܂B


filer-clear-all-marks
[       type]: Function
[  arguments]: filer-clear-all-marks &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂă}[NSĉ܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-close
[       type]: Function
[  arguments]: filer-close RESULT
[    package]: editor
[    seealso]: filer-cancel
[       file]: builtin.l
[    section]: t@C
[description]: 
t@C܂B

  RESULT : [_t@C̏ꍇA֐filer̖߂lɉe^܂B
           iڍוsj


filer-context-menu
[       type]: Function
[  arguments]: filer-context-menu
[    package]: editor
[    section]: t@C
[description]: 
t@CɂăReLXgj[\܂B


filer-count-marks
[       type]: Function
[  arguments]: filer-count-marks &optional FILE-ONLY-P SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂă}[Nꂽt@C̐Ԃ܂B

  FILE-ONLY-P        : fBNgΏۂɂ邩
             nil         fBNgΏۂɂ܂
             non-nil     t@CΏۂɂ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂B
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-current-file-directory-p
[       type]: Function
[  arguments]: filer-current-file-directory-p &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\ʒũt@CfBNgǂ𔻒肵܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-current-file-dot-dot-p
[       type]: Function
[  arguments]: filer-current-file-dot-dot-p &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\ʒũt@CefBNg ".." 
ł邩ǂ𔻒肵܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-demand-reload
[       type]: Function
[  arguments]: filer-demand-reload
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
iڍוsj


filer-dual-window-p
[       type]: Function
[  arguments]: filer-dual-window-p
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cʃt@Cǂ𔻕ʂ܂B


filer-forward-line
[       type]: Function
[  arguments]: filer-forward-line &optional ARG SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\̍sɈړ܂B

  ARG                : wsړ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-forward-page
[       type]: Function
[  arguments]: filer-forward-page &optional ARG SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\̃y[WɈړ܂B

  ARG                : wy[Wړ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-get-current-file
[       type]: Function
[  arguments]: filer-get-current-file &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\ʒũt@C̃pXԂ܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-get-directory
[       type]: Function
[  arguments]: filer-get-directory &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂČݕ\ĂfBNg̃tpX擾܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-get-drive
[       type]: Function
[  arguments]: filer-get-drive &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂČݕ\ĂhCu擾܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-get-mark-files
[       type]: Function
[  arguments]: filer-get-mark-files &optional FILE-ONLY-P SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂă}[Nꂽt@C̃pXXǧ`ŕԂ܂B

  FILE-ONLY-P        : fBNgΏۂɂ邩
             nil         fBNgΏۂɂ܂
             non-nil     t@CΏۂɂ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-get-sort-order
[       type]: Function
[  arguments]: filer-get-sort-order &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂt@C̕\Ԃ܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-get-text
[       type]: Function
[  arguments]: filer-get-text
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
ʃt@Cɂď㕔̃t@C̗ɏĂeLXgԂ܂B


filer-goto-bof
[       type]: Function
[  arguments]: filer-goto-bof &optional SECONDARY-WINDOW-P
[    package]: editor
[    seealso]: filer-goto-eof
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\EBhE̐擪Ɉړ܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-goto-eof
[       type]: Function
[  arguments]: filer-goto-eof &optional SECONDARY-WINDOW-P
[    package]: editor
[    seealso]: filer-goto-bof
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\EBhE̍ŌɈړ܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-goto-file
[       type]: Function
[  arguments]: filer-goto-file STRING &optional START REVERSE WILD-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂăt@C STRING ̈ʒuɃJ[\ړ܂B

  STRING  : t@C
  START   : Jnʒu
     nil      擪
     t        ݈ʒu
     ȊO ݈ʒu̎
  REVERSE : T
     nil      O
     non-nil  
  WILD-P  : ChJ[hLɂ邩
     nil      
     t        L
     ȊO L擪v("*"₤)


filer-isearch
[       type]: Function
[  arguments]: filer-isearch &optional CHAR NO-WRAP SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăCN^T[`ɂJ[\ړs܂B

  CHAR               : 镶Bnil ͓̎͂ꂽL[܂B
  NO-WRAP            : Ō܂łAŏɖ߂邩ǂ
             nil         ߂Ȃ
             non-nil     ߂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-left-window
[       type]: Function
[  arguments]: filer-left-window
[    package]: editor
[    seealso]: filer-right-window
[       file]: builtin.l
[    section]: t@C
[description]: 
ʃt@Cɂč̃EBhEANeBuɂ܂B


filer-left-window-p
[       type]: Function
[  arguments]: filer-left-window-p
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
ʃt@CɂČ݃ANeBuȃEBhẼEBhEʂ܂B


filer-mark
[       type]: Function
[  arguments]: filer-mark &optional FILE-ONLY-P SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\ʒũt@C}[N܂B

  FILE-ONLY-P        : fBNgΏۂɂ邩
             nil         fBNgΏۂɂ܂
             non-nil     t@CΏۂɂ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-mark-all
[       type]: Function
[  arguments]: filer-mark-all &optional FILE-ONLY-P SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂČݕ\ĂfBNgɂt@CSĂ}[N܂B

  FILE-ONLY-P        : fBNgΏۂɂ邩
             nil         fBNgΏۂɂ܂
             non-nil     t@CΏۂɂ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-mark-match-files
[       type]: Function
[  arguments]: filer-mark-match-files MASK &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
MASK ̎𖞂t@CSă}[N܂B

  MASK               : }[Nt@C̏
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-modal-p
[       type]: Function
[  arguments]: filer-modal-p
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@C[_ʂ܂B


filer-modify-column-width
[       type]: Function
[  arguments]: filer-modify-column-width N D &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂ邻ꂼ̃J̕ς܂B

  N                  : ύXJ
             0           t@C
             1           TCY
             2           XV
             3           
  D                  : ύX
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-read-char
[       type]: Function
[  arguments]: filer-read-char
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăL[{[h̓͂ǂݍ݁AԂ܂B


filer-reload
[       type]: Function
[  arguments]: filer-reload &optional MASK SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@C̉ʂXVAŐV̏Ԃɂ܂B

  MASK               : \t@C̏w肵܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-right-window
[       type]: Function
[  arguments]: filer-right-window
[    package]: editor
[    seealso]: filer-left-window
[       file]: builtin.l
[    section]: t@C
[description]: 
ʃt@CɂĉẼEBhEANeBuɂ܂B


filer-scroll-left
[       type]: Function
[  arguments]: filer-scroll-left &optional SECONDARY-WINDOW-P
[    package]: editor
[    seealso]: filer-scroll-right
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂčɃXN[܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-scroll-right
[       type]: Function
[  arguments]: filer-scroll-right &optional SECONDARY-WINDOW-P
[    package]: editor
[    seealso]: filer-scroll-left
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂĉEɃXN[܂B

  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-set-directory
[       type]: Function
[  arguments]: filer-set-directory DIRECTORY &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂĕ\fBNg DIRECTORY ɕύX܂B

  DIRECTORY          : fBNgw肵܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-set-file-mask
[       type]: Function
[  arguments]: filer-set-file-mask MASK &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂĕ\w肵܂B

  MASK               : \
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-set-text
[       type]: Function
[  arguments]: filer-set-text STRING
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
ʃt@C̃t@C̗ STRING Zbg܂B


filer-sort
[       type]: Function
[  arguments]: filer-sort ARG &optional SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂt@C̕\ύX܂B

  ARG                : \w肵܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-subscribe-to-reload
[       type]: Function
[  arguments]: filer-subscribe-to-reload PATH &optional SUB-DIRECTORY-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@Cɂ PATH \ĂEBhEXVA
ŐV̏Ԃɂ܂B

  PATH            : pXw肵܂
  SUB-DIRECTORY-P : PATH ̃TufBNgXVΏۂɂ邩ۂ
          nil         XVȂ
          non-nil     XV


filer-swap-windows
[       type]: Function
[  arguments]: filer-swap-windows
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
ʃt@CɂẴEBhEփtH[JXڂ܂B


filer-toggle-all-marks
[       type]: Function
[  arguments]: filer-toggle-all-marks &optional FILE-ONLY-P SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂČ݂̃fBNg̑SẴt@Cɂă}[NꂽԂ
ĂȂԂ𔽓]܂B

  FILE-ONLY-P        : fBNgΏۂɂ邩
             nil         fBNgΏۂɂ܂
             non-nil     t@CΏۂɂ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-toggle-mark
[       type]: Function
[  arguments]: filer-toggle-mark &optional FILE-ONLY-P SECONDARY-WINDOW-P
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\ʒũt@Cɂă}[NꂽԂƂĂȂ
Ԃ𔽓]܂B

  FILE-ONLY-P        : fBNgΏۂɂ邩
             nil         fBNgΏۂɂ܂
             non-nil     t@CΏۂɂ܂
  SECONDARY-WINDOW-P : ΏۂƂEBhEw肵܂
             nil         ݃ANeBuȃEBhE
             non-nil     ݃ANeBułȂEBhE


filer-viewer
[       type]: Function
[  arguments]: filer-viewer
[    package]: editor
[       file]: builtin.l
[    section]: t@C
[description]: 
t@CɂăJ[\ʒũt@C̍ŏ̕邱Ƃł܂B


fill
[       type]: Function
[  arguments]: fill SEQUENCE ITEM &key :start :end
[    package]: lisp
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCÊꂼITEMɒu܂BSEQUENCE͒u܂B

gpF
  ;;; V[PXāAύXĂ݂B
  (setq foo (make-sequence 'string 8 :initial-element #\a))
  => "aaaaaaaa"
  (fill foo #\b :start 3 :end 4)
  => "aaabaaaa"
  foo
  => "aaabaaaa"


fill-column
[       type]: Variable
[    package]: editor
[    seealso]: auto-fill-mode , set-fill-column , fill-prefix
[   referred]: fill-region , fill-region-as-paragraph
[       file]: fill.l
[    section]: |WV
[description]: 
lߍݎ̐܂Ԃ̌ێ܂B
l 72 łB

gp:
  ;;; l 62 ɕύXB
  (setq-default fill-column 62)

Jgobt@̒lύXꍇ́A֐ set-fill-column
gp܂B


fill-paragraph
[       type]: Function
[  arguments]: fill-paragraph
[    package]: editor
[    seealso]: fill-region-as-paragraph , fill-prefix
[   referred]: fill-region
[       file]: fill.l
[    section]: 
[description]: 
݂̒ilߍ݂܂B[ESC q]


fill-pointer
[       type]: Function
[  arguments]: fill-pointer VECTOR
[    package]: lisp
[    seealso]: array-has-fill-pointer-p , make-array , vector-pop , vector-push , length
[   referred]: vector , vector-push-extend
[       file]: builtin.l
[    section]: z
[description]: 
xN^iꎟzj VECTOR ̃tB|C^̈ʒuԂ܂B
VECTOR tB|C^ȂꍇAG[ƂȂ܂B
  
l:
  tB|C^́AxN^̌ڏ̍Ō̈ʒu߂܂B
  make-array ł͗^ꂽ DIMENSION ̔z܂A
  tB|C^^ꍇAʂɕ\ꂽ vector-pop Ȃǂ̊֐
  p肷̂̓tB|C^̈ʒu܂łƂȂ܂B

  ȂAaref g΃tB|C^ȍ~̗vfɂANZXł܂B
  ܂AtB|C^Ɋ֌WȂxN^{̒m肽ꍇ
  array-dimension i܂ array-dimensionsjg܂B


fill-region
[       type]: Function
[  arguments]: fill-region FROM TO
[    package]: editor
[    seealso]: fill-paragraph , fill-region-as-paragraph , fill-column
[       file]: fill.l
[    section]: [W
[description]: 
[W̊eiɑ΂Alߍ݂s܂B

gp:
  ;;; obt@Ŝlߍ
  (fill-region (point-min) (point-max))


fill-region-as-paragraph
[       type]: Function
[  arguments]: fill-region-as-paragraph FROM TO
[    package]: editor
[    seealso]: fill-paragraph , fill-region , fill-column
[       file]: fill.l
[    section]: [W
[description]: 
[W 1 ̒iƂċlߍ݂܂B
lߍ݌́Aϐ fill-column QƂ܂B


fill-region-hook
[       type]: Variable
[    package]: editor
[    seealso]: auto-fill-hook
[    section]: [W
[description]: 
fill-region/fill-paragraph̍ŌŎs܂B


filter-buffer
[       type]: Function
[  arguments]: filter-buffer COMMAND
[    package]: editor
[    seealso]: filter-region
[       file]: process.l
[    section]: vZX
[description]: 
obt@Ŝ̓eW͂ɂȂ COMMAND s܂B[C-x #]
COMMAND ̏I҂AIƃobt@̓e͈USďA
COMMAND ̕Wo͂obt@ɏo͂܂B


filter-region
[       type]: Function
[  arguments]: filter-region COMMAND &optional START END
[    package]: editor
[    seealso]: filter-buffer , call-process
[   referred]: execute-subprocess , make-process
[       file]: process.l
[    section]: vZX
[description]: 
[W̓eW͂ɂȂ COMMAND s܂B[C-x |]
COMMAND ̏I҂AIƃ[W̓e͈USďA
COMMAND ̕Wo͂[Wɂɏo͂܂B

[Ww肳ĂȂƂ́ACOMMANĎʂPɃJ[\ʒu
ɏo͂܂B


find
[       type]: Function
[  arguments]: find ITEM SEQUENCE &key :from-end :test :test-not :start :end :key
[    package]: lisp
[    seealso]: find-if , find-if-not , position , member , getf
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE ̒ ITEM Ƃ :test 𖞂̂΂Ԃ܂BȂ
nilԂ܂B

gpF
  ;;; Xg'aTĂ݂B
  (find 'a '(e c a b))
  => a


find-all-symbols
[       type]: Function
[  arguments]: find-all-symbols NAME
[    package]: lisp
[    seealso]: find-symbol
[       file]: package.l
[    section]: V{
[description]: 
󎚖 NAME ł悤ȃV{epbP[WT܂B
߂l͌V{̃XgłB

gpF
  (find-all-symbols "y")
  => (editor::y system::y lisp::y winapi::y)

  (find-all-symbols "system-root")
  => (system:system-root)

  (find-all-symbols "test")
  => (editor::test test :test lisp::test)


find-buffer
[       type]: Function
[  arguments]: find-buffer BUFFER-NAME
[    package]: editor
[    seealso]: find-name-buffer , get-file-buffer , get-buffer-create
[   referred]: create-new-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
OBUFFER-NAMEȃobt@݂΂̃obt@Ԃ܂B
݂ȂnilԂ܂B

gpF
  (find-buffer "*scratch*")
  => #<buffer: *scratch*>
  (find-buffer "*hoge hoge*")
  => nil


find-file
[       type]: Function
[  arguments]: find-file FILENAME &optional ENCODING NOMSG
[    package]: editor
[    seealso]: find-other-file , find-file-other-window , ed::find-file-internal , *prefix-args*
[   referred]: *auto-encoding-alist* , *auto-mode-parameter-alist* , *before-find-file-hook* , *find-file-auto-mode-function* , *find-file-file-not-found-hook* , *find-file-hooks* , *find-file-no-auto-encoding* , find-file-in-archive , find-file-read-only , insert-file , read-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
w肳ꂽt@CJAJgobt@̃t@Cɂ܂B [C-x C-f]
C^NeBuɌĂяoƃt@C~jobt@Őq˂܂B
vtBbNXA[MgtŌĂяoƁAt@C̕
R[hw肵ĊJƂł܂B

  FILENAME : t@CA܂̓t@C̃XgłB
  ENCODING : t@C̕R[hw肵܂B
  NOMSG    : non-nil ŃXe[^Xo[ɏ󋵂Ȃǂo͂ȂȂ܂B


find-file-in-archive
[       type]: Function
[  arguments]: find-file-in-archive ARCNAME FILENAME
[    package]: editor
[    seealso]: extract-archive , find-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
A[JCut@CWJĊJ܂B

  ARCNAME  : A[JCuw肵܂B
  FILENAME : WJt@Cw肵܂B

gpF
  (find-file-in-archive "C:/foo/bar.lzh" "hoge/fuga.txt")


find-file-other-window
[       type]: Function
[  arguments]: find-file-other-window FILENAME &optional ENCODING NOMSG
[    package]: editor
[    seealso]: find-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
w肳ꂽt@Cʂ̃EBhEŊJ܂B[C-x 4 f]


find-file-read-only
[       type]: Function
[  arguments]: find-file-read-only FILENAME &optional ENCODING NOMSG
[    package]: editor
[    seealso]: find-file
[   referred]: *find-file-hooks* , *find-file-read-only-hook*
[       file]: files.l
[    section]: t@CVXe
[description]: 
t@C FILENAME  read-only ŊJ܂B
FILENAME ̓t@C̃XgłĂ܂܂B

ł FILENAME ǂݍłobt@ꍇÃobt@ read-only ɐݒ肵܂B
FILENAME ǂݍłobt@Ȃꍇ find-file ƓlɃt@Cǂݍ݁A
obt@ read-only ɐݒ肵 *find-file-hooks* s܂B

̏ꍇŌ *find-file-read-only-hook* s܂B

  ENCODING : GR[fBOw肵܂B
  NOMSG    : non-nil ȂXe[^Xo[Ɍo߃bZ[W\܂B


find-if
[       type]: Function
[  arguments]: find-if PREDICATE SEQUENCE &key :from-end :start :end :key
[    package]: lisp
[    seealso]: find , find-if-not
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒PREDICATE𖞂̂΂Ԃ܂BȂnilԂ܂B


find-if-not
[       type]: Function
[  arguments]: find-if-not PREDICATE SEQUENCE &key :from-end :start :end :key
[    package]: lisp
[    seealso]: find , find-if
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒PREDICATE𖞂Ȃ̂΂Ԃ܂BȂ
nilԂ܂B


find-load-path
[       type]: Function
[  arguments]: find-load-path FILENAME
[    package]: lisp
[    seealso]: *load-path*
[       file]: builtin.l
[    section]: VXe
[description]: 
*load-path*t@C̃tpXԂ܂B

gpF
  (find-load-path "wip/ftp.l")
  => "C:/APPLICATIONS/XYZZY/lisp/wip/ftp.l"
  (find-load-path "siteinit.l")
  => "C:/APPLICATIONS/XYZZY/site-lisp/siteinit.l"


find-name-buffer
[       type]: Function
[  arguments]: find-buffer BUFFER-NAME
[    package]: editor
[    seealso]: find-buffer , get-file-buffer , create-new-buffer
[   referred]: buffer-name
[       file]: builtin.l
[    section]: obt@
[description]: 
OBUFFER-NAMEBUFFER-NAME<>ȃobt@̃XgԂ܂B
݂ȂnilԂ܂B

gpF
  (find-name-buffer " *TAGS*")
  => (#<buffer:  *TAGS*<2>> #<buffer:  *TAGS*>)
  (find-name-buffer "*hoge hoge*")
  => nil


find-other-file
[       type]: Function
[  arguments]: find-other-file FILENAME &optional ENCODING NOMSG
[    package]: editor
[    seealso]: *find-other-file-requires-file-name* , find-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
݂̃obt@Ďw肳ꂽt@CJ܂B[C-x C-v]

݊F
  muleɂ͂ȂB


find-package
[       type]: Function
[  arguments]: find-package NAME
[    package]: lisp
[    seealso]: pbP[W , list-all-packages , defpackage , delete-package
[   referred]: package-name
[       file]: builtin.l
[    section]: pbP[W
[description]: 
pbP[W𖼑OŌāÃpbP[WԂ܂B

  NAME : pbP[W̖O

gpF
  ;;; lispsystempbP[W擾Ă݂B
  (find-package "lisp")
  => #<package: lisp>
  (find-package "si")
  => #<package: system>

  ;;; "baz"Ƃ̃pbP[W݂͑Ȃ
  (find-package "baz")
  => nil


find-pseudo-frame
[       type]: Function
[  arguments]: find-pseudo-frame NAME
[    package]: editor
[    seealso]: select-pseudo-frame , selected-pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
݂̃t[̒疼O NAME ł̂TĕԂ܂B


find-symbol
[       type]: Function
[  arguments]: find-symbol STRING &optional PACKAGE
[    package]: lisp
[    seealso]: intern , pbP[W
[   referred]: find-all-symbols
[       file]: builtin.l
[    section]: pbP[W
[description]: 
pbP[WɃV{o^Ă邩𒲂ׂ܂B

  STRING  : V{̖O
  PACKAGE : pbP[W̖O

߂l͑lŕԂ܂B

  nil     V{ȂꍇnilԂ܂B
  nilȊO V{ꍇ͂̃V{̂܂ܕԂ܂B

gpF
  ;;; find-filefind-file-internalƂV{𒲂ׂĂ݂B
  (find-symbol "find-file" "lisp")
  => nil
     nil
  (find-symbol "find-file" "editor")
  => find-file
     :external
  (find-symbol "find-file-internal" "editor")
  => editor::find-file-internal
     :internal


find-text-attribute
[       type]: Function
[  arguments]: find-text-attribute TAG &key :start :end :from-end :test :test-not :key
[    package]: editor
[    seealso]: find-text-attribute-if , find-text-attribute-if-not , find-text-attribute-point
[   referred]: list-text-attributes , set-text-attribute
[       file]: builtin.l
[    section]: eLXg
[description]: 
set-text-attributeŎw肵^O܂B

(progn
  (set-text-attribute 1 6 'my-tag 1)
  (multiple-value-bind (from to tag)
      (find-text-attribute 'my-tag)
    (format t "~d, ~d, ~A" from to tag)))
==> 1, 6, my-tag

| 2. set-text-attribute ŁA͈͂ɓ tag w肵
|    Afind` ͈Ԑ擪ɋ߂̂ԂȂ(Ƃ낵
|    ƂȂ)̂łAԖڈȍ~擾邱Ƃ͂
|    ܂ł傤H

find-text-attribute TAG :start POS

ŁAPOS Ɍ݈ʒu+1^Ύ̂ԂĂ\łB
gƂȂ̂œǂ܂񂪁B

| 3. find-text-attribute  &key ́AӖĂ
|    ܂ł傤H

V[PXƓlɁA:test  :test-not ɂ͔r֐
^܂B܂A:key ɂ̓ANZX֐(?)^܂B
Ƃ΁Atag ̌`

  ("foo" bar)

łꍇA

  (find-text-attribute "foo" :test #'equal :key #'car)

ƂA

  (find-text-attribute 'bar :test #'eq :key #cadr)

Ō邱Ƃł\łBgƂȂ̂œ
ǂ܂񂪁B

:test-not ́A֐ nil Ԃꍇɐ^ƂȊO :
test ƓlłB:test  :test-not ͓Ɏw肷邱
Ƃ͂łAȗꍇ :test #'eql ^ꂽ
̂Ƃ܂B܂ :key ȗꍇ :key #'identity 
^ꂽ̂Ƃ܂(Ԃ)B


find-text-attribute-if
[       type]: Function
[  arguments]: find-text-attribute-if TEST &key :start :end :from-end :key
[    package]: editor
[    seealso]: find-text-attribute-if-not , find-text-attribute , find-text-attribute-point , set-text-attribute
[       file]: builtin.l
[    section]: eLXg
[description]: 
eLXĝA^O TEST 𖞂̂TAŏɌ̂Ԃ܂B
lŁAeLXg̊JnʒuEIʒuE^OԂ܂B

  :start     JnʒuiftHgł point-min?j
  :end       IʒuiftHgł point-max?j
  :from-end  납猟邩ǂ
  :key       TEST ɓnOɃ^OɓKp֐


find-text-attribute-if-not
[       type]: Function
[  arguments]: find-text-attribute-if-not TEST &key :start :end :from-end :key
[    package]: editor
[    seealso]: find-text-attribute-if , find-text-attribute , find-text-attribute-point , set-text-attribute
[       file]: builtin.l
[    section]: eLXg
[description]: 
eLXĝA^O TEST 𖞂Ȃ̂TAŏɌ̂Ԃ܂B
lŁAeLXg̊JnʒuEIʒuE^OԂ܂B

  :start     JnʒuiftHgł point-min?j
  :end       IʒuiftHgł point-max?j
  :from-end  납猟邩ǂ
  :key       TEST ɓnOɃ^OɓKp֐


find-text-attribute-point
[       type]: Function
[  arguments]: find-text-attribute-point POINT
[    package]: editor
[    seealso]: modify-text-attributes , find-text-attribute , delete-text-attribute-point
[   referred]: find-text-attribute-if , find-text-attribute-if-not , set-text-attribute
[       file]: builtin.l
[    section]: eLXg
[description]: 
POINT ̈ʒũeLXg̑𑽒lŕԂ܂B

  FROM          tꂽJnʒu
  TO            tꂽIʒu
  TAG           X̑ʂ^O
  FOREGROUND    F
  BACKGROUND    wiF
  BOLD          {[h
  UNDERLINE     t
  STRIKE-OUT    
  PREFIX        s
  EXTEND        s

gpF
  ;;; my-tagƂ^Oŗ̈ΐFɐݒ
  (set-text-attribute (point-min) (point-max) 'my-tag :foreground 2)
  => t
  ;;; J[\ʒuɃ^OΐԐF{[hɕύX
  (multiple-value-bind (from to tag foreground background bold underline strike-out prefix extend)
      (find-text-attribute-point 1)
    (when tag
      (modify-text-attributes tag ; foregroundboldȊO͂̂܂ܐݒ肷B
       :foreground 1              ; ԐFɐݒ
       :background background
       :bold t                    ; {[hɐݒ
       :underline underline
       :strike-out strike-out
       :prefix prefix
       :extend extend)))
  => t


first
[       type]: Function
[  arguments]: first LIST
[    package]: lisp
[    seealso]: car , nth
[   referred]: second
[       file]: list.l
[    section]: Xg
[description]: 
car̕ʖłB
S܂B

gpF
  ;;; carƓB
  (car '(1 2 3))
  => 1
  (first '(1 2 3))
  => 1
  (symbol-function 'car)
  => #<function: car>
  (symbol-function 'first)
  => #<function: car>
 
QlF
  ;;; list.l̒`
  (si:*fset 'first #'car)


first-error
[       type]: Function
[  arguments]: first-error &optional ARG WRAP
[    package]: editor
[    seealso]: next-error , *error-regexp-list*
[       file]: errors.l
[    section]: G[
[description]: 
grep*compilation*obt@ŎsƁAYsփWv\łB[F10]
Ȍ́Anext-error([F11], [C-x `])ƂŎXƊYsփWv\łB
eRpC̏o͌ʂɉăWv邱Ƃ\łB
܂ARpC̃G[o͂WɑΉĂȂĂA
*error-regexp-list*ύX邱ƂőΉ\ȏꍇ܂B


flet
[       type]: Special Form
[  arguments]: flet ({(NAME LAMBDA-LIST {declaration}* [doc-string] {FORM}*)}*) {FORM}*
[    package]: lisp
[    seealso]: labels , macrolet
[       file]: builtin.l
[    section]: ֐
[description]: 
[JȊ֐`ătH[]܂BtH[ flet 
`ꂽ֐́AOŒ`ꂽO̊֐D悳܂B
֐͓ɕ`ł܂B

ꂼ̒`@ defun ̂悤ɁAŏɊ֐A
Ƀp[^̃Xg(&optional, &rest, &key p[^g܂)A
optional declaration  docstringAčŌɃtH[Ƒ܂B

  (flet ((safesqrt (x) (sqrt (abs x)))) 
    ;; The safesqrt function is used in two places. 
    (safesqrt (apply #'+ (map 'list #'safesqrt longlist))))


float
[       type]: Function
[  arguments]: float NUMBER &optional OTHER
[    package]: lisp
[    seealso]: rationalize
[       file]: builtin.l
[    section]: l
[description]: 
Cӂ̌^̐l𕂓_^ɕϊ܂B

  (float 'NUMBER) == (coerce 'NUMBER 'single-float)

gpF
  ;;; integerfloatɕϊB
  (setq var 0)                  => 0
  (type-of var)                 => integer
  (setq var (float var))        => 0.0
  (type-of var)                 => single-float


floatp
[       type]: Function
[  arguments]: floatp OBJECT
[    package]: lisp
[    seealso]: numberp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTfloatȂtAȊOȂnilԂ܂B


floor
[       type]: Function
[  arguments]: floor NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: ceiling , truncate , round , ffloor
[   referred]: mod
[       file]: builtin.l
[    section]: l
[description]: 
NUMBER𕉂̖Ɋۂ߂܂B
DIVISORȗꍇɂNUMBERzȂő̐ɂȂ܂B

gpF  
  (floor 2.2)
  => 2
  (floor 2.8)
  => 2
  (floor -2.4)
  => -3  
  (multiple-value-list (floor 2.2))
  => (2 0.2)


fmakunbound
[       type]: Function
[  arguments]: fmakunbound SYMBOL
[    package]: lisp
[    seealso]: fboundp
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
w肳ꂽV{̊֐`̑܂B
ȍ~fboundpnilԂ悤ɂȂ܂BlƊ֐`͓̑ƗĂ
̂ŁAfmakunboundĂboundp̌ʂ͕ς܂B

gpF
  ;;; ֐`ւ̑Ă݂B
  (defun foo (x) (* x 3))       => foo
  (fboundp 'foo)                => t
  (fmakunbound 'foo)            => foo
  (fboundp 'foo)                => nil


focus-tool-bar
[       type]: Function
[  arguments]: focus-tool-bar
[    package]: editor
[       file]: builtin.l
[    section]: j[
[description]: 
^uo[ɃtH[JXڂ܂B^uo[TABƂŌ̃obt
@ɖ߂邱Ƃo܂B^uo[݂ȂƂ́AtH[JX͌̃ob
t@̂܂܂łB


following-char
[       type]: Function
[  arguments]: following-char
[    package]: editor
[    seealso]: preceding-char , char-after
[       file]: builtin.l
[    section]: eLXg
[description]: 
J[\ʒũLN^Ԃ܂B
obt@̖ɃJ[\ꍇɂ́A#\NULԂ܂B

gpF
  ;;; "s"''̏ɃJ[\ꍇ
  (following-char)
  => #\

  ;;; [EOF]ɃJ[\ꍇ
  (following-char)
  => #\NUL


format
[       type]: Function
[  arguments]: format DESTINATION CONTROL-STRING &rest ARGUMENTS
[    package]: lisp
[   referred]: message , minibuffer-message , msgbox , string
[       file]: builtin.l
[    section]: o
[description]: 
o͏ɏ]ďo͂܂B

  DESTINATION : o͐w肵܂B
        t       Wo͂ɏo
        nil     ƂČʂԂ
        fp      w̃Xg[ɏo

  CONTROL-STRING : ȉ̏o͎wqŐ`܂B
        ~A      AsciiiAXL[wjBprinc^CvŏóB
        ~S      S-ExpressioniSwjBprin1^CvŏóB
        ~%      sB~n%n̉s
        ~&      o̓Xg[słȂΉsBfresh-lineQƁB
        ~|      y[W
        ~~      Tildei`_wj
        ~s   sƂɑ󔒕𖳎
        ~T      Tabulatei^uwj
        ~*      argument𖳎
        ~?      IndirectioniԐڎwj
        ~D      10i
        ~B      Binaryi2iwj
        ~O      Octali8iwj
        ~X      Hexadecimali16iwj
        ~R      Radixiwj
        ~P      Plurali`wj
        ~C      Characteriwj
        ~F      Fixed-format floating-pointiŒ菬_`wj
        ~E      Exponential floating-pointiw`wj
        ~G      General floating-pointiʕ_wj
        ~$      Dollars floating-pointih_wj
        ~(      Case conversioniP[Xϊwj
        ~)      ~(
        ~[      Conditional expressioniIwj
        ~]      ~[
        ~{      Iterationiwj
        ~}      ~{
        ~^      Up and outi[Iwj

gp:
  ;;; 0tďo ("~[ŏ][,pfBO][,؂蕶]D")
  (format nil "~5,'0D" 4)
  => "00004"

  ;;; 3ƂɃJ}ŋ؂ďo
  (format nil "~:D" 1234567890)
  => "1,234,567,890"

  ;;; ŒጅJɂȂ悤ɋ󔒂ǉďo
  (format nil "~10A" "foo")
  => "       foo"
  (format nil "~10@A" "foo")
  => "foo       "

  ;;; P[Xϊ̗
  (format nil "~(~A~)" "FOO BAR")  ;Sď
  => "foo bar"
  (format nil "~:(~A~)" "foo bar") ;P̐擪̕啶
  => "Foo Bar"
  (format nil "~@(~A~)" "foo bar") ;擪̕啶
  => "Foo bar"
  (format nil "~:@(~A~)" "foo bar");Sđ啶
  => "FOO BAR"

  ;;; Ԑڎw̗
  (format nil "~? ~D" "[~A ~D]" '("foo" 2) 3)
  => "[foo 2] 3"
  (format nil "~@? ~D" "[~A ~D]" "foo" 2 3)
  => "[foo 2] 3"

  ;;; Iw̗
  (format nil "Windows ~[NT~;98~;95~]" 0)
  => "Windows NT"
  (format nil "Windows ~[NT~;98~;95~]" 1)
  => "Windows 98"
  ;ftHgl "~:;"
  (format nil "Windows ~[NT~;98~;95~:;3.1~]" 5)
  => "Windows 3.1"

  ;;; w̗
  ; "~{" ̓Xg
  (format nil "~{ ~A~}" '("dog" "cat" "pig"))
  => " dog cat pig"
  ; "~:{"  ̓Xg̃Xg
  (format nil "~:{[~A ~D]~}" '(("a" 1) ("b" 2) ("c" 3)))
  => "[a 1][b 2][c 3]"
  ; "~@{" c̈XgƂėp
  (format nil "~@{[~A ~D]~}" "a" 1 "b" 2 "c" 3)
  => "[a 1][b 2][c 3]"
  ; "~@:{" ̃XgXgƂėp
  (format nil "~:@{[~A ~D]~}" '("a" 1) '("b" 2) '("c" 3))
  => "[a 1][b 2][c 3]"

  ;;; [Iw̗
  ;ȂΏI
  (format nil "Done.~^ ~D warning~:P.~^ ~D error~:P.")
  => "Done."
  (format nil "Done.~^ ~D warning~:P.~^ ~D error~:P." 3)
  => "Done. 3 warnings."
  (format nil "Done.~^ ~D warning~:P.~^ ~D error~:P." 3 5)
  => "Done. 3 warnings. 5 errors."

  ;;; wƃ[Iw
  ;Xg̒̈Ȃ "~{" ŕ
  (format nil "~:{/~S~^ ...~}" '((hot dog) (hamburger) (ice cream) (french fries)))
  => "/hot .../hamburger/ice .../french ..."
  ;XgIȂ炻 ":{" ŜI
  (format nil "~:{/~S~:^ ...~}" '((hot dog) (hamburger) (ice cream) (french fries)))
  => "/hot .../hamburger .../ice .../french"
  ;Xg̒̈ȂΑŜI
  (format nil "~:{/~S~#:^ ...~}" '((hot dog) (hamburger) (ice cream) (french fries)))
  => "/hot .../hamburger"

  ;;; 16iformat̏
  (format nil "~2,'0x" 10)
  => "0a"
  (format nil "~:@(~2,'0x~)" 10)
  => "0A"


format-date
[       type]: Function
[  arguments]: format-date S FMT &optional UNIVERSAL-TIME
[    package]: editor
[    seealso]: decode-universal-time , format-date-string
[       file]: timestmp.l
[    section]: tE
[description]: 
ɏ]Đ`Xg[ɏo͂܂B

  S              : o̓Xg[w肵܂B
                   format̗ltnilw肷邱Ƃ͂ł܂B
  FMT            : tp̏w肵܂B
                   tp̏format-date-stringQƂĉB
  UNIVERSAL-TIME : o͂jo[T^C`Ŏw肵܂B
                   ȗ͌ݎg܂B


format-date-string
[       type]: Function
[  arguments]: format-date-string FMT &optional UNIVERSAL-TIME
[    package]: editor
[    seealso]: decode-universal-time , format-date
[   referred]: encode-universal-time , file-write-time , get-decoded-time , get-universal-time , set-file-write-time
[       file]: timestmp.l
[    section]: tE
[description]: 
ɏ]Đ`𕶎ƂĕԂ܂B

  FMT            : tp̏w肵܂B
  UNIVERSAL-TIME : o͂jo[T^C`Ŏw肵܂B
                   ȗ͌ݎg܂B

gpF
  (format-date-string "%y/%m/%d %H:%M:%S" 3112500590)
  => "98/08/19 16:29:50"
  (format-date-string "%yN%#m%#d(%v)")
  => "99N1110()"

tp̏F
  ɂĂ timestmp.l QƂĉBȉ͔łB 
  a: Z`̗j
  A: `̗j
  b: Z`̌
  B: `̌
  d: (00`31)                 # (0`31)
  e: a̔N(01`)             # (1`)
  E: a̔N(, 02`)         # (, 2`)
  g: (,吳,a,)  # (,,,)
  G: (M, T, S, H)
  H: (00`23)                 # (0`23)
  I: 12Ԃ̎(01`12)         # (1`12)
  i: Internet Time(000`999)
  m: (01`12)                 # (1`12)
  M: (00`59)                 # (0`59)
  p: ߑO/ߌ
  P: AM/PM                      # am/pm
  S: b(00`59)                 # (0`59)
  v: j({)
  y: N(2)
  Y: N(4)
  z: ^C][(JST-9)
  Z: ^C][(+0900)        # (+09:00)


format-drive
[       type]: Function
[  arguments]: format-drive &optional DRIVE QUICK
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
hCutH[}bg܂B

  DRIVE : hCu𕶎Ŏw肵܂B

gpF
  (format-drive #\a t)
  => nil


forward-char
[       type]: Function
[  arguments]: forward-char &optional (ARG 1)
[    package]: editor
[    seealso]: backward-char , *prefix-args*
[   referred]: forward-word
[       file]: builtin.l
[    section]: |WV
[description]: 
w肳ꂽEɈړ܂BsΎsɈړ܂B
[C-f], [Right]

݊F 
  Emacsł͈ړłȂꍇG[܂Bxyzzył̓G[͔
  ܂B̑AƂ tAȂ nil Ԃ܂B


forward-line
[       type]: Function
[  arguments]: forward-line &optional (N 1)
[    package]: editor
[    seealso]: previous-line , forward-virtual-line , next-line , *prefix-args*
[   referred]: backward-line
[       file]: builtin.l
[    section]: |WV
[description]: 
NsɕsɈړ܂B
ړ̑O goal-column ۑ܂B

߂l:
  ړsԂ܂BSړłȂƂ nil łB


forward-list
[       type]: Function
[  arguments]: forward-list &optional ARG NO-ERRORS
[    package]: editor
[    seealso]: forward-sexp , up-list , backward-list
[       file]: builtin.l
[    section]: |WV
[description]: 
ÕXg̏I[ֈړ܂B[ESC C-n]
  
  gp:
    ;;; forward-list ňړ
    ;;; 
    ;;; ^ Ń|Cgʒu\
    (let ((hoge '(1 2))) (foo hoge) ...)
      ^ ŏ͂̈ʒu
    (let ((hoge '(1 2))) (foo hoge) ...)
                        ^ 
    (let ((hoge '(1 2))) (foo hoge) ...)
                               ^


forward-page
[       type]: Function
[  arguments]: forward-page &optional (ARG 1)
[    package]: editor
[    seealso]: backward-page
[   referred]: mark-page
[       file]: page.l
[    section]: |WV
[description]: 
Ỏy[W܂ňړ܂B[C-x []
y[Wꍇ̓obt@̖Ɉړ܂B
ʂɂ͐䕶form feedPƂłsŉy[W\܂B

  ARG : y[Ww肵܂BftHg 1 łB
        ̒l̏ꍇAtɈړ܂B


forward-paragraph
[       type]: Function
[  arguments]: forward-paragraph &optional (ARG 1)
[    package]: editor
[    seealso]: backward-paragraph
[       file]: paragrph.l
[    section]: |WV
[description]: 
J[\i̖Ɉړ܂B[ESC }]


forward-sexp
[       type]: Function
[  arguments]: forward-sexp &optional ARG NO-ERRORS
[    package]: editor
[    seealso]: backward-sexp , up-list
[   referred]: forward-list
[       file]: builtin.l
[    section]: obt@
[description]: 
lisp-modeS1i߂܂B[ESC C-f]

gpF
  (forward-sexp)


forward-virtual-line
[       type]: Function
[  arguments]: forward-virtual-line &optional (ARG 1)
[    package]: editor
[    seealso]: forward-line
[   referred]: backward-virtual-line
[       file]: builtin.l
[    section]: |WV
[description]: 
\sŎsֈړ܂B


forward-word
[       type]: Function
[  arguments]: forward-word &optional (ARG 1)
[    package]: editor
[    seealso]: backward-word , forward-char
[   referred]: capitalize-word , kill-word , mark-word , next-word
[       file]: builtin.l
[    section]: |WV
[description]: 
J[\O̒PɈړ܂B[ESC f]


fourth
[       type]: Function
[  arguments]: fourth X
[    package]: lisp
[    seealso]: cadddr , nth
[       file]: list.l
[    section]: Xg
[description]: 
cadddr ̕ʖłBS܂B


fresh-line
[       type]: Function
[  arguments]: fresh-line &optional OUTPUT-STREAM
[    package]: lisp
[    seealso]: terpri
[       file]: builtin.l
[    section]: o
[description]: 
OUTPUT-STREAM s̐擪ł͂ȂƂs (#\LFD) o͂܂B


fround
[       type]: Function
[  arguments]: fround NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: round
[       file]: builtin.l
[    section]: l
[description]: 
round Ɠł_Ԃ܂B


ftruncate
[       type]: Function
[  arguments]: ftruncate NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: truncate
[       file]: builtin.l
[    section]: l
[description]: 
truncateƓł_Ԃ܂B


funcall
[       type]: Function
[  arguments]: funcall FN &rest ARGUMENTS
[    package]: lisp
[    seealso]: apply
[   referred]: *auto-fill-hook
[       file]: builtin.l
[    section]: ]
[description]: 
w肵Ċ֐\V{֐Ăяo܂B
FNɂ͊֐\V{ł֐ł\܂B̌ÓIɒ܂
Ȃꍇɂfuncall͌ĂȂ̂ŁȀꍇɂapplyg܂B

gpF
  ;;; car낢ȌĂяołB
  (car '(a b c))                => a
  (funcall 'car '(a b c))       => a
  (funcall #'car '(a b c))      => a

ӁF
  funcallapply̗lɊ֐ƂW̊֐́Acarlambda̎
  V{IɊ֐ɕϊ܂B]āA֐\V{ł֐
  ̂̂ł\܂B


function
[       type]: Special Form
[  arguments]: function FN
[    package]: lisp
[    seealso]: symbol-function , quote
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
֐̊֐`Ԃ܂B#'ƓłB

gpF
  ;;; #'functionsymbol-functionׂĂ݂B
  (defun foo (x) (* x 3))
  => foo
  #'foo
  => #<lexical-closure: foo>
  (function foo)
  => #<lexical-closure: foo>
  (symbol-function 'foo)
  => #<lexical-closure: foo>


functionp
[       type]: Function
[  arguments]: functionp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT֐ȂtAȊOȂnilԂ܂B


gc
[       type]: Function
[  arguments]: gc &optional NO-MESSAGE
[    package]: lisp
[       file]: builtin.l
[    section]: ̑
[description]: 
ijS~W߂܂B


gcd
[       type]: Function
[  arguments]: gcd &rest INTEGERS
[    package]: lisp
[    seealso]: lcm
[       file]: builtin.l
[    section]: l
[description]: 
̍ő񐔂Ԃ܂B

gpF
  (gcd 91 70)
  => 7
  (gcd 63 -42 35)
  => 7
  (gcd -3)
  => -3
  (gcd 35 8)
  => 1


gensym
[       type]: Function
[  arguments]: gensym &optional X
[    package]: lisp
[    seealso]: *gensym-counter* , make-symbol , unintern , uninterned
[   referred]: gentemp , symbol-package
[       file]: evalmacs.l
[    section]: V{
[description]: 
uninterned ȃV{𐶐܂B󎚖 G ̌ *gensym-counter* 
lȂ̂łB

 X w肷ƁA
  X ̂Ƃ *gensym-counter* ̑ X ̒lg܂B
  X ̂Ƃ "G" ̑ X ̒lg܂B


gentemp
[       type]: Function
[  arguments]: gentemp &optional (PREFIX t) (PACKAGE *package*)
[    package]: lisp
[    seealso]: gensym , intern
[       file]: evalmacs.l
[    section]: V{
[description]: 
intern ꂽV{𐶐܂
PACKAGE  intern ꂽ PREFIX ƓJE^ȂV{Ԃ܂

KՓ˂ȂV{𐶐܂B


get
[       type]: Function
[  arguments]: get SYMBOL INDICATOR &optional DEFAULT
[    package]: lisp
[    seealso]: symbol-plist , remprop
[       file]: builtin.l
[    section]: V{
[description]: 
V{̃vpeBԂ܂B

  SYMBOL    : vpeBԂV{
  INDICATOR : vpeB̃CWP[^

gpF
  ;;; V{ɃvpeBݒ肵Ă݂B
  (get 'clyde 'species)                         => nil 
  (setf (get 'clyde 'species) 'elephant)        => elephant 
  (get 'clyde 'species)                         => elephant

  ;;; ֐̐擾Ă݂B
  (defun foo (x) "increment" (1+ x))            => foo
  (get 'foo 'lisp::function-documentation)      => "increment"


get-alternate-file-buffer
[       type]: Function
[  arguments]: get-alternate-file-buffer FILENAME &key (:test #'equalp)
[    package]: editor
[    seealso]: get-buffer-alternate-file-name , set-buffer-alternate-file-name
[       file]: buffer.l
[    section]: obt@
[description]: 
t@C̕ʖ FILENAME ł悤ȃobt@Ԃ܂B


get-buffer-alternate-file-name
[       type]: Function
[  arguments]: get-buffer-alternate-file-name &optional BUFFER
[    package]: editor
[    seealso]: set-buffer-alternate-file-name
[   referred]: get-alternate-file-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@BUFFERɐݒ肳ꂽt@C̕ʖ擾܂B


get-buffer-create
[       type]: Function
[  arguments]: get-buffer-create NAME
[    package]: editor
[    seealso]: create-new-buffer , find-buffer , new-file , switch-to-buffer , obt@̓\
[   referred]: buffer-name
[       file]: buffer.l
[    section]: obt@
[description]: 
w肵Õobt@Ԃ܂BOw肵܂AÕobt@
ɂ΂Ԃ܂Bcreate-new-bufferŐV܂B

switch-to-bufferǂ܂Aswitch-to-buffer
get-buffer-createpĎĂ܂B

  NAME : obt@̖O

gpF
  ;;; *calc*Ȃ΍쐬B
  (get-buffer-create "*calc*")
  => #<buffer: *calc*>


get-buffer-file-name
[       type]: Function
[  arguments]: get-buffer-file-name &optional BUFFER
[    package]: editor
[    seealso]: set-buffer-file-name , get-file-buffer
[   referred]: *save-buffer-no-filenames-hook*
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@QƂĂt@C̃tpXԂ܂B
t@CQƂĂȂnilԂ܂B

  BUFFER : t@C̃tpXԂobt@w肵܂B

gpF
  ;;; Jgobt@̃t@C̃tpXԂ܂B
  (get-buffer-file-name)
  => "C:/xyzzy/site-lisp/xmldoc/reference.xml"


get-buffer-window
[       type]: Function
[  arguments]: get-buffer-window BUFFER &optional START-WINDOW
[    package]: editor
[    seealso]: window-buffer
[   referred]: set-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
obt@\ĂEBhEԂ܂Bobt@̃EBh
Eɕ\Ă܂̂ŁASTART-WINDOW珇ԂɒTn߂܂B
ݕ\ĂȂobt@nilԂ܂B

  BUFFER       : obt@
  START-WINDOW : n߂EBhE

gpF
  ;;; window-buffergĂ݂B
  (selected-buffer)
  => #<buffer: *scratch*>
  (window-buffer (get-buffer-window (selected-buffer)))
  => #<buffer: *scratch*>


get-clipboard-data
[       type]: Function
[  arguments]: get-clipboard-data
[    package]: editor
[    seealso]: copy-to-clipboard , clipboard-empty-p
[       file]: builtin.l
[    section]: VXe
[description]: 
Nbv{[h̓e𕶎ƂĎo܂B


get-decoded-time
[       type]: Function
[  arguments]: get-decoded-time
[    package]: lisp
[    seealso]: decode-universal-time , format-date-string
[       file]: builtin.l
[    section]: tE
[description]: 
݂̎Ԃ𑽒lŕԂ܂B
  
  (get-decoded-time) == (decode-universal-time (get-universal-time))
  
gpF
  (multiple-value-list (get-decoded-time))
  => (55 35 14 17 11 1999 2 nil -9)


get-disk-usage
[       type]: Function
[  arguments]: get-disk-usage DIRECTORY &optional RECURSIVEP
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
w肳ꂽfBNg̗eʂ擾܂B

  DIRECTORY  : 擾fBNgw肵܂B
  RECURSIVEP : TufBNgċAIɃ`FbN邩w肵܂B

߂l͑lŕԂ܂B

  1 ubNTCYioCgj
  2 SfBXNeʁioCgj
  3 󂫃fBXNeʁioCgj
  4 ubNPʂ̍vioCgj
  5 t@CTCYPɉZvioCgj
  6 ׂfBNǧ
  7 ׂt@Č

gpF
  (defun my-folder-size (my-dir)
    (interactive "Dfolder name: ")
    (let (my-dir-list (my-total-size  0))
      (setq my-dir-list (directory my-dir
                                   :wile "*.*"
                                   :absolute t
                                   :file-only t
                                   :recursive t
                                   :show-dots nil))
      (dolist (f my-dir-list)
        (setq my-total-size (+ my-total-size (file-length f))))
      (msgbox (format nil "tH_̎gpeʂ́A~d oCgłB"
                      my-total-size))))


get-dispatch-macro-character
[       type]: Function
[  arguments]: get-dispatch-macro-character DISP-CHAR SUB-CHAR &optional READTABLE
[    package]: lisp
[    seealso]: make-dispatch-macro-character , set-dispatch-macro-character
[       file]: builtin.l
[    section]: o
[description]: 
fBXpb`}N擾܂B
SUB-CHAR ͑啶ʂ܂B

DISP-CHAR fBXpb`}NłȂ΃G[ƂȂ܂B


get-file-attributes
[       type]: Function
[  arguments]: get-file-attributes PATHNAME
[    package]: editor
[    seealso]: get-file-info
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@C̑Ԃ܂Bt@CTCYŏIXVȂǂ̏ꊇĎ
ꍇɂ́Aget-file-infogp܂傤B

  PATHNAME : 擾t@Cw肵܂B

߂l͈ȉ̒l̍vŕ\܂B

  ed::*file-attribute-readonly*   : ǂݎp
  ed::*file-attribute-hidden*     : Bt@C
  ed::*file-attribute-system*     : VXet@C
  ed::*file-attribute-directory*  : fBNg
  ed::*file-attribute-archive*    : A[JCu
  ed::*file-attribute-compressed* : k

gpF
  ;;; c:\autoexec.bat̑擾Ă݂BA[JCuɂȂĂ̂
  ;;; ed::*file-attribute-archive*Ƃ̘_ς0ȊOɂȂB
  (get-file-attributes "c:/autoexec.bat")
  => 32
  (= (get-file-attributes "c:/autoexec.bat") ed::*file-attribute-archive*)
  => t


get-file-buffer
[       type]: Function
[  arguments]: get-file-buffer FILENAME
[    package]: editor
[    seealso]: get-buffer-file-name
[   referred]: create-file-buffer , find-buffer , find-name-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
t@C\Ăobt@Ԃ܂B
ȂnilԂ܂B

gpF  
  (get-file-buffer "not-documented.xml")
  => #<buffer: not-documented.xml>


get-file-info
[       type]: Function
[  arguments]: get-file-info PATHNAME
[    package]: editor
[   referred]: get-file-attributes
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@C̑܂Ƃ߂Ď擾܂BEŏIXVETCYEZ
ÕXǧ`łB͈ȉ̊ŁB
  ed::*file-attribute-readonly*
  ed::*file-attribute-hidden*
  ed::*file-attribute-system*
  ed::*file-attribute-directory*
  ed::*file-attribute-archive*
  ed::*file-attribute-compressed*

gpF
  (setq i (get-file-info (si:system-root)))
  => (16 3208385786 0 "XYZZY")
  (logand (car i) ed::*file-attribute-directory*)
  => 16
  (logand (car i) ed::*file-attribute-hidden*)
  => 0
  (format-date-string "%y/%m/%d %H:%M:%S" (cadr i))
  => "01/09/02 11:16:26"


get-image-size
[       type]: Function
[  arguments]: get-image-size FILENAME
[    package]: editor
[       file]: imagehdr.l
[    section]: ̑
[description]: 
w肳ꂽ摜t@C̏cEEtH[}bg擾邱Ƃ\łB

gpF
  ;;; image^O}Ă݂
  (require "imagehdr")
  (defun html-write-image-tag (file)
    (interactive "fJPEG, GIF, PNG : ")
    (multiple-value-bind (width height fmt)
      (get-image-size file)
      (insert (format nil "<IMG SRC=\"~a\" WIDTH=~d HEIGHT=~d>" file width height))))


get-ime-mode
[       type]: Function
[  arguments]: get-ime-mode
[    package]: editor
[    seealso]: toggle-ime
[       file]: builtin.l
[    section]: L[}bv
[description]: 
IMEON/OFFԂԂ܂B

߂l͈ȉ̒ʂł
  t   ϊ[h
  nil ړ̓[h


get-internal-real-time
[       type]: Function
[  arguments]: get-internal-real-time
[    package]: lisp
[    seealso]: internal-time-units-per-second , si:performance-counter
[       file]: builtin.l
[    section]: tE
[description]: 
IGetTickCountĂяoĂ܂BGetTickCountMSDNɂ
VXeŇoߎԂA~bimsjPʂŎ擾܂B
̎Ԃ́AVXe^C}̕\ɂ鐧󂯂܂B
VXe 49.7 ԘAē삳ƁAoߎԂ 0 ɖ߂܂B

łB

gpF  
  ;;ʂɌĂяoBAĂ
  (get-internal-real-time)
  =>984001406

  ;;tŋNԂ\
  (let ((tick (get-internal-real-time))
        d h m s ms)
    (multiple-value-setq (tick ms)
        (truncate tick 1000))
    (multiple-value-setq (tick s)
        (truncate tick 60))
    (multiple-value-setq (tick m)
        (truncate tick 60))
    (multiple-value-setq (d h)
        (truncate tick 24))
    (format nil "PCNoߎ day ~D time ~2,'0D:~2,'0D:~2,'0D.~3,'0D" d h m s ms))
  =>"PCNoߎ day 11 time 09:20:04.578"


get-local-window-flags
[       type]: Function
[  arguments]: get-local-window-flags WINDOW-OR-BUFFER
[    package]: editor
[    seealso]: set-local-window-flags
[       file]: builtin.l
[    section]: EBhE
[description]: 
[Jɐݒ肳ꂽEBhEtȌԂ𑽒lŕԂ܂B

@ WINDOW-OR-BUFFER : obt@EBhÊꂩw肵܂B

߂l
   ڂ̓[J t ɐݒ肳ꂽtO
   ڂ̓[J nil ɐݒ肳ꂽtO

gp :
  (progn
    (set-local-window-flags (selected-window) *window-flag-line-number* t)
    (set-local-window-flags (selected-window) *window-flag-ruler* t)
    (set-local-window-flags (selected-window) *window-flag-vscroll-bar* nil)
    (get-local-window-flags (selected-window)))
  =>
  3
  32


get-macro-character
[       type]: Function
[  arguments]: get-macro-character CHAR &optional READTABLE
[    package]: lisp
[    seealso]: set-macro-character
[       file]: builtin.l
[    section]: o
[description]: 
}N CHAR Ɋ蓖ĂĂ֐Ԃ܂B}NłȂ
ꍇ nil Ԃ܂B
܂A}Nłꍇɂ͓Ԗڂ̖߂lƂ CHAR  
non-terminating ǂԂ܂B

gpF
  ;;; #  non-terminating macro character
  (get-macro-character #\#)
  => system:|#-reader|
  => t
  ;;; '  terminating macro character
  (get-macro-character #\')
  => system:|'-reader|
  => nil
  ;;; A ̓}Nł͂Ȃ
  (get-macro-character #\A)
  => nil


get-menu
[       type]: Function
[  arguments]: get-menu MENU TAG-OR-POSITION &optional TAG-OR-POSITION-P
[    package]: editor
[    seealso]: current-menu , get-menu-position , define-menu
[   referred]: add-menu-item , add-menu-separator , insert-menu-item , insert-menu-separator
[       file]: builtin.l
[    section]: j[
[description]: 
w肳ꂽj[A^O܂͈ʒuŌj[擾܂B

  TAG-OR-POSITION   : ^O͈ʒuw肵܂B
  TAG-OR-POSITION-P : TAG-OR-POSITION̈^OƂĉ߂邩ʒu
                      ĉ߂邩߂܂B
           nil     TAG-OR-POSITION̓^O\V{
           non-nil TAG-OR-POSITION͈ʒu\l
gpF
  (get-menu *app-menu* 3 t)


get-menu-position
[       type]: Function
[  arguments]: get-menu-position MENU TAG
[    package]: editor
[    seealso]: get-menu , define-menu
[   referred]: add-menu-separator , insert-menu-separator
[       file]: builtin.l
[    section]: j[
[description]: 
j[̒^ÖʒuĕԂ܂B

  MENU : 郁j[w肵܂B
  TAG  : ^Ow肵܂B

ȂꍇɂnilԂ܂B
ꍇɂ͂̈ʒuƂ܂ރj[Ԃ܂B


get-next-buffer
[       type]: Function
[  arguments]: get-next-buffer &optional BUFFER REVERSE TAB-ORDER INTERNAL
[    package]: editor
[    seealso]: next-buffer , buffer-list
[       file]: builtin.l
[    section]: obt@
[description]: 
̃obt@Ԃ܂B

  BUFFER    : 
       :top     擪̃obt@Ԃ܂B
       :bottom  Ō̃obt@Ԃ܂B
       obt@ w肵obt@̎̃obt@Ԃ܂B
  REVERSE   : non-nil ȂÕobt@Ԃ܂B
  TAB-ORDER : nil Ȃobt@̐ŁAnon-nil Ȃobt@^u
              ̃obt@Ԃ܂B
  INTERNAL  : non-nil Ȃ\obt@܂߂Ď̃obt@Ԃ܂B


get-properties
[       type]: Function
[  arguments]: get-properties PLACE INDICATOR-LIST
[    package]: lisp
[    seealso]: getf
[       file]: builtin.l
[    section]: V{
[description]: 
2Ԗڂ̈XgɂȂĂgetfłB
vƑlŒlԂ܂B

gpF
  ;;; get-propertiesŒl擾Ă݂B
  (get-properties '(ind1 10 ind2 20 ind3 30) '(ind2))
  => ind2
     20
     (ind2 20 ind3 30)


get-selection-type
[       type]: Function
[  arguments]: get-selection-type
[    package]: editor
[    seealso]: set-selection-type , start-selection
[   referred]: pre-selection-p
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̑IԂԂ܂B

  nil   IȂA
  1     s[hI
  2     [hI
  3     `I


get-short-path-name
[       type]: Function
[  arguments]: get-short-path-name PATHNAME
[    package]: lisp
[    seealso]: truename
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAME8.3`ł̃pXԂ܂B
gpF
  (setq a (merge-pathnames "xyzzy.exe" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.exe"

  (get-short-path-name a)
  =>"C:/APPLIC~2/xyzzy/xyzzy.exe"


get-special-folder-location
[       type]: Function
[  arguments]: get-special-folder-location PLACE
[    package]: editor
[    seealso]: get-windows-directory , get-system-directory
[       file]: builtin.l
[    section]: VXe
[description]: 
낢ȃtH_ւ̃pXԂ܂B

  PLACE : tH_̎ނw肵܂B
    :start-menu
    :send-to
    :desktop
    :personal
    :programs
    :recent
    :startup
    :templates

QlF
  WindowsAPIGetSpecialFolderLocation


get-system-directory
[       type]: Function
[  arguments]: get-system-directory
[    package]: editor
[    seealso]: get-windows-directory , get-special-folder-location
[       file]: builtin.l
[    section]: VXe
[description]: 
WindowsVXetH_܂ł̃pXԂB

gpF
  (get-system-directory)
  => "C:/WINDOWS/System32/"


get-universal-time
[       type]: Function
[  arguments]: get-universal-time
[    package]: lisp
[    seealso]: decode-universal-time , format-date-string , file-write-time
[       file]: builtin.l
[    section]: tE
[description]: 
݂̎ԂԂ܂B

gpF
  (get-universal-time)
  => 3151806404


get-window-handle
[       type]: Function
[  arguments]: get-window-handle &optional WINDOW
[    package]: editor
[       file]: builtin.l
[    section]: VXe
[description]: 
w肳ꂽEBhẼnhԂ܂B

  WINDOW : nhԂEBhEw肵܂B

gpF
  ;;; J[\EBhẼnhԂ܂B
  (get-window-handle (selected-window))


get-window-line
[       type]: Function
[  arguments]: get-window-line &optional WINDOW
[    package]: editor
[    seealso]: window-lines , refresh-screen
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhEł̃J[\̕\sԂ܂B
EBhËԏ̕\sɃJ[\ꍇ 0 Ԃ܂B
݂̃J[\ʒu𐳊mɓ邽߁As擾Oɉʕ\
XV܂B

  WINDOW : EBhEw肵܂B
           w肵Ȃ (selected-window) g܂B


get-window-start-line
[       type]: Function
[  arguments]: get-window-start-line &optional WINDOW
[    package]: editor
[    seealso]: current-virtual-line-number , current-line-number
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE̐擪s\sŉsڂԂ܂B

⑫F
  ǂꍇɋN肦̂słAEBhEɃobt@֘At
  ĂȂꍇ nil Ԃ܂B


get-windows-directory
[       type]: Function
[  arguments]: get-windows-directory
[    package]: editor
[    seealso]: get-system-directory , get-special-folder-location
[       file]: builtin.l
[    section]: VXe
[description]: 
WindowstH_ւ̃pXԂ܂B

gpF
  (get-windows-directory)
  => "C:/WINDOWS/"


getf
[       type]: Function
[  arguments]: getf PLACE INDICATOR &optional DEFAULT
[    package]: lisp
[    seealso]: get-properties , symbol-plist
[   referred]: find , member
[       file]: builtin.l
[    section]: V{
[description]: 
CWP[^ƒl̃XgACWP[^Ɉvl擾܂B

  (get x y) == (getf (symbol-plist x) y)

gpF
  ;;; p͖getfgĎ擾Ă݂B
  (getf '(ind1 10 ind2 20 ind3 30) 'ind2)
  => 20


gethash
[       type]: Function
[  arguments]: gethash KEY HASH-TABLE &optional DEFAULT
[    package]: lisp
[    seealso]: gethash-region , maphash , make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[u̒L[v̂Ԃ܂B

  KEY        : L[w肵܂B
  HASH-TABLE : nbVe[uw肵܂B

gpF
  (setq hash-table (make-hash-table))
  => #<hash table>
  (gethash 'a hash-table)
  => nil
  (setf (gethash 'a hash-table) 1)
  => 1
  (gethash 'a hash-table)
  => 1

  (setq h (make-hash-table :test #'equalp))
  (setf (gethash "body" h) '(a b c))
  (gethash "BODY" h)


gethash-region
[       type]: Function
[  arguments]: gethash-region FROM TO HASHTABLE &optional DEFAULT
[    package]: editor
[    seealso]: gethash
[       file]: builtin.l
[    section]: nbV
[description]: 
[W̕nbVe[u擾܂B
(buffer-substring FROM TO)Ă(gethash ... HASHTABLE)悤Ȃ̂łB


global-set-key
[       type]: Function
[  arguments]: global-set-key KEY COMMAND
[    package]: editor
[    seealso]: global-unset-key , define-key , local-set-key , undefined , *global-keymap* , L[\gp\
[   referred]: BS  C-h ɕʁX̋@\蓖Ăɂ́H
[       file]: keymap.l
[    section]: L[}bv
[description]: 
O[oȃL[}bvɃL[o^܂B

gpF
 (global-set-key #\C-r          'previous-page)
 (global-set-key #\S-Left       'selection-backward-char)
 (global-set-key #\S-C-Left     'selection-backward-word)


global-unset-key
[       type]: Function
[  arguments]: global-unset-key KEY
[    package]: editor
[    seealso]: global-set-key
[       file]: keymap.l
[    section]: L[}bv
[description]: 
O[oȃL[}bṽL[̊蓖Ă܂B

gpF
  ;;; global-set-keyŊ蓖ĂL[Ă݂B
  (global-set-key #\C-r 'previous-page)
  => t
  (global-unset-key #\C-r)
  => t


go
[       type]: Special Form
[  arguments]: go TAG
[    package]: lisp
[    seealso]: tagbody , prog
[       file]: builtin.l
[    section]: \
[description]: 
tagbody  prog ̒Ŏw肳ꂽ^OփWv܂B

gp:
  ;;; dotimes ̃[v tagbody  go ŏĂ݂
  (let ((x 0) (sum 0))
    (tagbody
      start
      (setq sum (+ sum x)
            x (1+ x))
      (if (<= x 10) (go start)))
    sum)
  => 55


goal-column
[       type]: Function
[  arguments]: goal-column
[    package]: editor
[    seealso]: set-goal-column
[   referred]: next-line
[       file]: builtin.l
[    section]: |WV
[description]: 
݂̃S[J擾܂B
[xyzzy:06371] ̃XbhƁAsave-excursionŃS[J
Ȃ͎̂dl̂悤łB


goto-bol
[       type]: Function
[  arguments]: goto-bol
[    package]: editor
[    seealso]: goto-eol , goto-virtual-bol
[   referred]: goto-line
[       file]: builtin.l
[    section]: |WV
[description]: 
sɈړ܂B

݊F
  xyzzyIWî悤łB
  ̂łĝĂ݂B


goto-char
[       type]: Function
[  arguments]: goto-char POINT
[    package]: editor
[    seealso]: point-min , point-max , what-cursor-position
[   referred]: goto-line , goto-marker , make-marker
[       file]: builtin.l
[    section]: |WV
[description]: 
w肳ꂽʒuɃJgobt@̃J[\ړ܂B
̈ʒupoint, point-min, point-max̃|CgԂ֐
gp邱Ƃœ邱Ƃ\łB

  POINT: obt@̈ʒułB܂̓}[J[𗘗pł܂B
         ړłŏ̈ʒu point-min Ŏ擾łA
         lw肵 point-min ̈ʒuɈړ܂B
         ړłő̈ʒu point-max Ŏ擾łA傫
         lw肵 point-max ̈ʒuɈړ܂B

߂lF
  mule ł́APOINT Ԃ܂A xyzzy ł͏ t łB 


goto-column
[       type]: Function
[  arguments]: goto-column COLUMN &optional EXCEED-P
[    package]: editor
[    seealso]: goto-virtual-column , current-virtual-column , current-line-columns , goto-line
[   referred]: current-column
[       file]: builtin.l
[    section]: |WV
[description]: 
w肳ꂽʒuɈړ܂Bړ̌ʒuԂ܂B
current-line-columns Ԃl傫Ȓlw肵ꍇɂ́As̏I[
ʒu܂B̐w肵ꍇɂ́As̐擪Ɉʒu܂B

  COLUMN : 


goto-eol
[       type]: Function
[  arguments]: goto-eol
[    package]: editor
[    seealso]: goto-bol , goto-virtual-line
[   referred]: goto-line , goto-virtual-eol
[       file]: builtin.l
[    section]: |WV
[description]: 
sɈړ܂B

݊F
  xyzzyIWî悤łB
  ̂łĝĂ݂B


goto-last-modified-line
[       type]: Function
[  arguments]: goto-last-modified-line
[    package]: editor
[    seealso]: last-modified-point , exchange-point-and-mark
[       file]: cmds.l
[    section]: obt@
[description]: 
݂̃obt@ōŋߕύXꂽs̐擪Ɉړ܂B


goto-line
[       type]: Function
[  arguments]: goto-line LINE
[    package]: editor
[    seealso]: goto-virtual-line , goto-char , goto-column , goto-bol , goto-eol
[       file]: builtin.l
[    section]: |WV
[description]: 
w肳ꂽsԍɃWv܂B܂ԂLɂĂĕ\sɃW
vꍇɂ́Agoto-virtual-linegp܂B[ESC g]


goto-marker
[       type]: Function
[  arguments]: goto-marker MARKER
[    package]: editor
[    seealso]: set-marker , goto-char
[       file]: builtin.l
[    section]: |WV
[description]: 
}[J[̃|WVփ|Cgړ܂B
goto-char ƈႢA|CgijƂĎ󂯎邱Ƃ͂ł܂B


goto-matched-parenthesis
[       type]: Function
[  arguments]: goto-matched-parenthesis &optional ARG
[    package]: editor
[   referred]: set-syntax-match
[       file]: builtin.l
[    section]: |WV
[description]: 
|Cgɑ݂LN^Asyntax-open-psyntax-close-p
ꍇɁAΉLN^Ɉړ܂BΉe튇ʂɈړ
Ɏg܂B[ESC ]]


goto-virtual-bol
[       type]: Function
[  arguments]: goto-virtual-bol
[    package]: editor
[    seealso]: goto-bol , goto-virtual-eol
[   referred]: beginning-of-virtual-line
[       file]: builtin.l
[    section]: |WV
[description]: 
\s̍sɈړ܂B
ۂ̕\\s^sɂ͈ˑ܂B


goto-virtual-column
[       type]: Function
[  arguments]: goto-virtual-column COLUMN &optional EXCEED-P
[    package]: editor
[    seealso]: goto-column
[   referred]: current-virtual-column
[       file]: builtin.l
[    section]: |WV
[description]: 
w肳ꂽ\ֈړ܂B

  COLUMN   : ړ\ʒuw肵܂B
  EXCEED-P : iڍוsj

\܂Ԃ̌ʒu傫Ƃ́A܂Ԃ̌ʒuŎ~܂܂B
ۂ̕\\s^sɂ͈ˑ܂B


goto-virtual-eol
[       type]: Function
[  arguments]: goto-virtual-eol
[    package]: editor
[    seealso]: goto-eol , goto-virtual-bol
[   referred]: end-of-virtual-line
[       file]: builtin.l
[    section]: |WV
[description]: 
\s̍sɈړ܂B
ۂ̕\\s^sɂ͈ˑ܂B


goto-virtual-line
[       type]: Function
[  arguments]: goto-virtual-line LINE
[    package]: editor
[    seealso]: goto-line
[   referred]: current-virtual-line-number , goto-eol
[       file]: builtin.l
[    section]: |WV
[description]: 
\sł̎wsɈړ܂B
EBhE̕\s^s̐ؑւ́Auʐݒv|u\v|usԍ͕\s(D)v
ōs܂B

QlF
  t@CC[WF 
    001| ABCDEFGHIJKLMNOPQR
    002| ABCDEFGHIJKLMNOPQRS
    003| ABCDEFGHIJKLMNOPQRST
    004| ABCDEFGHIJKLMNOPQRSTU
    005| ABCDEFGHIJKLMNOPQRSTUV

                    
      
                                

  sF                        \sF                      
    001| ABCDEFGHIJKLMNOPQR         001| ABCDEFGHIJKLMNOPQR
    002| ABCDEFGHIJKLMNOPQRS        002| ABCDEFGHIJKLMNOPQRS
    003| ABCDEFGHIJKLMNOPQRST       003| ABCDEFGHIJKLMNOPQRST
    004| ABCDEFGHIJKLMNOPQRST       004| ABCDEFGHIJKLMNOPQRST
       | U                          005| U
    005| ABCDEFGHIJKLMNOPQRST       006| ABCDEFGHIJKLMNOPQRST
       | UV                         007| UV


graphic-char-p
[       type]: Function
[  arguments]: graphic-char-p CHAR
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
CHAR 󎚕ǂ𔻒肵܂B

  (graphic-char-p #\A)
  =>t
  (graphic-char-p #\SPC)
  =>t
  (graphic-char-p #\TAB)
  =>nil


handler-case
[       type]: Macro
[  arguments]: handler-case FORM &rest CASES
[    package]: lisp
[    seealso]: ignore-errors , trap-errors , unwind-protect , error , G[֌W
[   referred]: define-condition , make-condition
[       file]: handler.l
[    section]: G[
[description]: 
OLb`܂B
ڍׂ̓G[֘AQƂĂBLb`O
si:*condition-stringőΉ镶擾ł悤łB

  (handler-case
    Oȏ
    (G[̃V{1 (1) G[1)     
    (G[̃V{2 (2) G[2)     
    (G[̃V{3 (3) G[3))

Ⴆ΁AOȏ(error G[V{2)NƁAr
̏Ƃ΂āAG[2s܂BőΉoΏ
p܂AΉłȂ(error 2)sāAʂ
handler-caseɑΉ肢܂Bǂ܂łĂΉłȂ΁A
xyzzyG[_CAOoďI܂B

gpF
  ;;; OoĂAXɑΉpꍇ
  ;;; with-output-to-stringgĂ͕̂ϐς킵
  (with-output-to-string (out)
    (dolist (i '((6 3) (6 0) (6 "a")))
      (handler-case
          (/ (car i) (cadr i))
        (division-by-zero (c)
          (format out "division-by-zero: ~a~%" (si:*condition-string c)))
        (error (c)
          (format out "error:\t ~a~%" (si:*condition-string c))))))
  => "division-by-zero: 0ŏZ܂: /: (6 0)
      error:     sȃf[^^ł: \"a\": number"


hash-table-count
[       type]: Function
[  arguments]: hash-table-count HASH-TABLE
[    package]: lisp
[    seealso]: hash-table-size , make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[u̗vfԂ܂B

  HASH-TABLE : nbVe[uw肵܂B


hash-table-p
[       type]: Function
[  arguments]: hash-table-p OBJECT
[    package]: lisp
[    seealso]: make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
IuWFNgnbVe[uǂԂ܂B

  OBJECT : 肷IuWFNgw肵܂B

  (hash-table-p x) == (typep x 'hash-table)


hash-table-rehash-size
[       type]: Function
[  arguments]: hash-table-rehash-size HASH-TABLE
[    package]: lisp
[    seealso]: make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[ǔ݂rehash-sizeԂ܂B

  HASH-TABLE : nbVe[uw肵܂B


hash-table-size
[       type]: Function
[  arguments]: hash-table-size HASH-TABLE
[    package]: lisp
[    seealso]: hash-table-count , make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[ǔ݂̑傫Ԃ܂B

  HASH-TABLE : nbVe[uw肵܂B


hash-table-test
[       type]: Function
[  arguments]: hash-table-test HASH-TABLE
[    package]: lisp
[    seealso]: make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[ũL[r֐Ԃ܂B

  HASH-TABLE : nbVe[uw肵܂B

gpF
  (hash-table-test hash-table)
  => eql


hide-command-bar
[       type]: Function
[  arguments]: hide-command-bar SYM
[    package]: editor
[    seealso]: show-command-bar
[       file]: cmdbar.l
[    section]: j[
[description]: 
define-command-barŒ`R}ho[\ɂ܂B


hide-restricted-region
[       type]: Variable
[    package]: editor
[    seealso]: narrow-to-region
[    section]: [W
[description]: 
narrow-to-region̈\ɂ邩\邩𐧌䂵܂B

  t   : \ɂ܂B
  nil : \܂B


hide-tool-bar
[       type]: Function
[  arguments]: hide-tool-bar NAME
[    package]: editor
[    seealso]: show-tool-bar
[       file]: builtin.l
[    section]: j[
[description]: 
c[o[NAME\ɂ܂B


html-highlight-mode
[       type]: BufferLocal
[    package]: editor
[    seealso]: set-syntax-tag , parse-point-syntax
[    section]: V^bNX
[description]: 
non-nilȂ΃V^bNX :tag p\ɂȂ܂B


if
[       type]: Special Form
[  arguments]: if TEST THEN [ELSE]
[    package]: lisp
[   referred]: cond
[       file]: builtin.l
[    section]: \
[description]: 
IFs܂B
TESTnon nilȂTHENsBnilȂELSEs܂B

\F
  (if TEST THEN [ELSE])


ignore-errors
[       type]: Macro
[  arguments]: ignore-errors &body BODY
[    package]: lisp
[    seealso]: trap-errors , handler-case , unwind-protect , G[֌W
[   referred]: error
[       file]: handler.l
[    section]: G[
[description]: 
{̂]ƂɔG[SĖ܂B
G[ꍇɂ́Aignore-errorsnilƂ̃RfBV𑽒l
Ԃ܂B

C++̏ꍇF
  try {
    return resolve_shortcut("c:\\autoexec.bat");
  } catch (...) {
    return nil;
  }

xyzzy̏ꍇF
  (ignore-errors  (resolve-shortcut "c:/autoexec.bat"))
  =>nil
  =>#S(file-error pathname "c:/autoexec.bat" datum V[gJbgł͂܂)


ignored-extensions
[       type]: Variable
[    package]: editor
[       file]: defs.l
[    section]: ~jobt@
[description]: 
~jobt@ł͕̓⊮ɂāAignored-extensions̊gqt@
C͕⊮̑ΏۂɂȂ܂B

gpF
  ; exedll͓͕⊮Ȃ
  (setq ignored-extensions '("exe" "dll"))


imagpart
[       type]: Function
[  arguments]: imagpart NUMBER
[    package]: lisp
[    seealso]: realpart , complex
[       file]: builtin.l
[    section]: l
[description]: 
f̋擾܂B

gpF
  (setq a (complex 1 3))
  =>#C(1 3)

  (imagpart a)
  =>3


ime-push-composition-string
[       type]: Function
[  arguments]: ime-push-composition-string &optional NODELETE
[    package]: editor
[    seealso]: rewind-ime-composition
[       file]: kanji.l
[    section]: 
[description]: 
ZNV̊mωmԂɂ܂B[C-c C-p]


ime-register-word-dialog
[       type]: Function
[  arguments]: ime-register-word-dialog
[    package]: editor
[       file]: kanji.l
[    section]: _CAO
[description]: 
P/po^_CAO\܂B[C-c C-r]
ZNV΁AZNV̕Ƃ܂B


import
[       type]: Function
[  arguments]: import SYMBOLS &optional PACKAGE
[    package]: lisp
[    seealso]: pbP[W
[       file]: builtin.l
[    section]: pbP[W
[description]: 
V{̃Xgw肵āȂSẴV{pbP[WŃpbP[W
wȂŃANZXł悤ɂ܂BV{ɃpbP[Wɑ
ꍇ͗O𔭐܂B


in-package
[       type]: Macro
[  arguments]: in-package NAME
[    package]: lisp
[    seealso]: use-package , pbP[W , *package*
[   referred]: defpackage , make-package
[       file]: package.l
[    section]: pbP[W
[description]: 
ǂ̃pbP[WŎs邩ύX܂BύXɍꂽV{́A
w肳ꂽpbP[Wɓo^܂B

gpF
    ;;; ȍ~VV{́A"editor"pbP[Wɓo^
    ;;; 悤ɂȂB
    (in-package "editor")


incf
[       type]: Macro
[  arguments]: incf PLACE &optional (DELTA 1)
[    package]: lisp
[    seealso]: decf
[       file]: setf.l
[    section]: l
[description]: 
ϐCNg܂B

gpF
  ;;; ϐx̒lCNgB
  (setq x 1)    => 1
  (incf x)      => 2
  x             => 2


indent-for-comment
[       type]: Function
[  arguments]: indent-for-comment
[    package]: editor
[       file]: cmds.l
[    section]: eLXg
[description]: 
sɃRg (comment-start, comment-end) }܂B[ESC ;]
Rgʒu comment-indent-function ĂяoʂŌ܂܂B

Rg}̃J[\ʒu comment-start-skip 
comment-start-skip-function Ŏwł܂B


indent-region
[       type]: Function
[  arguments]: indent-region FROM TO
[    package]: editor
[   referred]: mode-specific-indent-command
[       file]: lispmode.l
[    section]: [W
[description]: 
mode-specific-indent-commandnon-nilȂ΁Aw̃[W
mode-specific-indent-commandňsCfg܂B
sdelete-trailing-spacesŋ󔒂폜܂B


indent-relative
[       type]: Function
[  arguments]: indent-relative
[    package]: editor
[    seealso]: newline-and-indent
[   referred]: indent-to
[       file]: cmds.l
[    section]: eLXg
[description]: 
pXy[X^uȊO̕֌ČAŏɌ
ꏊ̍s̃CfgƓݍsCfg܂B

Ȃ݂ emacs ̓̃R}hƂ͋Ⴂ܂B


indent-to
[       type]: Function
[  arguments]: indent-to COLUMN
[    package]: editor
[    seealso]: indent-relative , smart-indentation
[       file]: builtin.l
[    section]: eLXg
[description]: 
w肳ꂽ܂ŃCfg܂B݂̃J[\ʒu菬
΃Xy[X}܂BłȂΉ܂B

  COLUMN : Cfg錅w肵܂B

߂l͈ȉ̂ƂłB

  t   Cfgꍇ
  nil Ȃꍇ


insert
[       type]: Function
[  arguments]: insert &rest STRING-OR-CHAR
[    package]: editor
[   referred]: insert-buffer , insert-buffer-substring
[       file]: builtin.l
[    section]: eLXg
[description]: 
obt@ɑ}܂B

  STRING-OR-CHAR : }镶w肵܂B
                   &restŎ󂯂Ă̂ŉłOKłB

F
  xyzzỹo[W0.0.0.45.1܂̃o[Wł
  Emacsinsert̎dlAقȂĂ܂B

  ;;; Emacs̏ꍇ
  (insert "abc" "def" "ghi")
  => "abcdefghi"}

  ;;; xyzzy̏ꍇ
  (insert "ab" 4)
  => "abababab"}

  xyzzỹo[W0.0.0.45.1ȍ~AEmacsƂinsert݊܂
  ܂B

  (insert "foo")         => foo          ; ܂łƓ
  (insert "foo" 2)       => foofoo       ; ܂łƓ
  (insert "foo" "bar")   => foobar       ; EmacsƓ
  (insert "foo" "bar" 2) => foobarfoobar
  (insert #\f "o" #\o)   => foo          ; EmacsƓ
  (insert #\f "o" #\o 2) => foofoo
  (insert 2)             => G[
  (insert "foo" 2 "bar") => G[
  (insert 102 111 111)   => G[       ; Emacs  => foo


insert-buffer
[       type]: Function
[  arguments]: insert-buffer BUFFER
[    package]: editor
[    seealso]: insert-buffer-substring , insert-file , insert-file-contents , insert
[       file]: buffer.l
[    section]: obt@
[description]: 
w肳ꂽobt@̓ẽ݂obt@ɑ}܂B


insert-buffer-substring
[       type]: Function
[  arguments]: insert-buffer-substring BUFFER &optional FROM TO
[    package]: editor
[    seealso]: insert-buffer , insert
[       file]: buffer.l
[    section]: obt@
[description]: 
w肳ꂽobt@̓ẽ݂obt@ɑ}܂B
[Ww肳Ă΂̗̈}܂B


insert-file
[       type]: Function
[  arguments]: insert-file FILENAME &optional ENCODING
[    package]: editor
[    seealso]: insert-file-contents , insert-buffer , find-file
[   referred]: read-file
[       file]: files.l
[    section]: t@CVXe
[description]: 
w肳ꂽt@CJ[\̈ʒuɓǂݍ݂܂B[C-x i]


insert-file-contents
[       type]: Function
[  arguments]: insert-file-contents FILENAME &optional VISIT-P OFFSET SIZE
[    package]: editor
[    seealso]: insert-file
[   referred]: insert-buffer , read-file
[       file]: builtin.l
[    section]: obt@
[description]: 
t@C̓eJ[\ʒuɑ}܂B

  FILENAME : }t@C
  VISIT-P  : t@C}̓w肵܂B
        t       ύXtOEUNDÕNAAt@C̓t̕ύXs܂B
        nil     ɉ܂B
  OFFSET   : }ItZbg
  SIZE     : }钷

gpF
  ;;; ȒPȃev[g̑}
  ;;; site-lisp/template.lpӂĂ
  (defun insert-template ()
    (and (get-buffer-file-name)
         (not (file-exist-p (get-buffer-file-name)))
         (insert-file-contents (merge-pathnames "site-lisp/template.l" (si:system-root)) t)
         (message "template inserted")))
  => insert-template
  (add-hook '*lisp-mode-hook* 'insert-template)
  => (insert-template lisp-load-keyword-file)


insert-menu-item
[       type]: Function
[  arguments]: insert-menu-item MENU POSITION TAG ITEM &optional COMMAND INIT
[    package]: editor
[    seealso]: add-menu-item , get-menu , define-menu
[       file]: builtin.l
[    section]: j[
[description]: 
j[ڂ쐬j[̏̈ʒuɑ}܂B

  MENU     : ǉ̃j[w肵܂B
  POSITION : }ʒuw肵܂B
  TAG      : ʂ^Ow肵܂BKvȂnilw肵܂B
  ITEM     : j[ɕ\閼Ow肵܂B
  COMMAND  : j[̍ڂIꂽƂɎsR}hw肵܂B
  INIT     : j[JOɕ]Ԃlɂăj[̏
             ݒ肵܂Bڍׂadd-menu-itemQƂĉB


insert-menu-separator
[       type]: Function
[  arguments]: insert-menu-separator MENU POSITION &optional TAG
[    package]: editor
[    seealso]: add-menu-separator , define-menu , define-popup-menu , get-menu , get-menu-position
[       file]: builtin.l
[    section]: j[
[description]: 
Zp[^j[̏̈ʒuɑ}܂B

  MENU     : ǉ̃j[w肵܂B
  POSITION : }ʒuw肵܂B
  TAG      : ʂ^Ow肵܂B


insert-popup-menu
[       type]: Function
[  arguments]: insert-popup-menu MENU POSITION POPUP-MENU MENU-NAME
[    package]: editor
[    seealso]: add-popup-menu , define-popup-menu
[       file]: builtin.l
[    section]: j[
[description]: 
|bvAbvj[j[̏̈ʒuɑ}܂B

  MENU       : ǉ̃j[w肵܂B
  POSITION   : }ʒuw肵܂B
  POPUP-MENU : ǉ|bvAbvj[w肵܂B
  NAME       : j[ɕ\閼Ow肵܂B

gpF
  ;;; ENbNj[W̃j[ɒǉĂ݂B
  (insert-popup-menu *app-menu* 2 *app-popup-menu* "ҏW2(&E)")
  => #<menu 48701736>


insert-register
[       type]: Function
[  arguments]: insert-register R
[    package]: editor
[    seealso]: copy-to-register
[   referred]: copy-rectangle-to-register
[       file]: register.l
[    section]: [W
[description]: 
WX^ R ̓eobt@ɑ}܂B[C-x r i], [C-x r g]
R ɃeLXg܂͋`̈悪ĂȂƃG[ɂȂ܂B


integer-length
[       type]: Function
[  arguments]: integer-length INTEGER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
2iŕ\̒Ԃ܂B

gp:
  (integer-length 7) => 3 ; #b00000111
  (integer-length 8) => 4 ; #b00001000


integerp
[       type]: Function
[  arguments]: integerp OBJECT
[    package]: lisp
[    seealso]: numberp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTintegerȂtAȊOȂnilԂ܂B

  (integerp x) == (typep x 'integer)


interactive
[       type]: Special Form
[  arguments]: interactive {INTERACTIVE-STRING {PARAMETER}*|LIST}
[    package]: editor
[    seealso]: commandp , long-operation , *prefix-args* , read-buffer-name , read-char-encoding , read-command-name , read-directory-name , read-exist-buffer-name , read-exist-file-name , read-file-name-list , read-file-name , read-function-name , read-integer , read-sexp , read-string , read-symbol-name , read-variable-name
[   referred]: command-execute , completing-read , eval-expression , interactive-p , lambda-list-keywords
[       file]: builtin.l
[    section]: ֐
[description]: 
֐ΘbIɎs\ł邱ƁAȂ킿R}hł邱Ƃ錾܂B
̃tH[`Ɋ܂ފ֐͑ΘbIɎsł܂B
ΘbIɎsƂ͋̓Iɂ
EL[oChł̎s
EM-x (execute-extended-command) ł̎s
Ec[o[ł̎s
ȂǂłB

sɈKvłȂ֐ł͕Kv܂񂪁A^Ȃ΂Ȃ
֐̏ꍇ́AINTERACTIVE-STRINGɂđΘbIɎsƂɊ֐ɓn
̒l₻̗^𐧌䂷Kv܂B
INTERACTIVE-STRING̍\͈ȉ̂悤ɂȂ܂B
  *             CӁB݋֎~obt@ł̎s֎~܂B
  0             CӁBvvgɐ܂B
  wq        ɗ^f[^Ƃ̗^̎wɂȂ܂B
  Cӂ̕  ~jobt@ň^Ƃ̃vvgɂȂ܂B
  \n            ؂蕶łBĎ̈ɂĂ̋Lqł܂B

PARAMETERł͎wqɑ΂ݒLqł܂B
 :defaultN      \
 :historyN      
 :titleN        _CAÕ^Cg
N̕ɂ͉Ԗڂ̎wqɑ΂ݒ肩Ƃl܂B
Ⴆ΍ŏ̎wqɑ΂鏉\̎w:default0ōs܂B
:defaultN:titleNŎw肷͕̂A
:historyNŎw肷̂minibuffer-history-variablevpeBV{łB
̃f[^͂̃vpeBlgp܂Bminibuf.lQƁB

ȉAwqƂ̓łB

  {}
   P: Prompt       ~jobt@Ń[U[
   M: Must Match   ͂܂ŌJԂ
   C: Completion   ͌\E⊮
   D: Default      :defaultNgp\
   H: History      :historyNgp\
   T: Title        :titleNgp\

  [ŏIϊl]
  {xx}    - ֐ɂ xxx ^̒l
  {xx/yy} - ͒lȗ͖`lƁAyy^
  {xx|yy} - ͒ldlƁAyy ̌^ł
  {*****} - Ȃł

        {PMCDHT}
  a     {PMCDH }[symbol]        ֐
  B     {P CDH }[buffer/string] obt@
  b     {PMCDH }[buffer]        ̃obt@
  c     {P     }[character]     
  C     {PMCDH }[symbol]        R}h
  d     {      }[integer]       |Cgʒu
  D     {PMCDHT}[string]        fBNg
  e     {P CDH }[string]        st@C
  F     {P CDHT}[string]        t@C
  f     {PMCDHT}[string]        ̃t@C
  l     {P CDHT}[string|cons]   t@C()
  M     {      }[integer]       ZNVJnʒu
  m     {      }[integer]       }[Nʒu
  n     {PM    }[integer]       
  N     {PM    }[integer]       (OuD)
  p     {      }[integer]       Ou̒l
  P     {      }[symbol/nil]    ̑Ou
  R     {      }[integer]       ZNV͈(ڂZNV̎n_AڂZNV̏I_)
  r     {      }[integer]       [W(ڂ}[NʒuAڂ|Cgʒu)
  s     {P  DH }[string]        
  S     {PMCDH }[symbol]        V{
  v     {PMCDH }[symbol]        ϐ
  X     {P     }[*****]         S(ɂ͕]ln)
  x     {P     }[*****]         Ŝ
  z     {PMC H }[encoding]      GR[fBO
  Z     {PMC H }[encoding]      GR[fBO()
 
VɔCӂ̎wq쐬邱Ƃł܂B
*interactive-specifier-alist*Ɏwqɂ镶Ə̊֐V{
o^܂Bkeymap.lQƁB

܂ALISTɂĎwqɈ˂ȂCӂ̓邱Ƃł܂B
cmds.lrepeat-complex-command̒`ȂǂQƁB

l:
E0z0ZƂw͓ʂɁAOu^ꂽƂ̂݃~jobt@œ
  ͑҂ɂȂƂɂȂ܂B
EPARAMETER:emacsnon-nilw肷emacsƂ̌݊l
  Ȃ܂B


interactive-p
[       type]: Function
[  arguments]: interactive-p
[    package]: editor
[    seealso]: commandp , interactive
[       file]: builtin.l
[    section]: ]
[description]: 
s̊֐ interactive ɌĂ΂ĂtAłȂnilԂ܂B

gpF
  ;;; foobarƂ֐`āAfoointeractiveɌĂяoĂ݂B
  ;;; foointeractiveĂ邪Abar͂łȂB
  (defun foo () (interactive) (msgbox "foo: ~A" (interactive-p)) (bar))
  => foo
  (defun bar () (interactive) (msgbox "bar: ~A" (interactive-p)))
  => bar
  M-x: foo
  => [foo: t]
     [bar: nil]


intern
[       type]: Function
[  arguments]: intern STRING &optional PACKAGE
[    package]: lisp
[    seealso]: find-symbol , symbol-name , unintern , make-symbol , pbP[W
[   referred]: gentemp , symbol-package
[       file]: builtin.l
[    section]: pbP[W
[description]: 
񂩂V{쐬܂B쐬V{͎w肳ꂽpbP[W
intern܂Bmake-symbol񂩂V{o܂ApbP
[Wintern܂B

  STRING  : 
  PACKAGE : 쐬V{o^pbP[W

gpF
  ;;; foobarƂV{*package*ɓo^
  (intern "foobar")
  => foobar

  ;;; foobazƂV{lisppbP[Wɓo^B
  (intern "foobaz" (find-package "lisp"))
  => foobaz


internal-time-units-per-second
[       type]: Variable
[    package]: editor
[    seealso]: get-internal-real-time
[    section]: tE
[description]: 
get-internal-real-time Ŏ擾ĺA1b̗ʂ\܂B
Windows̎ނɂA̒lς邩ǂ͕słB


intersection
[       type]: Function
[  arguments]: intersection LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: nintersection , union , set-difference , set-exclusive-or , ldiff , subsetp
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 ̗Ɋ܂܂vf̃XgĕԂ܂B
nintersection ƈႢ LIST1 ͕ۑ܂B

gp:
  (intersection '(1 3 5 7 9) '(2 3 5 7 11))
  => (7 5 3)


isqrt
[       type]: Function
[  arguments]: isqrt INTEGER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
̕𐮐ŕԂ܂B

 (isqrt INTEGER) == (floor (sqrt INTEGER))

gpF
  ;;; 143144isqrtvZB
  (isqrt 143)
  => 11
  (isqrt 144)
  => 12


jump-to-register
[       type]: Function
[  arguments]: jump-to-register R
[    package]: editor
[    seealso]: point-to-register
[       file]: register.l
[    section]: |WV
[description]: 
WX^ R Ɋi[ꂽ}[J[̈ʒuփWv܂B[C-x r j]
R Ƀ}[J[ĂȂƃG[ɂȂ܂B


just-one-space
[       type]: Function
[  arguments]: just-one-space
[    package]: editor
[    seealso]: delete-horizontal-spaces , delete-indentation
[       file]: cmds.l
[    section]: eLXg
[description]: 
J[\ʒȗOɂ锼pXy[Xƃ^u폜ApXy[X
ЂƂ}܂B[ESC /]


kana-char-p
[       type]: Function
[  arguments]: kana-char-p CHAR
[    package]: editor
[    seealso]: kanji-char-p , characterp
[       file]: builtin.l
[    section]: f[^^
[description]: 
pJiԂ܂B

  t    pJiłB
  nil  pJiłȂB

Ji͈ȉ͈̔͂łB
  Code          Char
  ----          ----
  0xa1 .. 0xb0  #\ .. #\
  0xb1 .. 0xdd  #\ .. #\
  0xde          #\
  0xdf          #\


kanji-char-p
[       type]: Function
[  arguments]: kanji-char-p CHAR
[    package]: editor
[    seealso]: kana-char-p , characterp
[       file]: builtin.l
[    section]: f[^^
[description]: 
CHARԂ܂B
iڍוsj


kept-undo-information
[       type]: BufferLocal
[    package]: editor
[    seealso]: undo , undo-boundary , clear-undo-boundary , setup-temp-buffer
[    section]: obt@
[description]: 
undo \񐔂w肷ϐłB

  <integer> : w񐔕 undo ێ܂B
  LȊO  : undo ێ܂B(undo ł܂B)

gpF
  ;;; ݊JĂt@CłundołȂ悤ɂ܂B
  (make-local-variable 'kept-undo-information)
  => t
  (setq kept-undo-information nil)
  => nil


key-to-string
[       type]: Function
[  arguments]: key-to-string KEY &optional ESC-TO-META
[    package]: editor
[       file]: help.l
[    section]: L[}bv
[description]: 
L[ǂ݂₷悤ɕɕϊ܂B

  ESC-TO-META : non-nilȂESCM-ɕϊ܂

gp:
  (key-to-string '(#\ESC #\C-a))    => "ESC C-a"
  (key-to-string '(#\ESC #\C-a) t)  => "M-C-a"


keymapp
[       type]: Function
[  arguments]: keymapp OBJECT
[    package]: editor
[    seealso]: make-keymap
[       file]: builtin.l
[    section]: f[^^
[description]: 
w肳ꂽOBJECTL[}bvԂ܂B

  non-nil   OBJECT̓L[}bv
  nil       OBJECT̓L[}bvł͂Ȃ


keywordp
[       type]: Function
[  arguments]: keywordp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
^ꂽIuWFNg OBJECT L[[hۂԂ܂B OBJECT V
{łA keyword pbP[WɏƂ t ԂĂ悤
łB

  (symbol-package 'a)
  =>#<package: user>
  (symbol-package :a)
  =>#<package: keyword>
  
  (symbolp 'a)
  =>t
  (keywordp 'a)
  =>nil
  
  (symbolp :a)
  =>t
  (keywordp :a)
  =>t


kill-all-buffers
[       type]: Function
[  arguments]: kill-all-buffers &optional NOT-VERBOSE
[    package]: editor
[       file]: buffer.l
[    section]: obt@
[description]: 
Sobt@kill-buffer܂B
NOT-VERBOSEŕۑ邩ۂwł܂B

  NOT-VERBOSE :
        t       mFɕۑ悤Ƃ܂B
        nil     ύXobt@͊mF̃_CAO\܂B


kill-all-local-variables
[       type]: Function
[  arguments]: kill-all-local-variables
[    package]: editor
[   referred]: kill-local-variable , make-local-variable
[       file]: builtin.l
[    section]: obt@
[description]: 
SẴ[Jϐ݂̃obt@œƎ̒lĂȂ悤ɂ܂B
setq-defaultĂȂ[Jϐ͎QƂłȂȂ܂B

gpF
  ;;; defvar-localϐ̒lݒ肵ĂkillĂ݂B
  (defvar-local abc 123)        => abc
  (setq abc 456)                => 456
  abc                           => 456
  (kill-all-local-variables)    => t
  abc                           => 123


kill-buffer
[       type]: Function
[  arguments]: kill-buffer BUFFER
[    package]: editor
[    seealso]: delete-buffer , deleted-buffer-p , kill-selected-buffer , *query-kill-buffer-hook* , *kill-buffer-kills-scratch*
[       file]: buffer.l
[    section]: obt@
[description]: 
obt@폜܂B[C-x k]
Akill-buffer̓obt@ύXĂƍ폜Ăǂ
Ă܂B}NŎgۂɂ́Adelete-buffergقł
傤B([UɕɂȂ폜܂j

܂A*query-kill-buffer-hook*ɃtbN֐ݒ肷ƁAƎ̗pŃo
bt@̔jmFł܂B

gpF
  ;;; ݂̃obt@폜B
  (kill-buffer (selected-buffer))
  => t


kill-line
[       type]: Function
[  arguments]: kill-line &optional LINES
[    package]: editor
[    seealso]: *kill-ring* , kill-region
[       file]: cmds.l
[    section]: [W
[description]: 
skill܂B kills *kill-ring* ֒ǉ܂B [C-k]
A kill-line s邱ƂŁAsꊇ
*kill-ring* ֒ǉ邱Ƃł܂B

  LINES 
     nil  : |CgsȂ΁ÄʒủsR[hkill܂B
            |CgsłȂ΁A̍s̍s܂kill܂B
       0  : |CgsȂ΁AOs̍s܂kill܂B
            |CgsłȂ΁A̍s̍s܂kill܂B
     ̑̐ : w肳ꂽs kill ܂B 


kill-local-variable
[       type]: Function
[  arguments]: kill-local-variable SYMBOL
[    package]: editor
[    seealso]: kill-all-local-variables , make-local-variable , make-variable-buffer-local
[       file]: builtin.l
[    section]: obt@
[description]: 
SYMBOL݂̃obt@œƎ̒lĂȂlɂ܂B
kill-local-variablesł́ASYMBOL̒l̓O[oSYMBOL̒l
ɂȂ܂Bsetq-defaultĂȂ[Jϐ͎QƂłȂȂ܂B

gpF
  ;;; defvar-localϐ̒lݒ肵ĂkillĂ݂B
  (defvar-local abc 123)        => abc
  (setq abc 456)                => 456
  abc                           => 456
  (kill-local-variable 'abc)    => t
  abc                           => 123


kill-paragraph
[       type]: Function
[  arguments]: kill-paragraph &optional (ARG 1)
[    package]: editor
[    seealso]: kill-region , backward-kill-paragraph
[       file]: paragrph.l
[    section]: [W
[description]: 
݂̃pOt̍Ō܂kill܂B


kill-process
[       type]: Function
[  arguments]: kill-process PROCESS
[    package]: editor
[    seealso]: kill-subprocess , signal-process , make-process
[   referred]: process-status
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXIɏI܂B


kill-rectangle
[       type]: Function
[  arguments]: kill-rectangle P1 P2
[    package]: editor
[    seealso]: delete-rectangle , kill-region , kill-rectangle-selection , *rectangle-kill-buffer*
[   referred]: copy-rectangle , copy-rectangle-to-register , yank-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
P1P2Ŏw肳`̈kill܂B
kill`̈yankɂ́Ayank-rectangleg܂B
ʏ*kill-ring*Ƃ͕ʂ̗̈Ɋi[Ă悤łB


kill-rectangle-selection
[       type]: Function
[  arguments]: kill-rectangle-selection
[    package]: editor
[    seealso]: copy-rectangle-selection , kill-rectangle , operate-on-rectangle-selection
[   referred]: delete-rectangle-selection , kill-rectangle-selection-to-clipboard , yank-rectangle-selection
[       file]: select.l
[    section]: [W
[description]: 
}EXŋ`IꂽZNV̗̈kill܂B
yankɂyank-rectangle-selectiong܂Ayank-rectanglełsłB
kille*kill-ring*ƂNbv{[hƂႤ̈Ɋi[Ă悤łB


kill-rectangle-selection-to-clipboard
[       type]: Function
[  arguments]: kill-rectangle-selection-to-clipboard
[    package]: editor
[    seealso]: kill-rectangle-selection , copy-rectangle-selection-to-clipboard
[   referred]: copy-to-clipboard , kill-region-to-clipboard , kill-selection-to-clipboard
[       file]: select.l
[    section]: [W
[description]: 
}EXŋ`IꂽZNV̗̈폜ANbv{[hɃR
s[܂B


kill-region
[       type]: Function
[  arguments]: kill-region FROM TO
[    package]: editor
[    seealso]: copy-region-as-kill , kill-selection , zap-to-char
[   referred]: *kill-ring* , backward-kill-paragraph , kill-line , kill-paragraph , kill-rectangle , kill-region-to-clipboard , kill-word
[       file]: region.l
[    section]: [W
[description]: 
[Wkill ringɓ܂B [C-w]

--- kill rinĝȐ ---
kill-regiońA*kill-ring*̐擪ɒǉ܂B*kill-ring*
ő*kill-ring-max*iW16j܂ŕێł܂BőzÂ
̂j܂B

        *kill-ring*
          
        "defun"    kill-regione
            
        "length"      
            ő*kill-ring-max*
        "test"        
            
        ...           
          

ʂkill[C-k]yank[C-y]A*kill-ring*̐擪̂̂\t
܂񂪁Akillyank-pop[M-y]JԂƁA*kill-ring*̗vf
\tĂ܂B


kill-region-to-clipboard
[       type]: Function
[  arguments]: kill-region-to-clipboard FROM TO
[    package]: editor
[    seealso]: kill-rectangle-selection-to-clipboard , kill-region
[   referred]: copy-to-clipboard , kill-selection-to-clipboard
[       file]: region.l
[    section]: [W
[description]: 
FROMTOŎw肳̈폜̂ANbv{[hɃRs[܂B


kill-selected-buffer
[       type]: Function
[  arguments]: kill-selected-buffer
[    package]: editor
[    seealso]: kill-buffer
[       file]: buffer.l
[    section]: obt@
[description]: 
ÔƂselected-bufferkill-buffer܂B

QlF
  ;;; buffer.l
  (defun kill-selected-buffer ()
    (interactive)
    (kill-buffer (selected-buffer)))


kill-selection
[       type]: Function
[  arguments]: kill-selection
[    package]: editor
[    seealso]: yank-selection , copy-selection
[   referred]: kill-region
[       file]: select.l
[    section]: [W
[description]: 
Iꂽ̈؂A*selection-ring*̐擪ɒǉ܂B [F7]
ǉeyank-selectionœ\t܂B


kill-selection-to-clipboard
[       type]: Function
[  arguments]: kill-selection-to-clipboard
[    package]: editor
[    seealso]: kill-region-to-clipboard , kill-rectangle-selection-to-clipboard
[   referred]: copy-to-clipboard
[       file]: select.l
[    section]: [W
[description]: 
ZNV폜ANbv{[hɓ]܂B[C-Delete]
`IԂł΁A kill-rectangle-selection-to-clipboard
s܂B


kill-subprocess
[       type]: Function
[  arguments]: kill-subprocess
[    package]: editor
[    seealso]: kill-process , make-process
[       file]: process.l
[    section]: vZX
[description]: 
obt@ɌѕtĂvZX~܂B[C-c C-k]


kill-word
[       type]: Function
[  arguments]: kill-word &optional (ARG 1)
[    package]: editor
[    seealso]: backward-kill-word , kill-region , forward-word
[       file]: cmds.l
[    section]: [W
[description]: 
J[\ʒuO̒P̖܂ł؂ALOɒǉ܂B
[ESC d] ܂ [ESC h]
J[\P̓rɂꍇ́AJ[\ʒu炻̒P̖܂łA
ΏۂƂȂ܂B


kinsoku-bol-chars
[       type]: Function
[  arguments]: kinsoku-bol-chars &optional BUFFER
[    package]: editor
[    seealso]: kinsoku-eol-chars , set-kinsoku-chars
[   referred]: kinsoku-extend-limit , kinsoku-goto-column
[       file]: builtin.l
[    section]: eLXg
[description]: 
s֑̏W𕶎ŕԂ܂B


kinsoku-eol-chars
[       type]: Function
[  arguments]: kinsoku-eol-chars &optional BUFFER
[    package]: editor
[    seealso]: kinsoku-bol-chars , set-kinsoku-chars
[   referred]: kinsoku-goto-column , kinsoku-shorten-limit
[       file]: builtin.l
[    section]: eLXg
[description]: 
s֑̏W𕶎ŕԂ܂B


kinsoku-extend-limit
[       type]: Function
[  arguments]: kinsoku-extend-limit &optional BUFFER
[    package]: editor
[    seealso]: kinsoku-bol-chars , kinsoku-shorten-limit , set-kinsoku-chars , kinsoku-goto-column
[       file]: builtin.l
[    section]: eLXg
[description]: 
֑łԂ牺镶Ԃ܂B


kinsoku-goto-column
[       type]: Function
[  arguments]: kinsoku-goto-column COLUMN &optional KINSOKU-MODE
[    package]: editor
[    seealso]: kinsoku-bol-chars , kinsoku-extend-limit , kinsoku-eol-chars , kinsoku-shorten-limit
[       file]: builtin.l
[    section]: eLXg
[description]: 
COLUMNŋ֑{Ƃ̍sɈړ܂B


kinsoku-mode
[       type]: Function
[  arguments]: kinsoku-mode &optional BUFFER
[    package]: editor
[    seealso]: set-kinsoku-chars , *fill-kinsoku-mode*
[       file]: builtin.l
[    section]: eLXg
[description]: 
֑̏Ԃ\4rbg̃tOԂ܂B

  8: ֑sƂ t
  4: [hbvƂ t
  2: sԂ牺Ƃ t
  1: 󔒕Ԃ牺Ƃ t


kinsoku-shorten-limit
[       type]: Function
[  arguments]: kinsoku-shorten-limit &optional BUFFER
[    package]: editor
[    seealso]: kinsoku-eol-chars , kinsoku-extend-limit , set-kinsoku-chars , kinsoku-goto-column
[       file]: builtin.l
[    section]: eLXg
[description]: 
֑ŒǂoԂ܂B


lambda
[       type]: Misc
[  arguments]: lambda LAMBDA-LIST [[{DECLARATION}* | DOCUMENTATION]] {FORM}*
[    package]: lisp
[    seealso]: defun , si:closure-variable
[       file]: evalmacs.l
[    section]: \
[description]: 
֐ɖOtKvȂA葱LqꍇɃ_
p܂B_̓Ԗڂ̈̓_XgƌĂ΂A֐
p[^̖O^܂Blambdâ芮Sȍ\͈ȉłB

(lambda ({var}*
         [&optional {var | (var [initform [svar]])}*]
         [&rest var]
         [&key {var | ({var | (keyword var)} [initform [svar]])}*]
         [&aux {var | (var [initform])}*])
   [[{declaration}* | documentation-string]]
   {form}*)

_ɂĕ\֐ɓKpƁAform ]
čŌ form ̌ʂԂ܂Bform ͏ɕ]܂B

((lambda (x y) (+ x y)) 10 20)        => 30

_Xg̊evf́Ap[^wqAL&iApThj
Ŏn܂郉_XgL[[hȂB_Xg͂T̕
\܂B

EK{p[^̋Lq
    _XgL[[hOɌ var K{p[^ƂB

EIvVip[^̋Lq
    &optional玟̃_XgL[[h܂łA_Xg
    I܂ŁB֐ĂяoɁAIvVip[^ɑΉ
    ͂ĂĂ悢BȗꂽꍇAinitform 
     initform ɏA nil ŏB
    svar ͈^ꂽǂB

  ((lambda (x &optional (y 0 given))
       (if given (+ x y) x))
    10 20)
  => 30

EXgp[^̋Lq
    &restƂɑ̃p[^wqB֐ւ̈̂A
    K{p[^ƃIvVip[^ɑΉ̈ȊO
    Ȃ郊XgɑB

  ((lambda (x &optional (y 1) (z 2) &rest args)
       (list x y z args))
    'a 'b 'c 'd 'e 'f)
  => (a b c (d e f))

EL[[hp^̋Lq
    &key玟̃_XgL[[h܂łA_Xg
    I܂ŁB֐Ă΂ꂽƂɑΉ keyword ɑΉ
    p[^wq var lɑB

  ((lambda (x &key ((:test f) #'eq))
       (if (funcall f x "word") 'True 'False))
   "word" :test #'equal)
  => True

  ((lambda (x &key (test #'eq))
       (if (funcall test x "word") 'True 'False))
    "word" :test #'eql)
  => False

E⏕ϐ̋Lq
    _Xg &aux ܂܂ȂǍ̑SĂ̎w
    ⏕ϐ̎wqłBɎ̗͓ʂ^B
    ̎gpɂĂ͏ɃX^C̖łB
  
  ((lambda (x &aux (l (length x)))
       (list x l))
    '(a b c))
  => ((a b c) 3)
  
  ((lambda (x)
       (let ((l (length x))) (list x l)))
    '(a b c))
  => ((a b c) 3)


lambda-list-keywords
[       type]: Variable
[    package]: lisp
[    seealso]: interactive
[       file]: evalmacs.l
[    section]: ϐƒ萔
[description]: 
_XgL[[hƂĎgV{̃XgłB

QƗ:
  lambda-list-keywords
  =>(&optional &rest &key &aux &body &whole &environment)


lambda-parameters-limit
[       type]: Variable
[    package]: lisp
[    seealso]: call-arguments-limit
[    section]: ϐƒ萔
[description]: 
lambdaɗ^邱Ƃ̂ł̌̌El

QƗF 
  lambda-parameters-limit
  => 536870911


last
[       type]: Function
[  arguments]: last LIST &optional (N 1)
[    package]: lisp
[    seealso]: butlast , subseq
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg̖N̃XgԂ܂B

gpF
  ;;; 擾Ă݂B
  (last '(a b c d))     => (d)
  (last '(a b c d) 2)   => (c d)
  (last '(a b c d) 5)   => (a b c d)


launch-application
[       type]: Function
[  arguments]: launch-application APP
[    package]: editor
[       file]: dialogs.l
[    section]: vZX
[description]: 
vO xyzzy ̊OŎs܂B


lcm
[       type]: Function
[  arguments]: lcm INTEGER &rest MORE-INTEGERS
[    package]: lisp
[    seealso]: gcd
[       file]: builtin.l
[    section]: l
[description]: 
̍ŏ{Ԃ܂B

gpF  
  (lcm 14 35)
  => 70
  (lcm 0 5)
  => 0
  (lcm 1 2 3 4 5 6)
  => 60


ldb
[       type]: Function
[  arguments]: ldb BYTESPEC INTEGER
[    package]: lisp
[    seealso]: dpb , byte
[   referred]: deposit-field , ldb-test , mask-field
[       file]: number.l
[    section]: l
[description]: 
w肳ꂽtB[h̒lo܂B
tB[hw肷 byte specifier ͊֐ byte ō܂B

F
  ;;; ŉʃrbgo
  (ldb (byte 1 0) #x02)  => 0
  (ldb (byte 1 0) #x0f)  => 1
  ;;; (ŉʃoCg) 4 rbgo
  (ldb (byte 4 4) #x0f)  => 0
  (ldb (byte 4 4) #xaf)  => 10
  (ldb (byte 4 4) #xf0)  => 15


ldb-test
[       type]: Function
[  arguments]: ldb-test BYTESPEC INTEGER
[    package]: lisp
[    seealso]: ldb
[       file]: number.l
[    section]: l
[description]: 
w肳ꂽtB[h non-zero ǂ𔻒肵܂B
(not (zerop (ldb BYTESPEC INTEGER))) ƓłB


ldiff
[       type]: Function
[  arguments]: ldiff LIST OBJECT
[    package]: lisp
[    seealso]: tailp , intersection , set-difference , set-exclusive-or
[   referred]: union
[       file]: list.l
[    section]: Xg
[description]: 
OBJECT  LIST ̈ꕔłȂALIST  OBJECT ̕XgԂ܂B

LIST ̈ꕔł邩ǂ̔ eq ōs܂B
OBJECT  LIST  tailp ł LIST ̈ꕔłƂ݂ȂƂ܂B

gp:
  (setq x '(a b c d e))
  => (a b c d e)
  (setq y (cddr x))
  => (c d e)
  (ldiff x y)
  => (a b)
  ;; ڂ͓ł x ̈ꕔłȂȂ_
  (ldiff x '(c d e))
  => (a b c d e)


length
[       type]: Function
[  arguments]: length SEQUENCE
[    package]: lisp
[    seealso]: list-length , fill-pointer
[   referred]: make-array , vector
[       file]: builtin.l
[    section]: V[PX
[description]: 
sequence(AXgAz)̒߂܂B
zfill-pointerꍇ́A܂ł̒ɂȂ܂B

gpF
  (length "abcd")               => 4
  (length (list 1 2 3))         => 3
  (length (make-array 7))       => 7
  (length (make-array 7 :fill-pointer 4))
                                => 4


let
[       type]: Special Form
[  arguments]: let ({VAR|(VAR [VALUE])}*) {declaration}* {FORM}*
[    package]: lisp
[    seealso]: let*
[   referred]: do* , prog
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
[Jȕϐ`ătH[]܂B


let*
[       type]: Special Form
[  arguments]: let* ({VAR|(VAR [VALUE])}*) {declaration}* {FORM}*
[    package]: lisp
[    seealso]: let
[   referred]: do* , prog*
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
letƂ悭Ă܂BletƈقȂAVAȐɐɒ`VARQ
邱Ƃ\łB

gpF
  ;;; letlet*̈Ⴂ
  (setq Y 2)
  => 2
  (let (X (Y 1) (Z Y)) (list X Y Z))
  => (nil 1 2)
  (let* (X (Y 1) (Z Y)) (list X Y Z))
  => (nil 1 1)


lisp-complete-symbol
[       type]: Function
[  arguments]: lisp-complete-symbol
[    package]: editor
[    seealso]: *lisp-popup-completion-list*
[       file]: lispmode.l
[    section]: V{
[description]: 
Lisp ̃V{⊮܂B[ESC TAB]


lisp-indent-hook
[       type]: Misc
[    package]: editor
[    section]: V{
[description]: 
V{ɃvpeBݒ肷邱Ƃ lisp-indent-line ł̃Cfgʂ𐧌䂵܂B

  l n   : n Ԗڈȍ~̈ *lisp-body-indent* A
             Ö (* *lisp-body-indent* 2) Cfg
  nil      : ʏ̃Cfg
             1Ԗڂ̈̃Cfgʂ *lisp-indent-offset* ɏ]
  ȊO : ׂĂ̈ *lisp-body-indention* Cfg

gpF
  ;;; $XYZZY/lisp/lispmode.l 
  (setf (get 'lambda 'lisp-indent-hook) 'defun)
  (setf (get 'interactive 'lisp-indent-hook) 1)
  (setf (get 'progn 'lisp-indent-hook) 0)
  (setf (get 'if 'lisp-indent-hook) 2)
  (setf (get 'let 'lisp-indent-hook) 1)
  (setf (get 'let* 'lisp-indent-hook) 1)


list
[       type]: Function
[  arguments]: list &rest ARGS
[    package]: lisp
[    seealso]: list* , make-list
[       file]: builtin.l
[    section]: Xg
[description]: 
̊֐́A ARGS vfƂ郊Xg܂BʂƂĕԂ郊
Xg() nil Ń^[~l[g(󒍁FI[)Ă܂B ARGS ^
ȂꍇA empty XgԂ܂B 

  (list 1 2 3 4 5)
  => (1 2 3 4 5)
  (list)
  => nil


list*
[       type]: Function
[  arguments]: list* &rest ARGS
[    package]: lisp
[    seealso]: list
[       file]: builtin.l
[    section]: Xg
[description]: 
list Ƃ悭 ARGS vfƂ郊Xg܂A Ō̗vf
RXZ cdrɒڂȂ܂B

gp:
  (setq a (list 1 2 3))
  => (1 2 3)            ; (1 . (2 . (3 . nil)))

  (setq b (list* 1 2 3))
  => (1 2 . 3)          ; (1 . (2 . 3))

  (setq c (list* 4 5 6 a))
  => (4 5 6 1 2 3)


list-all-packages
[       type]: Function
[  arguments]: list-all-packages
[    package]: lisp
[    seealso]: defpackage , pbP[W
[   referred]: find-package
[       file]: builtin.l
[    section]: pbP[W
[description]: 
xyzzyɑ݂pbP[WꗗXgŕԂ܂B

gpF
  (list-all-packages)
  =>  (#<package: win-user> #<package: winapi> #<package: 
     foreign>  #<package: lisp> #<package: system> #<package: 
     keyword> #<package: user> #<package: editor>)


list-archive
[       type]: Function
[  arguments]: list-archive ARCHIVE-FILE &optional FILE-NAME-ONLY
[    package]: editor
[    seealso]: create-archive
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
A[JCũt@Cꗗo܂B

  ARCHIVE-FILE   : ꗗ擾A[JCuw肵܂B
  FILE-NAME-ONLY : ߂ľ`w肵܂B
        t   t@C(fBNg)݂̂Ԃ܂B
        nil t@C(fBNg)AATCYA^CX^v
            Ԃ܂B

gpF
  (list-archive "foo.lzh")


list-function
[       type]: Function
[  arguments]: list-function &rest ARGS
[    package]: editor
[    seealso]: ed::build-summary-function
[       file]: listfn.l
[    section]: ֐
[description]: 
obt@̊֐̈ꗗ_CAOŕ\܂BI邱ƂŒ
`ʒuɃWv邱Ƃ\łBobt@̊֐̈ꗗ́Ao
bt@[Jϐbuild-summary-function擾Ă܂B


list-length
[       type]: Function
[  arguments]: list-length LIST
[    package]: lisp
[    seealso]: length
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg̒Ԃ܂B
XgzĂꍇAlength ͌ʂԂȂ܂񂪁A
list-length  nil Ԃ܂B

gpF
  ;;; Xgׂ̒Ă݂B
  (list-length '())             => 0 
  (list-length '(a b c d))      => 4 
  (list-length '(a (b c) d))    => 3 
  (let ((a '(x)))
    (setf (cdr a) a)
    (list-length a))            => nil


list-server-resources
[       type]: Function
[  arguments]: list-server-resources SERVER-NAME &optional COMMENT-P
[    package]: editor
[    seealso]: list-servers
[       file]: builtin.l
[    section]: ̑
[description]: 
w肳ꂽRs[^̋L̈ꗗ擾܂B
Ɏ̃Rg擾\łB

gpF
  (list-server-resources "SAMURAI")
  => ("SPOOL" "E" "D" "A")
  (list-server-resources "SAMURAI" t)
  => (("SPOOL" "") ("E" "CD-ROM Drive") ("D" "Backup Storage") ("A" "FD Drive"))


list-servers
[       type]: Function
[  arguments]: list-servers &optional COMMENT-P
[    package]: editor
[    seealso]: list-server-resources
[       file]: builtin.l
[    section]: ̑
[description]: 
lbg[NRs[^̈ꗗ擾ł܂B
ɃRs[^ɐݒ肳ĂRg擾\łB

gpF
  (list-servers)
  => ("SAMURAI" "ROUNIN")
  (list-servers t)
  => (("SAMURAI" "Main Machine") ("ROUNIN" "Sub Machine"))


list-text-attributes
[       type]: Function
[  arguments]: list-text-attributes &optional START END
[    package]: editor
[    seealso]: find-text-attribute , set-text-attribute
[       file]: builtin.l
[    section]: eLXg
[description]: 
obt@̃eLXgׂĒTAXgɂĕԂ܂B
͈͂w肵ꍇA͈̔͒Ɉꕔł܂܂̂Xgɂ܂B

  START : ͈͂̊Jn_
  END   : ͈͂̏I_


list-tool-bars
[       type]: Function
[  arguments]: list-tool-bars
[    package]: editor
[   referred]: tool-bar-info
[       file]: builtin.l
[    section]: j[
[description]: 
c[o[̏Ԃ擾܂BԂ͈ȉ̌`ŕԂ܂B

`F
  (((̃c[o[1 ʒu1 cʒu1 1)
    (̃c[o[2 ʒu2 cʒu2 2)
    (̃c[o[3 ʒu3 cʒu3 3) ... )
   ((㑤̃c[o[1 ʒu1 cʒu1 1) ... )
   ((Ẽc[o[1 ʒu1 cʒu1 1) ... )
   ((̃c[o[1 ʒu1 cʒu1 1) ... )
   (\̃c[o[1 \̃c[o[2 ... ))

^uo[̏ꍇɐԂ܂Bc[o[̏ꍇɂ́AKnil
Ԃ܂B


list-xyzzy-windows
[       type]: Function
[  arguments]: list-xyzzy-windows
[    package]: editor
[    seealso]: next-xyzzy-window , previous-xyzzy-window
[   referred]: activate-xyzzy-window
[       file]: builtin.l
[    section]: vZX
[description]: 
NxyzzÿꗗXg`ŕԂ܂B
  
  (list-xyzzy-windows)
  =>((0 . "*scratch* - xyzzy 0.2.2.235@XYZZY") (1 . "*untitled* - xyzzy 0.2.2.235@XYZZY") (2 . "*untitled*<2> - xyzzy 0.2.2.235@XYZZY"))


listen
[       type]: Function
[  arguments]: listen &optional INPUT-STREAM
[    package]: lisp
[    seealso]: read-char-no-hang
[       file]: builtin.l
[    section]: o
[description]: 
w肳ꂽ̓Xg[ɉ͂ԂȂtAȂȂnilԂ܂B


listp
[       type]: Function
[  arguments]: listp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTcons󃊃Xg()ȂtAȊOȂnilԂ܂B

  (listp x) == (typep x 'list) == (typep x '(or cons null))


load-file
[       type]: Function
[  arguments]: load-file FILENAME
[    package]: lisp
[    seealso]: load-library , load , mc-load-file
[       file]: misc.l
[    section]: ]
[description]: 
t@CΘbIɓǂݍ݂܂B
load-library ƈقȂA*load-path* ɂȂt@Cǂݍ߂܂B


load-keyword-file
[       type]: Function
[  arguments]: load-keyword-file NAME &optional ICASE TABLE CONDITION
[    package]: editor
[    seealso]: L[[ht@C̏ , *keyword-load-path* , make-list-from-keyword-table
[       file]: kwd.l
[    section]: ̑
[description]: 
L[[ht@C[h܂B

gpF
  (and *xmldoc-keyword-file*
       (null *xmldoc-keyword-hash-table*)
       (setq *xmldoc-keyword-hash-table*
             (load-keyword-file *xmldoc-keyword-file* t)))
  (when *xmldoc-keyword-hash-table*
    (make-local-variable 'keyword-hash-table)
    (setq keyword-hash-table *xmldoc-keyword-hash-table*))


load-library
[       type]: Function
[  arguments]: load-library FILENAME &rest REST
[    package]: lisp
[    seealso]: si:*load-library , load-file , *load-path* , mc-load-library , e탍[h֌W̊֐̈Ⴂ
[   referred]: require
[       file]: misc.l
[    section]: ]
[description]: 
CuΘbIɓǂݍ݂܂B
requireƈقȂAxǂłĂxǂݍ݂܂B

Iɂ́Asi:*load-libraryinteractiveŐ錾̂łB

| ܂Asi:*load-libraryŎsAbZ[Wo͂āA𑱂
| ͉̂\ł傤H

  (handler-case
      (si:*load-library "foo")
    (error (c) (si:*print-condition c)))
      (si:*load-library "bar")


load-session
[       type]: Function
[  arguments]: load-session FILENAME &optional NOT-CLOSE
[    package]: editor
[    seealso]: save-session , *default-session-directory*
[   referred]: open-session-dialog
[       file]: session.l
[    section]: obt@
[description]: 
ZbVt@CɕۑĂԂ𕜌܂B [C-x 6 f]

  NOT-CLOSE : [hOɊJĂobt@폜邩ǂ
        nil       *scratch* Ăׂč폜Ă烍[h
        non-nil   c܂܃[h


local-keymap
[       type]: Function
[  arguments]: local-keymap &optional BUFFER
[    package]: editor
[    seealso]: use-kaymap , local-set-key
[       file]: builtin.l
[    section]: L[}bv
[description]: 
obt@ BUFFER ̃[JL[}bv (use-keymap Őݒ肳ꂽL[}b
v) Ԃ܂B

BUFFER ȗꂽꍇ̓Jgobt@ΏۂɂȂ܂B


local-set-key
[       type]: Function
[  arguments]: local-set-key KEY COMMAND
[    package]: editor
[    seealso]: local-unset-key , local-keymap , global-set-key , define-key
[       file]: keymap.l
[    section]: L[}bv
[description]: 
Jgobt@̃[JL[}bvɃL[o^܂B
̈Ӗ global-set-key ƓłB


local-unset-key
[       type]: Function
[  arguments]: local-unset-key KEY
[    package]: editor
[    seealso]: local-set-key
[       file]: keymap.l
[    section]: L[}bv
[description]: 
[JL[}bṽL[蓖Ă܂B

gpF
  ;;; lisp-modeTAB̃[JL[}bvOB
  (lookup-key-command #\TAB)
  => lisp-indent-line
  (local-unset-key #\TAB)
  => t
  (lookup-key-command #\TAB)
  => self-insert-command


local-variable-p
[       type]: Function
[  arguments]: local-variable-p SYMBOL &optional BUFFER
[    package]: editor
[    seealso]: make-local-variable , defvar-local
[       file]: builtin.l
[    section]: f[^^
[description]: 
w肳ꂽV{obt@[Jϐǂ𔻒肵܂B

gpF
  ;;; buffer: foo
  (local-variable-p 'abc)
  => nil
  (make-local-variable 'abc)
  => t
  (local-variable-p 'abc)
  => t

  ;;; buffer: bar
  (local-variable-p 'abc)
  => nil


lock-file
[       type]: BufferLocal
[    package]: editor
[    seealso]: unlock-file , file-locked-p
[    section]: obt@
[description]: 
bNt@C邩ǂw肷ϐłB

  t   : bNt@CB
  nil : bNt@CȂB

gpF
  ;;; ݊JĂt@Cł̓bNt@CȂ悤ɂB
  (make-local-variable 'lock-file)
  => t
  (setq lock-file nil)
  => nil 


log
[       type]: Function
[  arguments]: log NUMBER &optional BASE
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
BASE Ƃ NUMBER ̑ΐԂ܂B

gpF
  (log 2.718282)
  => 1.0
  (log 7.389056)
  => 2.0


logand
[       type]: Function
[  arguments]: logand &rest ARGS
[    package]: lisp
[    seealso]: logior , logandc1 , logandc2 , lognand , lognot
[       file]: number.l
[    section]: l
[description]: 
rbgAND܂BCł&łB

gpF
  ;;; 2i#b11110000#b00110011̃rbg̐ςB
  (format nil "~8,'0b" (logand #b11110000 #b00110011))
  => "00110000"


logandc1
[  arguments]: logandc1 X Y
[    package]: lisp
[    seealso]: logand , logandc2
[       file]: number.l
[    section]: l
[description]: 
X1̕␔  Y ̃rbg̘_ςԂ܂B

gp:
  (format nil "~4,'0b" (logandc1 #b0011 #b0101))
  => "0100"
  (format nil "~4,'0b" (logand (lognot #b0011) #b0101))
  => "0100"


logandc2
[  arguments]: logandc2 X Y
[    package]: lisp
[    seealso]: logand , logandc1
[       file]: number.l
[    section]: l
[description]: 
X  Y1̕␔ ̃rbg̘_ςԂ܂B

gp:
  (format nil "~4,'0b" (logandc2 #b0011 #b0101))
  => "0010"
  (format nil "~4,'0b" (logand #b0011 (lognot #b0101)))
  => "0010"


logeqv
[       type]: Function
[  arguments]: logeqv &rest ARGS
[    package]: lisp
[    seealso]: logxor
[       file]: number.l
[    section]: l
[description]: 
rbg̘_Ԃ܂B

gp:
  (format nil "~4,'0b" (logeqv #b0011 #b0101))
  => "-111"
  (format nil "~4,'0b" (lognot (logxor #b0011 #b0101)))
  => "-111"


logior
[       type]: Function
[  arguments]: logior &rest ARGS
[    package]: lisp
[    seealso]: logand , lognor , logorc1 , logorc2
[       file]: number.l
[    section]: l
[description]: 
rbgOR܂BCł|łB

gpF
  ;;; 2i#b00110000#b00000011̃rbg̘aB
  (format nil "~8,'0b" (logior #b00110000 #b00000011))
  => "00110011"


lognand
[       type]: Function
[  arguments]: lognand X Y
[    package]: lisp
[    seealso]: logand , lognor
[       file]: number.l
[    section]: l
[description]: 
rbg̔ےI_(NAND)Ԃ܂B

gp:
  ;;; X        0011
  ;;; Y        0101
  ;;; AND      0001
  ;;; NAND     1110
  ;;; 1̕␔  0001
  ;;; 2̕␔  0010
  (format nil "~4,'0b" (lognand #b0011 #b0101))
  => "0-10"
  (format nil "~4,'0b" (lognot (logand #b0011 #b0101)))
  => "0-10"


lognor
[       type]: Function
[  arguments]: lognor X Y
[    package]: lisp
[    seealso]: logior , lognand
[       file]: number.l
[    section]: l
[description]: 
rbg̔ےI_a(NOR)Ԃ܂B

gp:
  ;;; X        0011
  ;;; Y        0101
  ;;; OR       0111
  ;;; NOR      1000
  ;;; 1̕␔  0111
  ;;; 2̕␔  1000
  (format nil "~4,'0b" (lognor #b0011 #b0101))
  => "-1000"
  (format nil "~4,'0b" (lognot (logior #b0011 #b0101)))
  => "-1000"


lognot
[       type]: Function
[  arguments]: lognot INTEGER
[    package]: lisp
[    seealso]: logand , logor
[       file]: builtin.l
[    section]: l
[description]: 
INTEGER1̕␔(2i\01𔽓])Ԃ܂B

gp:
  ;;; INTEGER 00000011
  ;;; ]    11111100
  ;;; 1̕␔ 00000011
  ;;; 2̕␔ 00000100
  (lognot #b0011)
  => -4
  (format nil "~8,'0b" -4)
  => "0000-100"
  (format nil "~4,'0b" (lognot -4))
  => "0011"


logorc1
[       type]: Function
[  arguments]: logorc1 X Y
[    package]: lisp
[    seealso]: logior , logorc2
[       file]: number.l
[    section]: l
[description]: 
X1̕␔  Y ̃rbg̘_aԂ܂B

gp:
  (format nil "~4,'0B" (logorc1 #b0011 #b0101))
  => "0-11"
  (format nil "~4,'0b" (logior (lognot #b0011) #b0101))
  => "0-11"


logorc2
[       type]: Function
[  arguments]: logorc2 X Y
[    package]: lisp
[    seealso]: logior , logorc1
[       file]: number.l
[    section]: l
[description]: 
X  Y1̕␔ ̃rbg̘_aԂ܂B

gp:
  (format nil "~4,'0B" (logorc2 #b0011 #b0101))
  => "-101"
  (format nil "~4,'0b" (logior #b0011 (lognot #b0101)))
  => "-101"


logxor
[       type]: Function
[  arguments]: logxor &rest ARGS
[    package]: lisp
[    seealso]: logeqv
[       file]: number.l
[    section]: l
[description]: 
rbg̔rI_aԂ܂B

gp:
  (format nil "~4,'0b" (logxor #b0011 #b0101))
  => "0110"


long-float-p
[       type]: Function
[  arguments]: long-float-p OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTlong-floatȂtAȊOȂnilԂ܂B


long-operation
[       type]: Macro
[  arguments]: long-operation &rest BODY
[    package]: editor
[    seealso]: begin-wait-cursor , end-wait-cursor
[   referred]: interactive
[       file]: misc.l
[    section]: ̑
[description]: 
J[\vɂ܂B炩ɏԂƂ܂ꍇɂ
悤ƗǂƎv܂B

gpF
  (long-operation
     (message "start")
     ;; 
     (message "end"))


looking-at
[       type]: Function
[  arguments]: looking-at REGEXP &optional CASE-FOLD
[    package]: editor
[    seealso]: looking-for , scan-buffer , string-match , string-looking-at , K\̕\L
[       file]: builtin.l
[    section]: EK\
[description]: 
݂̃J[\ʒuőOɐK\Ń}b`tAȂnilԂ܂B

gpF
  ;;; J[\ʒusł(ƃ}b`邩?
  (defun rrr ()
    (interactive)
    (if (looking-at "^(")
      (message "ok") (message "bad")))

  ;;; 󔒂^uSpXy[X΍폜
  (if (looking-at "[ \t@]*")
      (delete-region (match-beginning 0) (match-end 0)))

QlF
  ;;; looking-at ̌ (K\Ō}b`)
  ;;; XyzzyWiki ┠/175 
  (defun looking-at-backward (regexp &optional case-fold)
    (save-excursion
      (save-restriction
        (narrow-to-region (point-min) (point))
        (goto-char (point-min))
        (scan-buffer (format nil "~A\\'" regexp)
                     :regexp t :case-fold case-fold))))


looking-back
[       type]: Function
[  arguments]: looking-back STRING &optional CASE-FOLD
[    package]: editor
[    seealso]: looking-for
[       file]: builtin.l
[    section]: EK\
[description]: 
݂̃J[\ʒuɃ}b`tAȂnilԂ܂B

gpF
  (looking-back "::")
  (looking-back "\\")
  (looking-back "#'")


looking-for
[       type]: Function
[  arguments]: looking-for STRING &optional CASE-FOLD
[    package]: editor
[    seealso]: looking-at , looking-back
[       file]: builtin.l
[    section]: EK\
[description]: 
݂̃J[\ʒuOɃ}b`tAȂnilԂ܂B
Ƀ}b`looking-backAK\Ń}b`
looking-atgp܂B

gpF
  (looking-for "^")
  (looking-for "define")
  (looking-for "::")


lookup-dictionary
[       type]: Function
[  arguments]: lookup-dictionary DIRECTORY DIC-FILE INDEX-FILE WORD
[    package]: editor
[       file]: builtin.l
[    section]: ̑
[description]: 
@\
iڍוsj

gpF
  (lookup-dictionary *edict-dictionary-path* "xyzzydic" "xyzzye2j" s)


lookup-key-command
[       type]: Function
[  arguments]: lookup-key-command KEY
[    package]: editor
[    seealso]: lookup-keymap
[       file]: help.l
[    section]: L[}bv
[description]: 
w肵L[ɐݒ肳ꂽ֐Ԃ܂B
lookup-keymapgĎĂ܂B


lookup-keymap
[       type]: Function
[  arguments]: lookup-keymap KEYMAP KEY &optional IGNORE-CASE SYMBOL-ONLY
[    package]: editor
[    seealso]: command-keys , lookup-key-command
[   referred]: make-keymap
[       file]: builtin.l
[    section]: L[}bv
[description]: 
w肵L[}bv̒Ŏw肵L[ɃoChꂽ֐Ԃ܂B


loop
[       type]: Macro
[  arguments]: loop &body BODY
[    package]: lisp
[       file]: evalmacs.l
[    section]: \
[description]: 
[v܂B
Eoɂ͈ȉ̗lreturng܂B

 (loop
   
   (if  (return l))
   )

gpF
  ;;; u͂vƓ܂ŌJԂ
  (loop (if (yes-or-no-p "quit?") (return 123)))
  => 123


lower-case-p
[       type]: Function
[  arguments]: lower-case-p CHAR
[    package]: lisp
[    seealso]: upper-case-p , both-case-p , char-downcase
[       file]: builtin.l
[    section]: 
[description]: 
CHAR Ȃ t AłȂ nil Ԃ܂B

gpF
  (lower-case-p #\a)
  => t
  (lower-case-p #\A)
  => nil
  (lower-case-p #\RET)
  => nil


machine-name
[       type]: Function
[  arguments]: machine-name
[    package]: editor
[    seealso]: user-name , si:getenv
[   referred]: os-major-version , os-minor-version , os-platform
[       file]: builtin.l
[    section]: VXe
[description]: 
}VԂ܂B

gpF
  ;;; }VԂ܂B
  (machine-name)
  => "WS4849"

  ;;; PCɂāAden8diff̃CXg[fBNgĂ̂ŁA
  ;;; ؂ւł܂B
  (defun my-directory-setup ()
    (let ((x (machine-name)))
      (setq *diff-command-name*
            (cond ((string= x "TOMOYO") "c:/Cygnus/diff")
                   (t "c:/z/tools/diff")))
      (setq *den8-directory*
            (cond ((string= x "KANA") "D:/1gou-ki/den8_321")
                   (t "c:/z/den8_321")))))


macro-function
[       type]: Function
[  arguments]: macro-function SYMBOL
[    package]: lisp
[    seealso]: fboundp , boundp
[       file]: builtin.l
[    section]: }N
[description]: 
SYMBOL}NۂԂ܂B}N̏ꍇɂ͂̓eԂ܂B
gpF
  (macro-function 'car)
  =>nil

  (macro-function 'when)
  =>(macro (lisp::test &body lisp::body)
         (block when (list 'if lisp::test (cons 'progn lisp::body))))


macroexpand
[       type]: Function
[  arguments]: macroexpand FORM &optional ENV
[    package]: lisp
[    seealso]: defmacro , macroexpand-1
[       file]: builtin.l
[    section]: }N
[description]: 
tH[ǂ̂悤Ƀ}NWJ邩Ԃ܂B
}N̓WJmF̂ɖ𗧂܂B

gpF
  ;;; }NM2`Ăǂ̂悤ɓWJ
  (defmacro M2 (&rest args)
      `(progn
         (m-setup) ,@args (m-cleanup)))
  (macroexpand '(M2 (insert "Begin") (insert "End")))
  => (progn (m-setup) (insert "Begin") (insert "End") (m-cleanup)) 


macroexpand-1
[       type]: Function
[  arguments]: macroexpand-1 FORM &optional ENV
[    package]: lisp
[    seealso]: macroexpand
[       file]: builtin.l
[    section]: }N
[description]: 
macroexpandɎĂ܂AWJ郌x1xŏIƂ낪Ⴂ܂B
̃}NȂǂǂWĴׂƂɕ֗łB

gp:
  (defmacro my-macro ()
    `(dotimes (x 10)))
  Ƃ}NƂ
  
  (macroexpand '(my-macro))
  => (block nil (let* ((x 0) (#1=#:count 10)) (lisp::*loop (if (>= x #1#) (return (progn 'nil))) (tagbody) (setq x (+ x 1)))))
  my-macroWJdotimes܂(ۂdotimesWJコdo*WJ)
  ċAIɓWJ܂A

  (macroexpand-1 '(my-macro))
  => (dotimes (x 10))
  ƁAmy-macroWJ܂B


macrolet
[       type]: Special Form
[  arguments]: macrolet ({(NAME LAMBDA-LIST {declaration}* [doc-string] {FORM}*)}*) {FORM}*
[    package]: lisp
[    seealso]: defmacro , flet
[       file]: builtin.l
[    section]: }N
[description]: 
defmacrőǏłłB


make-array
[       type]: Function
[  arguments]: make-array DIMENSIONS &rest REST &key (:element-type t) (:initial-element () ies-p) (:initial-contents () ics-p) :fill-pointer :adjustable :displaced-to (:displaced-index-offset 0)
[    package]: lisp
[    seealso]: make-sequence , aref , setf , make-vector , length , array-dimensions
[   referred]: adjustable-array-p , array-element-type , array-rank , fill-pointer , vector
[       file]: array.l
[    section]: z
[description]: 
DIMENSIONS Ŏ傫E̔zAlƂĕԂ܂B
ADIMENSIONS  nil ȂA[z񂪂܂B
Ƃ΁Aϐ hoge TCY4̈ꎟz(=TCY4̃xN^)ɂ邽߂ɂ́A

  (setf hoge (make-array 4))
  => #(nil nil nil nil)

ϐ foo TCY2x4̓񎟌zƂ邽߂ɂ́A

  (setf foo (make-array '(2 4)))
  => #2A((nil nil nil nil) (nil nil nil nil))

Ƃ܂B
:element-type ́AVz̊evf̌^K肵܂B
:initial-element ^ĂꍇAVz̑Svfׂ͂
:initial-element ɏ܂Bɑ΂āA:initial-contents ^
ĂꍇAVz̊evf :initial-contents ŏ܂B
Ƃ΁A

  (make-array '(2 4) :initial-element 10); 2x4̔zB:initial-elementŏ
  => #2A((10 10 10 10) (10 10 10 10))
  (setq a (make-array '(2 4) 
  :initial-contents '((0 1 2 3) (3 2 1 0))); 2x4̔zB:initial-contentsŏ
  => #2A((0 1 2 3) (3 2 1 0))

ȂAz̗vfɃANZX邽߂ɂ́A aref g܂B

:displaced-to, :displaced-index-offset ẃA̔z̈ꕔȂ鋤Lz
𐶐邽߂Ɏg܂B copy-seq ɂ镡Ƃ͈ႢAz񎩑̂LĂ܂B

  (setq b (make-array '(2 3) :displaced-to a :displaced-index-offset 2))
  => #2A((2 3 3) (2 1 0))

  (setq c (make-array 5 :displaced-to a :displaced-index-offset 1))
  => #(1 2 3 3 2)

  (setf (aref b 1 0) 10)
  a
  => #2A((0 1 2 3) (3 10 1 0))
  b
  => #2A((2 3 3) (10 1 0))
  c
  => #(1 2 3 3 10)


make-backup-files
[       type]: BufferLocal
[    package]: editor
[   referred]: save-buffer
[    section]: obt@
[description]: 
obNAbvt@C邩ǂw肷ϐłB

  t   : obNAbvt@C
  nil : obNAbvt@CȂ

gpF
  ;;; ݊JĂt@CobNAbvƂȂ悤ɂB
  (make-local-variable 'make-backup-files)
  => t
  (setq make-backup-files nil)
  => nil


make-broadcast-stream
[       type]: Function
[  arguments]: make-broadcast-stream &rest STREAMS
[    package]: lisp
[    seealso]: broadcast-stream-streams , broadcast-stream-p , make-concatenated-stream , make-echo-stream , xyzzyŒ񋟂ĂXg[̎
[       file]: builtin.l
[    section]: o
[description]: 
u[hLXgp̏o̓Xg[쐬܂B
STREAMS Ɏw肵̃Xg[ɑ΂ēɏo͂邱Ƃł܂B

QlF
                        OUTPUT
                    STREAM1 
                      
        BROADCAST   OUTPUT
    STREAM  STREAM2 
          
                      OUTPUT
                    STREAM3 
                        
gpF
  ;;; foobarƂo̓Xg[ĂA
  ;;; hogeƂu[hLXgpXg[ꊇďo
  (with-open-stream (foo (open "foo.txt" :direction :output))
    (with-open-stream (bar (open "bar.txt" :direction :output))
      (with-open-stream (hoge (make-broadcast-stream foo bar))
        (princ "abc" hoge))))
  => "abc"


make-buffer-stream
[       type]: Function
[  arguments]: make-buffer-stream BUFFER &optional POINT EOB
[    package]: editor
[    seealso]: buffer-stream-buffer , buffer-stream-point , buffer-stream-set-point , xyzzyŒ񋟂ĂXg[̎
[   referred]: buffer-stream-p
[       file]: builtin.l
[    section]: o
[description]: 
obt@buffer-stream쐬܂B

  BUFFER : buffer-stream쐬obt@w肵܂B
  POINT  : o͂Jn|Cgw肵܂B
        nil     obt@̐擪Jnʒu
        nilȊO w肳ꂽ|CgJnʒu
  EOB    : I[̃|Cgw肵܂B
        nil     obt@̍ŌオI[
        nilȊO w肳ꂽ|CgI[


make-concatenated-stream
[       type]: Function
[  arguments]: make-concatenated-stream &rest STREAMS
[    package]: lisp
[    seealso]: make-broadcast-stream , xyzzyŒ񋟂ĂXg[̎
[   referred]: concatenated-stream-streams
[       file]: builtin.l
[    section]: o
[description]: 
STREAMS Ɏw肵̓̓Xg[āAԂɓǂݏo߂
̓̓Xg[܂B

QlF
                        INPUT     
                      STREAM1 
                          
        CONCAT  INPUT     
    STREAM  STREAM2 
              
                      INPUT     
                      STREAM3 
                            

gpF
  ;;; ̓̓Xg[{A{ɘAڂĂ݂B
  (with-open-stream (foo (make-string-input-stream "foo"))
    (with-open-stream (bar (make-string-input-stream "bar"))
      (with-open-stream (hoge (make-concatenated-stream foo bar))
        (while (setq in (read-char hoge nil))
          (write-char in)))))


make-condition
[       type]: Function
[  arguments]: make-condition TYPE &rest ARGS
[    package]: lisp
[    seealso]: handler-case , error , G[֌W , define-condition
[       file]: condition.l
[    section]: G[
[description]: 
TYPE ^̃RfBV쐬ĕԂ܂B
쐬邾ŁAG[ɂ͂Ȃ܂B
G[𔭐ɂ error ȂǂœKv܂B

gp:
  (make-condition 'simple-error)
  => #S(simple-error format-string nil format-arguments nil)


make-dispatch-macro-character
[       type]: Function
[  arguments]: make-dispatch-macro-character CHAR &optional NON-TERMINATING-P READTABLE
[    package]: lisp
[    seealso]: set-dispatch-macro-character , get-dispatch-macro-character
[       file]: builtin.l
[    section]: o
[description]: 
fBXpb`}NVɍ쐬܂B
CHAR ɃfBXpb`}NłΉ܂B


make-echo-stream
[       type]: Function
[  arguments]: make-echo-stream INPUT-STREAM OUTPUT-STREAM
[    package]: lisp
[    seealso]: echo-stream-input-stream , echo-stream-output-stream , echo-stream-p , make-two-way-stream , make-broadcast-stream , xyzzyŒ񋟂ĂXg[̎
[       file]: builtin.l
[    section]: o
[description]: 
INPUT-STREAM ̓͂ OUTPUT-STREAM ɏo͂Xg[쐬܂B
make-two-way-stream ƈقȂA INPUT-STREAM ͂ꂽéAS
OUTPUT-STREAM ɃGR[܂B

QlF

     ECHO STREAM    INPUT 
    STREAM  
                
                OUTPUT
    STREAM  
            


make-hash-table
[       type]: Function
[  arguments]: make-hash-table &key :test :size :rehash-size :rehash-threshold
[    package]: lisp
[    seealso]: gethash , hash-table-count , hash-table-p , hash-table-rehash-size , hash-table-size , hash-table-test , remhash , clrhash , maphash , eql
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[u쐬ĕԂ܂B

  :test        : nbVe[ũL[̓֌WBftHg eql łB
                 w\Ȋ֐́Aeq, eql, equal, equalp Ɍ܂B
  :size        : nbVe[ȕTCY̖ڈB
                 ̒l傫fA܂ 2, 3, 5, 7 ŊȂl
                 ɐݒ肳܂B
  :rehash-size : nbVe[ũe[uTCY𑝉ʂ̖ڈB
                 ftHg 1B݂̃TCY  :rehash-size Ql
                 ɁA傫fA܂ 2, 3, 5, 7 ŊȂTCY
                 ɂ܂B
  :rehash-threshold
               : xyzzy ł͎ĂȂ悤łB (0.2.2.235 )
                 ̑Ae[u̎gp 80% 𒴂ƃe[u
                 L܂B

Ƃ肤f͈ȉ̒ʂłB
      17, 47, 101, 149, 199, 307, 401, 499, 599, 701, 797, 907, 997,
      1103, 1499, 1999, 2999, 4001, 4999, 6007, 7001, 8009, 8999,
      10007, 19997, 29989, 39989, 49999, 59999, 70001, 79999, 90001, 99991

gp:
  (setq hash (make-hash-table :size 3))
  => #<hashtable 51122492>

  (progn
    (setf (gethash #\C-0 hash) 0)
    (setf (gethash #\C-1 hash) 1)
    (setf (gethash #\C-2 hash) 2))
  => 2
  
  (gethash #\C-1 hash)
  => 1
      t

  (hash-table-size hash)
  => 17

  (hash-table-rehash-size hash)
  => 1

  (hash-table-test hash)
  => eql


make-keymap
[       type]: Function
[  arguments]: make-keymap
[    package]: editor
[    seealso]: make-sparse-keymap , keymapp , use-keymap , define-key , lookup-keymap
[   referred]: *full-keymap-length*
[       file]: builtin.l
[    section]: L[}bv
[description]: 
̃L[}bv쐬܂B


make-list
[       type]: Function
[  arguments]: make-list SIZE &key :initial-element
[    package]: lisp
[    seealso]: list , make-sequence
[       file]: builtin.l
[    section]: Xg
[description]: 
w肳ꂽ̃Xg쐬ĕԂ܂B

  SIZE             : Xg̒
  :initial-element : Xg̗vf

gpF
  (make-list 3)
  => (nil nil nil)
  (make-list 0)
  => nil
  (make-list 2 :initial-element 'x)
  => (x x)


make-list-from-keyword-table
[       type]: Function
[  arguments]: make-list-from-keyword-table HASH
[    package]: editor
[   referred]: load-keyword-file
[       file]: kwd.l
[    section]: ϐƒ萔
[description]: 
L[[hnbVe[u⊮p̃Xg쐬܂B

  HASHFL[[hnbVe[u(*xxxx-keyword-hash-table*)w

gpF
  ;;; CSS̃L[[hnbVe[u
  ;;; ⊮pXg쐬āAdo-completionB
  (defun css-completion ()
    (interactive)
    (or *css-completion-list*
        (setq *css-completion-list* (make-list-from-keyword-table *css-keyword-hash-table*))
        (return-from css-completion nil))
    (let ((opoint (point)))
      (when (skip-syntax-spec-backward "w_")
        (let ((from (point)))
          (goto-char opoint)
          (do-completion from opoint :list-ignore-case *css-completion-list*)))))


make-local-variable
[       type]: Function
[  arguments]: make-local-variable SYMBOL
[    package]: editor
[    seealso]: make-variable-buffer-local , defvar-local , local-variable-p , kill-local-variable , kill-all-local-variables , buffer-local-value
[   referred]: setq-default
[       file]: builtin.l
[    section]: obt@
[description]: 
SYMBOL݂̃obt@œƎ̒lĂ悤Ƀ[Jϐɂ܂B
make-variable-buffer-localƂ͈قȂÃ݂obt@łB

gpF
  ;;; ݂̃obt@͎ۑȂ悤ɂB
  (make-local-variable 'auto-save)
  => t  
  (setq auto-save nil)
  => nil


make-marker
[       type]: Function
[  arguments]: make-marker &optional BUFFER
[    package]: editor
[    seealso]: point-marker , markerp , set-marker , mark , marker-point , goto-char , process-marker
[   referred]: scan-buffer
[       file]: builtin.l
[    section]: |WV
[description]: 
̃}[J[ĕԂ܂B
obt@ҏW邱ƂŁA}[J[̈ʒuɒǐĕς܂B
}[J[́A goto-char  buffer-substringAdelete-region Ȃǂ̃ob
t@̈ʒuɂƂ֐̈ƂĎgpł܂B

  BUFFER : }[J[obt@w肵܂B
           w肵Ȃ΁Ã݂obt@ɂȂ܂B

gpF
  ;; XNb`Ń}[J[
  (setq marker (make-marker (find-buffer "*scratch*")))
  => #<marker: *scratch*: ->

  ;; }[J[Ɉʒuݒ肷
  (set-marker marker 3)
  => #<marker: *scratch*: 3>

  ;; }[J[ʒuɈړ
  (goto-char marker)
  => t

  ;; }[J[O̓e폜
  (goto-char (point-max))
  (delete-region 0 1)
  (marker-point marker)
  => 2

  ;; }[J[Oɕ}
  (goto-char 0)
  (insert "abc")
  (marker-point marker)
  => 5

  ;; }[J[ʒuɕ}
  (goto-char marker)
  (insert "xyz")
  (marker-point marker)
  => 5


make-package
[       type]: Function
[  arguments]: make-package PACKAGE-NAME &key :nicknames :use :internal-size :external-size
[    package]: lisp
[    seealso]: defpackage , delete-package , in-package , pbP[W
[       file]: builtin.l
[    section]: pbP[W
[description]: 
pbP[W쐬܂BdefpackageƂ̈Ⴂ́Hiڍוsj

gpF
  (make-package name :external-size 0)


make-process
[       type]: Function
[  arguments]: make-process COMMAND-LINE &key :environ :output :exec-directory :incode :outcode :eol-code
[    package]: editor
[    seealso]: call-process , execute-subprocess , filter-region , buffer-process , process-send-string , set-process-sentinel , set-process-filter , kill-subprocess , shell-execute , open-network-stream
[   referred]: kill-process , process-marker , process-status
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXN܂B

  COMMAND-LINE    : sR}hIvVtŎw肵܂B
  :environ        : ݒ肷ϐAzXg`œn܂B
                    (("HOME" . "C:/applications/xyzzy/")
                     ("TOPDIR" . "C:/spool/"))
  :output         : vZX̕Wo͂o͂obt@w肵܂B
  :exec-directory : sfBNgw肵܂B
  :incode         : vZX̓͂̕R[hw肵܂B
  :outcode        : vZX̏o͂̕R[hw肵܂B
  :eol-code       : sR[hw肵܂B

vZXւ̓͂process-send-stringgp܂B
vZX̓obt@Ɋ֘AtAvZX̏o͂obt@ɂ̂܂܏o͂܂B
obt@Ɋ֘AtꂽvZX̏Ԃ́C[hC :Run  :Exit 
\܂B܂Aϐo͐擙ύXł܂B

߂ĺCobt@Ɋ֘AtꂽvZXłB

Ql:
  [xyzzy:02210]R{^񂳂
  call-process ܂͕ʂ̑gݍ݊֐ŁAẂAWóAWG[
  o͂𒼐ڃobt@Ɍq悤ɂĂƎv̂łA
  łH

  (make-process *eshell* :output (selected-buffer))
  (process-send-string (buffer-process (selected-buffer))
                       (concatenate 'string cmd *shell-ret*))


make-random-state
[       type]: Function
[  arguments]: make-random-state &optional STATE
[    package]: lisp
[    seealso]: *random-state* , random-state-p , random
[       file]: builtin.l
[    section]: l
[description]: 
̏Ԃ܂

  STATE:
    nil          ͂Ɍ݂*random-state*̃Rs[Ԃ܂B
    t            ɊÂĐVԂ܂B
    random-state ̊֐(make-random-state)̖߂lnƃRs[Ԃ܂B

gp:
 ;;;̍Č
 (let ((rs1 (make-random-state nil))
       (rs2 (make-random-state nil)))   ;;̗Ԃ̃Rs[
   (dotimes (i 10)
     (format t "~A " (random 100 rs1))) ;;
   (terpri)
   (dotimes (i 10)
     (format t "~A " (random 100 rs1))) ;;ڂ肷
   (terpri)
   (dotimes (i 10)
     (format t "~A " (random 100 rs2))) ;;ڂĂ݂B
   (terpri))
 =>3 41 81 70 73 66 32 72 2 55   ;
   21 97 83 14 86 26 99 69 18 46 
   3 41 81 70 73 66 32 72 2 55   ;ɂȂ


make-sequence
[       type]: Function
[  arguments]: make-sequence TYPE SIZE &key :initial-element
[    package]: lisp
[    seealso]: make-vector , make-array , make-list
[   referred]: concatenate , map , string
[       file]: sequence.l
[    section]: V[PX
[description]: 
vf̃^Cv TYPE ŃTCY SIZE ȃV[PX쐬ĕԂ܂B
:initial-element ^ꂽꍇ͂ꂼ̍ڂ͂ŏ܂B
  
TYPE ̒lƕԂV[PX͈ȉ̒ʂłB
  'list           Xg
  'vector         xN^
  'simple-vector 
  'string         
  'simple-string 

TYPE ɂ̓Xg^邱ƂłȀꍇ͍ŏ̗vfŃV[PX܂܂B
  '(list ...)          Xg
  '(array ...)         z
  '(simple-array ...) 
ŏ̗vf list ̏ꍇAԖڈȍ~͖̈܂B
ŏ̗vf array ܂ simple-array ̏ꍇ͎OԖڂ̗vf܂ňӖ܂B
Ԗڂ̗vf͒lɂĈȉ̂悤ɕω܂BXg̏ꍇ͂̍ŏ̗vfŔf܂B
  t                   z
  nil                
  character           
  base-character     
  standard-char      
  extended-character 
OԖڂ̗vf 1 ܂ (*) ܂ (SIZE ɓl) łȂ΂Ȃ܂񂪁A
ǂIłɈႢ͂Ȃ悤łB
  
gpF
  ;;; #\a  8 ̕Ă݂
  (make-sequence 'string 8 :initial-element #\a)
  => "aaaaaaaa"
  (make-sequence 'list 4 :initial-element "abc")
  => (#1="abc" #1# #1# #1#)
  (make-sequence 'vector 4 :initial-element 'a)
  => #(a a a a)
  ;;;  TYPE  array ^Ă݂
  (make-sequence '(array t (*)) 4 :initial-element 'a)
  => #(a a a a)
  (make-sequence '(array character 1) 8 :initial-element #\a)
  => "aaaaaaaa"


make-sparse-keymap
[       type]: Function
[  arguments]: make-sparse-keymap
[    package]: editor
[    seealso]: make-keymap
[       file]: builtin.l
[    section]: L[}bv
[description]: 
̃L[}bv쐬܂B
L[`̐ȂɎgƃߖł܂B

gpF
  ;;; lispmode.l
  (unless *lisp-mode-map*
    (setq *lisp-mode-map* (make-sparse-keymap))
    (define-key *lisp-mode-map* #\C-M-x 'eval-defun)
    ...
    (define-key *lisp-mode-map* #\) 'lisp-electric-close))


make-string-input-stream
[       type]: Function
[  arguments]: make-string-input-stream STRING &optional START END
[    package]: lisp
[    seealso]: make-string-output-stream , with-input-from-string , xyzzyŒ񋟂ĂXg[̎
[       file]: builtin.l
[    section]: o
[description]: 
񂩂̓͗pXg[쐬܂B
ȌÃXg[͕̓eԂɎ擾\łB

  STRING : Ώۂ̕w肵܂B
  START  : ̓Xg[ƂJnʒułB
  END    : ̓Xg[ƂIʒułB

̓̓Xg[gp̂łȂ΁Awith-input-from-string g
pȒPłB

gpF
  ;;; ̓͗pXg[ЂƂǂݏoĂ݂B
  (with-open-stream (foo (make-string-input-stream "abc def"))
    (read foo))
  => abc  

  ;;; with-input-from-stringgēĂ݂B
  (with-input-from-string (foo "abc def")
    (read foo))
  => abc  


make-symbol
[       type]: Function
[  arguments]: make-symbol PRINT-NAME
[    package]: lisp
[    seealso]: intern , gensym , symbol-package , uninterned
[       file]: builtin.l
[    section]: V{
[description]: 
󎚖PRINT-NAMEłuninternedȃV{Ԃ܂B

QlF
  evalmacs.l


make-syntax-table
[       type]: Function
[  arguments]: make-syntax-table
[    package]: editor
[    seealso]: copy-syntax-table , syntax-table-p , use-syntax-table
[   referred]: syntax-table
[       file]: builtin.l
[    section]: V^bNX
[description]: 
V^bNXe[u쐬܂B{IɊeɃV^bNXR[h
U܂AɂړI̍\ɉĈȉ̐ݒs܂B

  E񒆂̃GXP[v̐ݒ
  E^O⊇ʂȂǂ̑Ήt̂镶̐ݒ
  EPȂ΂ɂȂ؂蕶̐ݒ
  ERg̐ݒ
      EJnIꕶōsRg
      EJnI𕶎ōsRg
      EC++X^C̃Rg
  Esɕꍇ̃Rg̐ݒ

̐ݒ set-syntax-... n̊֐gčs܂BݒɉāA
ʂ̐Ft skip-syntax-spec-forward / skip-syntax-spec-backward ł̓
ς肵܂B

ftHglF
  Num           Char            SyntaxCode
  ---           ----            ----------
  0x00          #\NUL           SCjunk
  0x01 .. 0x08  #\C-a .. #\C-h  SCjunk
  0x09          #\TAB           SCwhite
  0x0a          #\LFD           SCwhite
  0x0b          #\C-k           SCjunk
  0x0c          #\C-l           SCwhite
  0x0d          #\RET           SCwhite
  0x0e .. 0x1a  #\C-n .. #\C-z  SCjunk
  0x1b          #\ESC           SCjunk
  0x1c          #\C-\\          SCjunk
  0x1d          #\C-]           SCjunk
  0x1e          #\C-^           SCjunk
  0x1f          #\C-_           SCjunk
  0x20          #\SPC           SCwhite
  0x21 .. 0x2f  #\! .. #\/      SCpunct
  0x30 .. 0x39  #\0 .. #\9      SCword
  0x3a          #\:             SCpunct
  0x3b          #\;             SCpunct
  0x3c          #\<             SCpunct
  0x3d          #\=             SCpunct
  0x3e          #\>             SCpunct
  0x3f          #\?             SCpunct
  0x40          #\@             SCpunct
  0x41 .. 0x5a  #\A .. #\Z      SCword
  0x5b          #\[             SCpunct
  0x5c          #\\             SCpunct
  0x5d          #\]             SCpunct
  0x5e          #\^             SCpunct
  0x5f          #\_             SCpunct
  0x60          #\`             SCpunct
  0x61 .. 0x7a  #\a .. #\z      SCword
  0x7b          #\{             SCpunct
  0x7c          #\|             SCpunct
  0x7d          #\}             SCpunct
  0x7e          #\~             SCpunct
  0x7f          #\DEL           SCjunk
  0x80                          SCjunk
  0x81 ..0x9f   #\x81 .. #\x9f  SCkanji
  0xa0                          SCkanji
  0xa1 .. 0xb0  #\ .. #\      SCkana
  0xb1 .. 0xdd  #\ .. #\      SCkana
  0xde          #\             SCkana
  0xdf          #\             SCkana
  0xe0 .. 0xfc  #\xe0 .. #\xfc  SCkanji
  0xfd                          SCjunk
  0xfe                          SCjunk
  0xff                          SCjunk


make-temp-file-name
[       type]: Function
[  arguments]: make-temp-file-name &optional PREFIX SUFFIX DIRECTORY DIRECTORY-P
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
ꎞƗp̃t@C쐬̃pXԂ܂B
t@C͑ɍ쐬܂B悤ɃfBNg쐬邱Ƃ\łB

  PREFIX      : ꎞƗp̃t@C̐ړq
  SUFFIX      : ꎞƗp̃t@C̊gq
                w肪".tmp"ƂȂ܂B
  DIRECTORY   : ꎞƗp̃t@C쐬fBNg
                w肪ΊϐTMPɍ쐬܂B
  DIRECTORY-P : t@Cł͂ȂfBNg쐬ꍇ
        t       fBNg쐬܂B
        nil     t@C쐬܂B

gpF
  ;;; C:\spoolɈꎞƗpt@C쐬܂B 
  (make-temp-file-name "_den" "tmp" "c:/spool")
  => "c:/spool/_denc0dc.tmp"


make-two-way-stream
[       type]: Function
[  arguments]: make-two-way-stream INPUT-STREAM OUTPUT-STREAM
[    package]: lisp
[    seealso]: two-way-stream-input-stream , two-way-stream-output-stream , make-echo-stream , xyzzyŒ񋟂ĂXg[̎
[       file]: builtin.l
[    section]: o
[description]: 
͂INPUT-STREAMAo͂OUTPUT-STREAMɂo̓Xg[쐬܂B

QlF
        TWO WAY
          STREAM    INPUT 
    STREAM  
                    
                    OUTPUT
    STREAM  
            


make-variable-buffer-local
[       type]: Function
[  arguments]: make-variable-buffer-local SYMBOL
[    package]: editor
[    seealso]: make-local-variable
[   referred]: kill-local-variable
[       file]: builtin.l
[    section]: obt@
[description]: 
SYMBOLX̃obt@œƎ̒lĂ悤Ƀ[Jϐɂ܂B
make-local-variableƂ͈قȂASẴobt@ΏۂłB
]̂Ƃdefvar-localgΗǂƎv܂B


make-vector
[       type]: Function
[  arguments]: make-vector LENGTH &key (:element-type t) (:initial-element () ies-p) (:initial-contents () ics-p) :fill-pointer :adjustable :displaced-to (:displaced-index-offset 0)
[    package]: lisp
[    seealso]: vector , make-array , copy-seq
[   referred]: make-sequence
[       file]: array.l
[    section]: z
[description]: 
w肵̃xN^Ԃ܂B

gpF
  ;;; 10̃xN^܂B
  (make-vector 10)
  => #(nil nil nil nil nil nil nil nil nil nil)

  ;;; :element-typecharacterw肷ƕ񂪍쐬ł
  (make-vector 10 :element-type 'character)
  => "^@^@^@^@^@^@^@^@^@^@"


makunbound
[       type]: Function
[  arguments]: makunbound SYMBOL
[    package]: lisp
[    seealso]: boundp
[   referred]: set
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
w肳ꂽV{̒l̑܂B
ȍ~boundpnilԂ悤ɂȂ܂BlƊ֐`͓̑ƗĂ
̂ŁAmakunboundĂfboundp̌ʂ͕ς܂B

gpF
  ;;; Ă݂B
  (set 'foo 2)          => 2
  (boundp 'foo)         => t
  (makunbound 'foo)     => foo
  (boundp 'foo)         => nil


map
[       type]: Function
[  arguments]: map RESULT-TYPE FUNCTION SEQUENCE &rest MORE-SEQUENCES
[    package]: lisp
[    seealso]: map-into , make-sequence , mapcar
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE  FUNCTION KpāARESULT-TYPE ɉV[PXԂ܂B
mapcar Ƃ̈Ⴂ́AXgłȂz񓙂̃V[PXɂKpł
ƂƁARESULT-TYPE ̎w肪KvȂƂłB

  RESULT-TYPE : nilA make-sequence  TYPE Ɠ̂g܂B
                nil ̏ꍇ ߂l͏ nil ŁAʏ pړIƂ
                gp܂B
  FUNCTION    : mapcar ƓlASEQUENCE ̊evfЂƂo
                ̂ƂȂ܂B MORE-SEQUENCES ꍇ͂ mapcar 
                Ɠ悤ɓKp܂B

gp:
  ;;; ̏ꍇ͈̗vf string ł͂Ȃ char ɂȂ邱Ƃɒ
  (map 'list #'char-code "abc")
  => (97 98 99)


map-backslash-to-slash
[       type]: Function
[  arguments]: map-backslash-to-slash STRING
[    package]: editor
[    seealso]: map-slash-to-backslash
[       file]: builtin.l
[    section]: 
[description]: 
̃obNXbVXbVɒuĕԂ܂B

  STRING : ϊΏۂ̕

gpF
  ;;; pXϊB
  (map-backslash-to-slash "C:\\xyzzy\\xyzzy.exe")
  => "C:/xyzzy/xyzzy.exe"


map-char-encoding-region
[       type]: Function
[  arguments]: map-char-encoding-region P1 P2 &optional ENCODING
[    package]: editor
[    seealso]: detect-char-encoding , map-char-encoding-selection , parse-char-encoding-region
[       file]: kanji.l
[    section]: eLXg
[description]: 
[W̕f[^𕶎GR[fBO ENCODING ̃f[^ƂāA
xyzzyR[h֕ϊ܂B
ENCODING w肳Ȃ͎肵܂B


map-into
[       type]: Function
[  arguments]: map-into RESULT-SEQUENCE FUNCTION &rest SEQUENCES
[    package]: lisp
[    seealso]: map
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCES  map Ɠ悤 FUNCTION KpǍʂ 
RESULT-SEQUENCE ɖߍ݂܂BRESULT-SEQUENCE ԒZ SEQUENCE 
ꍇɂ RESULT-SEQUENCE ̌㕔̗]vf͕ω܂B
  
gp:
  (map-into "abcde" #'char-upcase "fgh")
  => "FGHde"
  (map-into '(1 2 3) #'- '(4 5 6 7 8))
  => (-4 -5 -6)


map-slash-to-backslash
[       type]: Function
[  arguments]: map-slash-to-backslash STRING
[    package]: editor
[    seealso]: map-backslash-to-slash
[       file]: builtin.l
[    section]: 
[description]: 
̃XbVobNXbVɒuĕԂ܂B

  STRING : ϊΏۂ̕

gpF
  ;;; pXϊB
  (map-slash-to-backslash "C:/xyzzy/xyzzy.exe")
  => "C:\\xyzzy\\xyzzy.exe"


mapc
[       type]: Function
[  arguments]: mapc FUNCTION LIST &rest MORE-LISTS
[    package]: lisp
[    seealso]: mapcar
[       file]: builtin.l
[    section]: \
[description]: 
̓nmapcarƂ悭Ă܂A߂lɂ͗^ꂽXg
܂ܕԂ܂B


mapcan
[       type]: Function
[  arguments]: mapcan FN LISTS &rest MORE-LISTS
[    package]: lisp
[    seealso]: mapcar , mapcon , nconc
[       file]: evalmacs.l
[    section]: \
[description]: 
̓n mapcar ɂ悭Ă܂A֐ FN ̌Ăяoʂ
XgԂ܂B

  (mapcan f x1 ... xn) == (apply #'nconc (mapcar f x1 ... xn))

gpF
  ;;; mapcanmapcarƂ̈Ⴂ
  (mapcan #'(lambda (x) (and (characterp x) (list (char-name x))))
          '(456 #\A 789 #\b #\c 123))
  => ("latin_capital_letter_a" "latin_small_letter_b" "latin_small_letter_c")
  (mapcar #'(lambda (x) (and (characterp x) (list (char-name x))))
          '(456 #\A 789 #\b #\c 123))
  => (nil ("latin_capital_letter_a") nil ("latin_small_letter_b") ("latin_small_letter_c") nil)


mapcar
[       type]: Function
[  arguments]: mapcar FUNCTION LIST &rest MORE-LISTS
[    package]: lisp
[    seealso]: mapcan , mapcon , maplist , mapc , mapl , map
[       file]: builtin.l
[    section]: \
[description]: 
̃Xg֐̖߂l̃Xg쐬ĕԂ܂B
͊eXgcarAڂcadrAOڂcaddr֐ɓn܂B
Xg̏ꍇɂ̂Ő}܂B

  ;;; Xg      
  (mapcar #'char-name '( #\a #\b #\c))
                        
                                
                                                
  == (list (char-name #\a) (char-name #\b) (char-name #\c))
  == (list "latin_small_letter_a" "latin_small_letter_b" "latin_small_letter_c")
  => ("latin_small_letter_a" "latin_small_letter_b" "latin_small_letter_c")

  ;;; Xg   
  (mapcar #'+      '( 1 2 3 4)
                   '( 1 3 5  )
                   '( 1 4 916)
                   '( 1 827  )) 
                     
                    
                                        
  == (list (+ 1 1 1 1) (+ 2 3 4 8) (+ 3 5 9 27))
  == (list 4 17 44)
  => (4 17 44)

gpF
  (mapcar #'+ '(1 2 3 4) 
              '(1 3 5) 
              '(1 4 9 16) 
              '(1 8 27)) 
  => (4 17 44)


mapcon
[       type]: Function
[  arguments]: mapcon FN LISTS &rest MORE-LISTS
[    package]: lisp
[    seealso]: maplist , mapcan , nconc
[   referred]: mapcar
[       file]: evalmacs.l
[    section]: \
[description]: 
̓n maplist ɂ悭Ă܂A֐ FN ̌Ăяoʂ
XgԂ܂B

  (mapcon f x1 ... xn) == (apply #'nconc (maplist f x1 ... xn))

gpF
  (mapcon #'(lambda (x) (if (find 2 x) (list x))) '(1 a 2 b 3))
  => ((1 a 2 b 3) (a 2 b 3) (2 b 3))
  
  (mapcon #'(lambda (x) (if (find 2 x) x)) '(1 a 2 b 3)) ; [v?
  
  (mapcon #'(lambda (x) (if (find 2 x) (copy-list x))) '(1 a 2 b 3))
  => (1 a 2 b 3 a 2 b 3 2 b 3)


maphash
[       type]: Function
[  arguments]: maphash FUNCTION HASH-TABLE
[    package]: lisp
[    seealso]: with-hash-table-iterator , gethash , make-hash-table
[       file]: hash.l
[    section]: nbV
[description]: 
nbVe[ůevf֐ɓn܂B

  FUNCTION   : L[ƒl󂯎֐
  HASH-TABLE : nbVe[uw肵܂B

gpF
  (setf hsh (make-hash-table))
  (setf (gethash #\a hsh) "Apple")  => "Apple"
  (setf (gethash #\b hsh) "Banana") => "Banana"
  (setf (gethash #\c hsh) "Cake")   => "Cake"
  (let ((alist nil))
    (maphash #'(lambda (x y) (pushnew (cons x y) alist)) hsh)
    alist)
  =>((#\c . "Cake") (#\b . "Banana") (#\a . "Apple"))


mapl
[       type]: Function
[  arguments]: mapl FUNCTION LIST &rest MORE-LISTS
[    package]: lisp
[    seealso]: maplist
[   referred]: mapcar
[       file]: builtin.l
[    section]: \
[description]: 
̓nmaplistƂ悭Ă܂A߂lɂ͗^ꂽXg
̂܂ܕԂ܂B


maplist
[       type]: Function
[  arguments]: maplist FUNCTION LIST &rest MORE-LISTS
[    package]: lisp
[    seealso]: mapcar , mapcon
[   referred]: mapl
[       file]: builtin.l
[    section]: \
[description]: 
̃Xg֐̖߂l̃Xg쐬ĕԂ܂B
͊eXgAڂcdrAOڂcddr֐ɓn܂B

gpF
  (maplist #'(lambda (x) (cons 'foo x)) '(a b c d))
  => ((foo a . #1=(b . #2=(c . #3=(d)))) (foo . #1#) (foo . #2#) (foo . #3#))


mark
[       type]: Function
[  arguments]: mark &optional FORCE
[    package]: editor
[    seealso]: marker-point , make-marker , set-mark , exchange-point-and-mark
[   referred]: region-beginning , region-end
[       file]: builtin.l
[    section]: |WV
[description]: 
}[N̈ʒu𐔒lŕԂ܂B

  FORCEF}[Nݒ肳ĂȂꍇɏp邩H
        t       G[ƂȂA֐nilԂ
        nil     G[Ƃ


mark-dialog-box
[       type]: Function
[  arguments]: mark-dialog-box
[    package]: editor
[       file]: gmark.l
[    section]: _CAO
[description]: 
}[N_CAO\܂B[C-F2]

}[N_CAÓAO[o}[Nݒ肷邱ƂłÃ|C
gԂړ邱Ƃł܂B

  ړ   : I}[NɈړ܂B
  ǉ   : }[Nǉ܂B
  폜   : I}[N폜܂B
  S폜 : SẴ}[N폜܂B


mark-page
[       type]: Function
[  arguments]: mark-page &optional (ARG 0)
[    package]: editor
[    seealso]: forward-page , backward-page
[       file]: page.l
[    section]: |WV
[description]: 
y[Wŋ؂ꂽ̈[Wɐݒ肵܂B[C-x C-p]
y[WꍇAobt@Ŝ[WɂȂ܂B

  ARG : y[Wʒuw肵܂BftHg 0 łB


mark-paragraph
[       type]: Function
[  arguments]: mark-paragraph
[    package]: editor
[       file]: paragrph.l
[    section]: [W
[description]: 
i̖Ƀ}[NA擪Ƀ|Cgݒ肵܂B[ESC h]


mark-sexp
[       type]: Function
[  arguments]: mark-sexp &optional (ARG 1)
[    package]: editor
[    seealso]: set-mark-command
[       file]: sexp.l
[    section]: ֐
[description]: 
OS̖Ƀ}[Nݒ肵܂B[ESC NUL]


mark-whole-buffer
[       type]: Function
[  arguments]: mark-whole-buffer &optional ARG
[    package]: editor
[       file]: cmds.l
[    section]: [W
[description]: 
obt@Ŝ[Wɂ܂B

ARG 
  nil Ȃobt@̖Ƀ}[Nݒ肵Aobt@̐擪Ɉړ
  non-nil Ȃobt@̐擪Ƀ}[Nݒ肵Aobt@̖Ɉړ


mark-word
[       type]: Function
[  arguments]: mark-word &optional (ARG 1)
[    package]: editor
[    seealso]: set-mark-command , forward-word
[       file]: cmds.l
[    section]: [W
[description]: 
J[\ʒuO̒P̖Ƀ}[Nݒ肵܂B[ESC @]
J[\P̓rɂꍇ́A̒P̖Ƀ}[Nݒ肵܂B


marker-buffer
[       type]: Function
[  arguments]: marker-buffer MARKER
[    package]: editor
[       file]: builtin.l
[    section]: |WV
[description]: 
}[J[ݒ肳Ăobt@Ԃ܂B

gpF
  (marker-buffer m)
  => #<buffer: *scratch*>


marker-point
[       type]: Function
[  arguments]: marker-point MARKER
[    package]: editor
[    seealso]: mark , set-marker
[   referred]: command-output-send-input , make-marker
[       file]: builtin.l
[    section]: |WV
[description]: 
}[J[̈ʒu𐔒lŕԂ܂B
}[J[̈ʒuݒ肳ĂȂ폜Ă肵ꍇ nil Ԃ܂B

gpF
  (marker-point m)
  => 62


markerp
[       type]: Function
[  arguments]: markerp OBJECT
[    package]: editor
[    seealso]: make-marker
[       file]: builtin.l
[    section]: f[^^
[description]: 
w肳ꂽOBJECT}[J[Ԃ܂B

  t     OBJECT̓}[J[
  nil   OBJECT̓}[J[ł͂Ȃ


mask-field
[       type]: Function
[  arguments]: mask-field BYTESPEC INTEGER
[    package]: lisp
[    seealso]: ldb
[       file]: number.l
[    section]: l
[description]: 
w肳ꂽtB[hȊO 0 ƂlԂ܂B

  ;; ldb Ƃ̔r
  (format nil "~2,'0x" (ldb (byte 4 4) #xaf))
  =>"0a"
  (format nil "~2,'0x" (mask-field (byte 4 4) #xaf))
  =>"a0"


match-beginning
[       type]: Function
[  arguments]: match-beginning REGNUM
[    package]: editor
[    seealso]: match-end , match-string
[   referred]: scan-buffer
[       file]: builtin.l
[    section]: EK\
[description]: 
K\gɈv擪̃|Cg擾ł܂B

  REGNUM : 擾w
        0̏ꍇ         K\ŜɈv镶擾
        1-9̏ꍇ       K\REGNUMԖڂ̊ʂɑΉ擾


match-data
[       type]: Function
[  arguments]: match-data &optional DATA
[    package]: editor
[    seealso]: store-match-data , scan-buffer
[   referred]: match-string , replace-match
[       file]: builtin.l
[    section]: EK\
[description]: 
scan-buffer Ō_̏Ԃێ܂B̌ŁA
̌ʂ match-string / match-beginning / match-end / replace-match 
sƂ\łB

gpF
  ;;; J[\abcdefƕ񂪂ꍇ
  ;;; 2񂵂Ă炻̌ʂꂼ擾B
  (let (1st 2nd)
    ; 
    (scan-buffer "a\\(\\w*\\)" :regexp t)
    (setq 1st (match-data))
    (scan-buffer "abc\\(\\w*\\)" :regexp t)
    (setq 2nd (match-data))
    ; ʎQ
    (store-match-data 1st)
    (msgbox "~A" (match-string 1))
    (store-match-data 2nd)
    (msgbox "~A" (match-string 1)))


match-end
[       type]: Function
[  arguments]: match-end REGNUM
[    package]: editor
[    seealso]: match-beginning , match-string
[   referred]: scan-buffer
[       file]: builtin.l
[    section]: EK\
[description]: 
K\gɈvŌ̃|Cg擾ł܂B

  REGNUM : 擾w
        0̏ꍇ         K\ŜɈv镶擾
        1-9̏ꍇ       K\REGNUMԖڂ̊ʂɑΉ擾


match-string
[       type]: Function
[  arguments]: match-string REGNUM
[    package]: editor
[    seealso]: match-beginning , match-end , match-data , store-match-data , scan-buffer , K\̕\L
[   referred]: string-looking-at
[       file]: builtin.l
[    section]: EK\
[description]: 
K\gɈv擾邱Ƃł܂B
(buffer-substring (match-beginning REGNUM) (match-end REGNUM))Ɉv܂B

  REGNUM : 擾w
        0̏ꍇ         K\ŜɈv镶擾
        1-9̏ꍇ       K\REGNUMԖڂ̊ʂɑΉ擾

gpF
  ;;; ɌLisp̃Rg擾B
  (progn
    (scan-buffer ";\\([^;\n]+\\)" :regexp t :no-dup nil)
    (match-string 1))


max
[       type]: Function
[  arguments]: max NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: min
[       file]: builtin.l
[    section]: l
[description]: 
̒ōő̐lԂ܂B

gpF  
  (max 3)
  => 3
  (max -3 0 2)
  => 2
  (max 2.5 1)
  => 2.5
  (max 3 2.5)
  => 3


mc-autoload
[       type]: Function
[  arguments]: mc-autoload FN FILE &optional COMMANDP MACROP ENCODING
[    package]: lisp
[    seealso]: autoload , mc-load-library , mc-load-file
[       file]: misc.l
[    section]: ]
[description]: 
Shift_JIS ȊÕGR[fBÕt@Cɒ`ꂽ֐ autoload 悤ݒ肵܂B

  FN       : ֐V{
  FILE     : ֐`ꂽt@C
  COMMANDP : interactive ֐ǂ
  MACROP   : }Nǂ
  ENCODING : FILE ǂݍލۂ̃GR[fBO


mc-load-file
[       type]: Function
[  arguments]: mc-load-file FILENAME &optional ENCODING
[    package]: lisp
[    seealso]: load-file , mc-autoload , mc-load-library
[       file]: misc.l
[    section]: ]
[description]: 
Shift_JIS ȊÕGR[fBÕt@Cǂݍ݂܂B
mc-load-library ƈႢA*load-path* ɂȂt@Cǂݍ߂܂B
  
  FILENAME : t@CitpXj
  ENCODING : ǂݍރt@C̃GR[fBO


mc-load-library
[       type]: Function
[  arguments]: mc-load-library FILENAME &key :encoding :no-suffix (:if-does-not-exist :error)
[    package]: lisp
[    seealso]: load-library , mc-autoload , mc-load-file
[       file]: misc.l
[    section]: ]
[description]: 
Shift_JIS ȊÕGR[fBÕt@Cǂݍ݂܂B

  FILENAME           : t@C
  :encoding          : ǂݍރt@C̃GR[fBO
  :no-suffix         : t@C *load-path* Tǂw肵܂B
        t                t@C find-load-path ŒT܂B
        nil              FILENAME ̂܂܎g܂B
  :if-does-not-exist : t@CȂꍇ̋w肵܂B
        :error           G[Ԃ܂BftHg̋łB
        ȊO         nil Ԃ܂B


member
[       type]: Function
[  arguments]: member ITEM LIST &key :test :test-not :key
[    package]: lisp
[    seealso]: member-if , member-if-not , find , position , getf
[       file]: builtin.l
[    section]: Xg
[description]: 
LIST ̒ ITEM Ƃ :test 𖞂̂ΈvƂ납̃XgԂ܂B
Ȃ nil Ԃ܂B

gpF
  (member 'e '(a b c d))
  => nil
  (member 'b '(a b c d))
  => (b c d)


member-if
[       type]: Function
[  arguments]: member-if PREDICATE LIST &key :key
[    package]: lisp
[    seealso]: member , member-if-not
[       file]: builtin.l
[    section]: Xg
[description]: 
LIST ̒ŏ PREDICATE 𖞂̂΁ÃXgԂ܂B
Ȃ nil Ԃ܂B

gpF
  (member-if #'numberp '(a b c))
  => nil
  (member-if #'numberp '(a b 3 c))
  => (3 c)


member-if-not
[       type]: Function
[  arguments]: member-if-not PREDICATE LIST &key :key
[    package]: lisp
[    seealso]: member , member-if
[       file]: builtin.l
[    section]: Xg
[description]: 
LIST ̒ŏ PREDICATE 𖞂Ȃ̂΁ÃXgԂ܂B
Ȃ nil Ԃ܂B

gpF
  (member-if-not #'numberp '(1 2 3))
  => nil
  (member-if-not #'numberp '(1 2 a 3))
  => (a 3)


menup
[       type]: Function
[  arguments]: menup OBJECT
[    package]: editor
[       file]: builtin.l
[    section]: j[
[description]: 
IuWFNgj[ǂԂ܂B

  OBJECT : 肷IuWFNg

  t   IuWFNg̓j[
  nil IuWFNg̓j[ł͂Ȃ


merge
[       type]: Function
[  arguments]: merge RESULT-TYPE SEQUENCE1 SEQUENCE2 PREDICATE &key :key
[    package]: lisp
[    seealso]: union , concatenate , stable-sort
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE1SEQUENCE2𕹍܂BSEQUENCE1SEQUENCE2͔j󂳂܂B
PREDICATEɂSEQUENCE1SEQUENCE2̒lrAnilȂ SEQUENCE1̒l 
nil Ȃ SEQUENCE2̒lɃ}[WĂ܂B

  RESULT-TYPE : ʂƂȂV[PX̌^w肵܂B
  PREDICATE   : V[PXmr֐w肵܂B
  :key        : rΏƂ擾֐w肵܂B


  (merge 'list '(1 2 3 5 8) '(2 4 6) #'<) => (1 2 2 3 4 5 6 8)
  (merge 'string "AbCF" "aBcd" #'char-lessp) => "AabBCcdF"


merge-pathnames
[       type]: Function
[  arguments]: merge-pathnames PATHNAME &optional DEFAULTS
[    package]: lisp
[    seealso]: file-namestring , directory-namestring , namestring
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
pXƃt@C܂B

  PATHNAME : t@C̕w肵܂B
  DEFUALTS : pX̕w肵܂B
             w肵Ȃ(default-directory)̃pXgp܂B

gpF
  ;;; "c:/foo""bar.l"B
  (merge-pathnames "bar.l" "c:/foo")
  => "c:/foo/bar.l"

  (merge-pathnames "bar.l" "c:/foo/") <--fBNg̖/
  => "c:/foo/bar.l"                      Ă邩ƂCɂȂĂB


message
[       type]: Function
[  arguments]: message FMT &rest ARGS
[    package]: lisp
[    seealso]: clear-message , msgbox , message-box , minibuffer-message , with-interval-message , format , *status-window* , status-window-stream-p
[       file]: misc.l
[    section]: o
[description]: 
bZ[WXe[^Xo[ɏo͂܂B

  FMT  : formatl̏wł܂B
  ARGS : o͏ւ̃p^ƂȂ܂B


message-box
[       type]: Function
[  arguments]: message-box MESSAGE &optional TITLE STYLES &key :button1 :button2 :button3 :button4 :button5 :no-wrap
[    package]: editor
[    seealso]: yes-or-no-p , msgbox
[   referred]: message
[       file]: builtin.l
[    section]: _CAO
[description]: 
yes-or-no-p n_ȃ_CAO\܂B

  MESSAGE  : _CAOɕ\郁bZ[Ww肵܂B
  TITLE    : _CAÕ^Cgw肵܂B
  STYLES   : _CAÕX^CXgŎw肵܂B
        :ok                     [OK] \܂B
        :ok-cancel              [OK][LZ] \܂B
        :yes-no                 [͂][] \܂B
        :yes-no-cancel          [͂][][LZ] \܂B
        :abort-retry-ignore     [~][Ďs][] \܂B
        :information            (i) CtH[V}[N\܂B
        :exclamation            (!) Q\܂B
        :question               (?) ^╄\܂B
        :button1                {^ 1 ftHgIɂ܂B
        :button2                {^ 2 ftHgIɂ܂B
        :button3                {^ 3 ftHgIɂ܂B
        :button4                {^ 4 ftHgIɂ܂B
        :button5                {^ 5 ftHgIɂ܂B
  :BUTTON1 : {^ 1 ̃eLXgύX܂B
  :BUTTON2 : {^ 2 ̃eLXgύX܂B
  :BUTTON3 : {^ 3 ̃eLXgύX܂B
  :BUTTON4 : {^ 4 ̃eLXgύX܂B
  :BUTTON5 : {^ 5 ̃eLXgύX܂B
  :NO-WRAP : MESSAGE Ƃɐ܂Ԃ𐧌䂵܂B
        t       Ƃ܂ԂȂB
        nil     ΐ܂ԂB

{^Ƃ̖߂ĺAꂼȉ̂ƂłB

  :ok     [OK] I
  :cancel [LZ] I
  :yes    [͂] I
  :no     [] I
  :abort  [~] I
  :retry  [Ďs] I
  :ignore [] I

gpF
  ;;; [͂][][LZ] \I܂B
  (message-box "[𑗐M܂?" nil
    '(:yes-no-cancel :question :button1))
  => :yes

  ;;; _CAǑʂ case ŏꍇ킯Ă݂
  (case (message-box "[𑗐M܂?" nil
                     '(:yes-no-cancel :question :button1))
    (:yes (den8-draft-send t))
    (:no t)
    (t nil))


meta-prefix
[       type]: Function
[  arguments]: meta-prefix
[    package]: editor
[    seealso]: esc-map
[       file]: keymap.l
[    section]: L[}bv
[description]: 
ESC vtBbNXłB [ESC]

meta-prefix ̊֐Z͕ʂ̃R}hł͂Ȃ esc-map ƂL[}b
vێĂ܂B


min
[       type]: Function
[  arguments]: min NUMBER &rest MORE-NUMBERS
[    package]: lisp
[    seealso]: max
[       file]: builtin.l
[    section]: l
[description]: 
̒ōŏ̐lԂ܂B

gpF
  (min 3)
  => 3
  (min -2 0 3)
  => -2
  (min 2.5 1)
  => 1


minibuffer-message
[       type]: Function
[  arguments]: minibuffer-message FMT &rest ARGS
[    package]: editor
[    seealso]: clear-minibuffer-message , minibuffer-prompt , format
[   referred]: message
[       file]: misc.l
[    section]: ~jobt@
[description]: 
ɏ]ă~jobt@ɃbZ[W\܂B 
~jobt@ɃJ[\\ȂȊO minibuffer-prompt ƓH

  FMT  : format l̏
  ARGS : o͏ւ̃p^


minibuffer-prompt
[       type]: Function
[  arguments]: minibuffer-prompt FMT &rest ARGS
[    package]: editor
[   referred]: clear-minibuffer-message , minibuffer-message
[       file]: misc.l
[    section]: ~jobt@
[description]: 
ɏ]ă~jobt@ɃbZ[W\܂B
̌read-chargăL[{[h當ǂݍ߂΁A
Â~jobt@̓͂\ɂȂ܂B

  FMT  : formatl̏wł܂B
  ARGS : o͏ւ̃p^ƂȂ܂B

gpF
  ;;; ȉ̂悤ɂƁApX[h͂̂悤ɃGR[obNȂB
  minibuffer͂\
  (defun test1 ()
    (interactive)
    (let ((ans ""))
      (loop
        (minibuffer-prompt "From ~d: " 12)
        (let ((c (read-char *keyboard*)))
          (case c
            (#\RET (return ans))
            (#\C-g (quit))
            (t (setq ans (format nil "~a~c" ans c))))))))  

QlF
  wip/ftp.lgetpass


minibuffer-window
[       type]: Function
[  arguments]: minibuffer-window
[    package]: editor
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@̃EChE擾܂B

gpF
  ;;; ~jobt@ɈړB
  (set-window (minibuffer-window))


minibuffer-window-p
[       type]: Function
[  arguments]: minibuffer-window-p WINDOW
[    package]: editor
[   referred]: delete-window
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
EBhE~jobt@ǂԂ܂B

  WINDOWF~jobt@ǂ𒲂ׂEBhE 

  t     ~jobt@ł
  nil   ~jobt@ł͂Ȃ

gpF
  ;;; ~jobt@ł͕ʂ̃obt@ɕύXłȂ̂ŕʂ̃EBhEɈړB
  (if (minibuffer-window-p (selected-window))
      (other-window))
  => t


minor-mode-map
[       type]: Function
[  arguments]: minor-mode-map &optional BUFFER
[    package]: editor
[    seealso]: set-minor-mode-map
[       file]: builtin.l
[    section]: [h
[description]: 
set-minor-mode-mapŐݒ肵L[}bv擾܂B


minusp
[       type]: Function
[  arguments]: minusp NUMBER
[    package]: lisp
[    seealso]: plusp
[       file]: builtin.l
[    section]: l
[description]: 
NUMBER [菬 t AłȂ nil Ԃ܂B

gpF
  (minusp 0)
  => nil
  (minusp -1)
  => t
  (minusp -0.00001)
  => t


mismatch
[       type]: Function
[  arguments]: mismatch SEQUENCE1 SEQUENCE2 &key :from-end :test :test-not (:key #'identity) (:start1 0) (:start2 0) :end1 :end2
[    package]: lisp
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE1  SEQUENCE2 rAvȂvf̃CfbNXԂ܂B

  :start1  SEQUENCE1 ̔rJnʒu
  :start2  SEQUENCE2 ̔rJnʒu
  :end1    SEQUENCE1 ̔rIʒu
  :end2    SEQUENCE2 ̔rIʒu

:start1  :start2 ̒lقȂꍇASEQUENCE1 ł̃CfbNXԂ܂B

gp:
  (mismatch "abcd" "abxd")
  => 2

l:
  :from-end ͎ĂȂ悤łB


mod
[       type]: Function
[  arguments]: mod NUMBER DIVISOR
[    package]: lisp
[    seealso]: floor , rem
[       file]: builtin.l
[    section]: l
[description]: 
(floor NUMBER DIVISOR)̖߂l̓ڂԂ܂B

gpF
  (mod 13 4)
  => 1
  (mod -13 4)
  => 3


mode-line-format
[       type]: BufferLocal
[    package]: editor
[    seealso]: update-mode-line , title-bar-format
[    section]: EBhE
[description]: 
[hC̃tH[}bgݒ肵܂B
^Cgo[̃tH[}bgƓlł̂ŁAtitle-bar-formatQƂĉB


mode-name
[       type]: BufferLocal
[    package]: editor
[    seealso]: buffer-mode
[    section]: ϐƒ萔
[description]: 
[h̖Oi[Ă郍[JϐłB
Hmode-namebuffer-mode͕K[JϐɂȂ̂ł傤H


mode-specific-indent-command
[       type]: BufferLocal
[    package]: editor
[    seealso]: indent-region
[    section]: [h
[description]: 
indent-regionQƂ̂

gpF
  ;;; Kȃ[hňȉevalĂ݂ƁA
  ;;; "x:" ̂悤ȍs͍sɂȂAȊO̍s8ڂɂȂB
  (progn
    (make-local-variable 'mode-specific-indent-command)
    (setq mode-specific-indent-command
        #'(lambda () (save-excursion
                       (goto-bol)
                       (delete-horizontal-spaces)
                       (or (looking-at "^\\w+:") (indent-to 8))))))


modify-text-attributes
[       type]: Function
[  arguments]: modify-text-attributes TAG &key :foreground :background :bold :underline :strike-out :prefix :extend :start :end :test :test-not :key
[    package]: editor
[    seealso]: set-text-attribute
[   referred]: find-text-attribute-point , modify-text-attributes-if , modify-text-attributes-if-not
[       file]: builtin.l
[    section]: eLXg
[description]: 
set-text-attribute ŕẗ̑ύX܂B
͈p܂B
Ⴆ΁Aset-text-attribute ł :underline t ƂĂA
modify-text-attributes  :strike-out t ƂĂA
Ǝ̗\ł͂܂B

  TAG           set-text-attributeŎw肵^O
  :bold         {[hŕ\邩ǂ
  :underline    tŕ\邩ǂ
  :strike-out   \邩ǂ
  :foreground   F𐮐Ŏw
  :background   wiF𐮐Ŏw
  :prefix       g͕s
  :extend       s̉sȍ~ς邩ǂ

gpF
  ;;; obt@ŜɉtĂɂB
  (set-text-attribute (point-min) (point-max) 'all :bold t :foreground 1)
  => t
  (modify-text-attributes 'all :strike-out t)
  => t
  (delete-text-attributes 'all)
  => t


modify-text-attributes-if
[       type]: Function
[  arguments]: modify-text-attributes-if TEST &key :foreground :background :bold :underline :strike-out :prefix :extend :start :end :key
[    package]: editor
[    seealso]: modify-text-attributes-if-not , modify-text-attributes , set-text-attribute
[       file]: builtin.l
[    section]: eLXg
[description]: 
eLXĝA^O TEST 𖞂ׂ̂ĂɂāAύX܂B
͈p܂B
͈͂w肵ꍇAJn_͈͂Ɋ܂܂̂̂ݕύX܂B

  :bold        {[hŕ\邩ǂ
  :underline   tŕ\邩ǂ
  :strike-out  \邩ǂ
  :foreground  F𐮐Ŏw
  :background  wiF𐮐Ŏw
  :prefix      sԍɕ\镶
  :extend      s̉sȍ~ς邩ǂ
  :start       Jnʒu
  :end         Iʒu
  :key         TEST ɓnOɃ^OɓKp֐


modify-text-attributes-if-not
[       type]: Function
[  arguments]: modify-text-attributes-if-not TEST &key :foreground :background :bold :underline :strike-out :prefix :extend :start :end :key
[    package]: editor
[    seealso]: modify-text-attributes , modify-text-attributes-if
[       file]: builtin.l
[    section]: eLXg
[description]: 
eLXĝA^O TEST 𖞂Ȃׂ̂ĂɂāAύX܂B
͈p܂B
͈͂w肵ꍇAJn_͈͂Ɋ܂܂̂̂ݕύX܂B

  :bold        {[hŕ\邩ǂ
  :underline   tŕ\邩ǂ
  :strike-out  \邩ǂ
  :foreground  F𐮐Ŏw
  :background  wiF𐮐Ŏw
  :prefix      sԍɕ\镶
  :extend      s̉sȍ~ς邩ǂ
  :start       Jnʒu
  :end         Iʒu
  :key         TEST ɓnOɃ^OɓKp֐


mouse-menu-popup
[       type]: Function
[  arguments]: mouse-menu-popup &optional APPS
[    package]: editor
[   referred]: apps-popup
[       file]: mouse.l
[    section]: j[
[description]: 
|bvAbvj[\܂B[RBtnUp]

  APPS  : j[̕\ʒuw肵܂B
     nil      }EXJ[\ʒu
     non-nil  J[\ʒu


msgbox
[       type]: Function
[  arguments]: msgbox FMT &rest ARGS
[    package]: editor
[    seealso]: message-box , format
[   referred]: message
[       file]: misc.l
[    section]: _CAO
[description]: 
bZ[W{bNX\܂B
[OK] {^ƃCtH[VACR\܂B

  FMT  : format ̏o͏Ɠ̂wł܂B
  ARGS : o͏ւ̃p^ƂȂ܂B

߂l :ok ƂȂ܂B

gpF
  ;;; o͏Ő`Ă݂B
  (msgbox "̃obt@ ~A łB" buffer-mode)
  => :ok


multiple-value-bind
[       type]: Special Form
[  arguments]: multiple-value-bind ({VAR}*) VALUES-FORM {declaration}* {FORM}*
[    package]: lisp
[    seealso]: values , multiple-value-list , multiple-value-setq
[   referred]: multiple-value-call , multiple-value-prog1
[       link]: http://www.geocities.jp/m_hiroi/
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
tH[Ԃl󂯎܂BL䂳"xyzzy Lisp Programming"
Ղ̂Ōfڂ̋𒸂܂BȉQƂĉB

--- pJn  ---
̒l󂯎ɂ́A}N multiple-value-bind gƊȒPłB 

multiple-value-bind (&rest vars) values-form &rest form

multiple-value-bind ́AlԂ֐ values-form ]Ǎʂ 
vars Œ`ϐɃZbg܂Bϐ͋ǏϐƂĐݒ肳̂ŁA
multiple-value-bind sĂԂLłBȒPȗ܂傤B
Common Lisp ɂ́AłȂl𐮐ɕϊ֐ floor, ceiling, 
truncate, round `Ă܂B̊֐͂Q̒liljԂ܂B

  (truncate 10 3)
  => 3

  (multiple-value-bind
  (q r)
  (truncate 10 3)
  (format nil " ~D, ] ~D~%" q r))
  => " 3, ] 1"

֐ truncate ͊ZsďƗ]Ԃ܂Bӂ truncate 
яoƏԂłAmultiple-value-bind gƁÂقɗ]
󂯎邱Ƃł܂Bq  r  truncate Ԃl󂯎ϐłB
ɁAtruncate ]ČʂϐɃZbg܂BƂ́Ac form 
Ԃɕ]Ă܂B multiple-value-bind ͍Ōɕ] form 
lԂ܂B

AԂlϐ̌ꍇAc̕ϐɂ nil Zb
g܂BtɁAԂlϐꍇA]Ȓl͎̂Ă܂B
̗ĂB

  (multiple-value-bind (q)
  (truncate 10 3)
  (list q))
  => (3)
  
  (multiple-value-bind (q r s)
  (truncate 10 3)
  (list q r s))
  => (3 1 nil)

ŏ̗ł́Aϐ q `ĂȂ̂ŁA q ɂ͏Zbg܂
]͎̂Ă܂B̗ł́Aϐ s `Ă܂Atruncate 
͂Q̒lԂȂ̂ŁA s ɂ nil Zbg܂B
--- pI ---


multiple-value-call
[       type]: Special Form
[  arguments]: multiple-value-call FUNCTION {FORM}*
[    package]: lisp
[    seealso]: multiple-value-bind , apply , values
[   referred]: multiple-value-list
[       file]: builtin.l
[    section]: \
[description]: 
FORM ̖߂lƂ FUNCTION Ăт܂B
apply ƈđlŕԂꂽԖڈȍ~̖߂ln܂B

gpF
  (multiple-value-call #'+ (values 1 2 3) (values 4 5))
  => 15


multiple-value-list
[       type]: Macro
[  arguments]: multiple-value-list FORM
[    package]: lisp
[    seealso]: values , multiple-value-call , multiple-value-bind , multiple-value-setq
[       file]: evalmacs.l
[    section]: ϐƒ萔
[description]: 
֐ԂlXgŕԂ܂B

gpF
  (defun foo () (values 1 2 3))
  => foo
  (foo)
  => 1
     2
     3
  (multiple-value-list (foo))
  => (1 2 3)


multiple-value-prog1
[       type]: Special Form
[  arguments]: multiple-value-prog1 FORM {FORM}*
[    package]: lisp
[    seealso]: prog1 , values , multiple-value-bind
[       file]: builtin.l
[    section]: \
[description]: 
tH[Ԃɕ]čŏ̃tH[̌ʂ𑽒lŕԂ܂B

prog1 ɎĂ܂Aŏ̃tH[lԂꍇł prog1 ̖
l͑lɂȂ܂B


multiple-value-setq
[       type]: Special Form
[  arguments]: multiple-value-setq VARIABLES FORM
[    package]: lisp
[    seealso]: multiple-value-bind , multiple-value-list
[   referred]: values
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
ԂꂽlX̕ϐɐݒ肵܂B
ϐ̌tH[Ԃl̐Ƃɂ͗]͎̂Ă
BȂꍇɂ́AȂnilݒ肳܂B

  VARIABLES : ϐ̃Xg
  FORM      : ]tH[

gpF
  ;;; valuesőlԂꍇ
  (setq a (values 1 2)) => 1
  a                     => 1
  (multiple-value-setq (a b) (values 1 2))
                        => 1
  a                     => 1
  b                     => 2


namestring
[       type]: Function
[  arguments]: namestring PATHNAME
[    package]: lisp
[    seealso]: file-namestring , merge-pathnames
[       file]: builtin.l
[    section]: 
[description]: 
PATHNAME̓eɉēK؂ȃtpXԂ悤ȓB^̂t
pXłȂ΁A擪(default-directory)ătpX炵܂B
gpF
  (default-directory)
  =>"C:/Applications/xyzzy/"

  (namestring "abc.txt")
  =>"C:/Applications/xyzzy/abc.txt"

  (namestring "Z:/zzz.txt")
  =>"Z:/zzz.txt"


narrow-to-region
[       type]: Function
[  arguments]: narrow-to-region FROM TO
[    package]: editor
[    seealso]: hide-restricted-region , save-restriction , widen , point-min , point-max
[       file]: builtin.l
[    section]: |WV
[description]: 
w肵͈͈ȊOړEҏWłȂ悤ɂ܂B[C-x n]
save-restrictioñubNI邩Awidenƌɖ߂܂B
point-min, point-max̒lς܂B

gpF
  C-SPCŃ}[NtāAǂɈړāAC-x n(narrow-to-region)Ƃ
  ƁAw肵[W̊Oɂ͈ړłȂȂ܂B͒ûƂɒu
  ͈͂𐧌AL[{[h}N͈̔͂𐧌肷̂ɂ悭g
  ܂BƂ́ALispR[h̒œ͈̔͂ƂȂ񂩂ɂg
  B


nbutlast
[       type]: Function
[  arguments]: nbutlast LIST &optional (N 1)
[    package]: lisp
[    seealso]: butlast
[       file]: list.l
[    section]: Xg
[description]: 
Xg̍ŌNvfXgԂ܂B
 LIST ͔j󂳂܂B

gpF
  ;;; Ō̗vf菜܂B
  (setq foo '(1 2 3))
  => (1 2 3)
  (nbutlast foo)
  => (1 2)
  foo
  => (1 2)


nconc
[       type]: Function
[  arguments]: nconc &rest LISTS
[    package]: lisp
[    seealso]: append
[   referred]: mapcan , mapcon
[       file]: builtin.l
[    section]: Xg
[description]: 
̃XgɂƂĂXgԂ܂B
͔j󂳂܂B

gpF
  ;;; XgĂ݂B
  (setq x '(a b c))
  (setq y '(d e f))
  (nconc x y)
  => (a b c d e f) 
  x
  => (a b c d e f)
  y
  => (d e f)


need-buffer-save-p
[       type]: Function
[  arguments]: need-buffer-save-p BUFFER
[    package]: editor
[    seealso]: need-not-save
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@ۑKvԂ܂B
need-not-saveƊ֘AĂ܂B

  t     obt@̕ۑKv
  nil   obt@̕ۑKvł͂Ȃ


need-not-save
[       type]: BufferLocal
[    package]: editor
[    seealso]: need-buffer-save-p , setup-temp-buffer
[    section]: ϐƒ萔
[description]: 
ۑKv邩ǂݒ肵܂B
X̃obt@̃[hȂ̂ł΁Agp̗lɃ[
Jϐɂ܂BႦ΁A*scratch*̗lɏ̂Ă肷obt@ł́A
ۑ̕Kv͂Ȃ̂ŁAtɂȂĂ܂B

  t     ۑ̕Kv͂Ȃ
  nil   ۑ

gpF
  ;;; ݂̃obt@͕ۑ̕Kv͂ȂB
  (make-local-variable 'need-not-save)
  => t
  (setq need-not-save t)
  => t


negative-argument
[       type]: Function
[  arguments]: negative-argument RAW &optional ARG
[    package]: editor
[    seealso]: universal-argument , digit-argument
[       file]: cmds.l
[    section]: ֐
[description]: 
ɑR}hɕ̑Oun܂B[ESC -]


new-file
[       type]: Function
[  arguments]: new-file
[    package]: editor
[    seealso]: get-buffer-create , create-new-buffer
[       file]: files.l
[    section]: t@CVXe
[description]: 
t@CɊ֘AtĂȂVobt@ *untitled* ܂B


new-pseudo-frame
[       type]: Function
[  arguments]: new-pseudo-frame NAME &optional SAVE-P SELECTED-FN DELETED-FN
[    package]: editor
[    seealso]: select-pseudo-frame , delete-pseudo-frame , *select-pseudo-frame-hook*
[   referred]: ed::pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
Vt[ĕԂ܂B[C-x 6 2]

  NAME        : t[̖O
  SAVE-P      : ZbVۑɂ̃t[ۑ邩ǂ
  SELECTED-FN : ̃t[IɎs֐
  DELETED-FN  : ̃t[폜Ɏs֐

t[͍\̂ƂĒ`ĂÄ͂ꂼ
̃Xbgɐݒ肳܂B

C^NeBuɌĂ񂾏ꍇ NAME ͎IɊUASAVE-P  t ɐݒ肳܂B
OuČĂׂ NAME ΘbIɓ͂ł܂B


newline
[       type]: Function
[  arguments]: newline &optional (ARG 1)
[    package]: editor
[    seealso]: newline-and-indent
[       file]: cmds.l
[    section]: eLXg
[description]: 
s}܂B[RET], [C-m]


newline-and-indent
[       type]: Function
[  arguments]: newline-and-indent &optional (ARG 1)
[    package]: editor
[    seealso]: newline , indent-relative
[   referred]: delete-indentation
[       file]: cmds.l
[    section]: |WV
[description]: 
sA݂钼O̍sƓCfg܂B
[hɈˑCfgR}h͎gp܂B[LFD], [C-j]


next-buffer
[       type]: Function
[  arguments]: next-buffer
[    package]: editor
[    seealso]: previous-buffer , *next-buffer-in-tab-order* , other-buffer
[   referred]: get-next-buffer
[       file]: buffer.l
[    section]: obt@
[description]: 
̃obt@ɐؑւ܂B [Home]
GfB^ŌݑIĂEBhE̒̃obt@ς邾łB

obt@^ȕԂɂnext-buffer̂Ȃ΁A
*next-buffer-in-tab-order*QƂĉB


next-error
[       type]: Function
[  arguments]: next-error &optional ARG
[    package]: editor
[    seealso]: *error-regexp-list* , first-error
[       file]: errors.l
[    section]: G[
[description]: 
̃G[̊YsɃWv܂B[F11], [C-x `]


next-line
[       type]: Function
[  arguments]: next-line &optional (N 1)
[    package]: editor
[    seealso]: next-virtual-line , previous-line , forward-line , goal-column
[   referred]: next-line-add-newlines
[       file]: cmds.l
[    section]: |WV
[description]: 
Ns̕sɈړ܂B 
ړ̑O goal-column ۑ܂B

߂l:
  1słړłƂ t AȊO nil łB


next-line-add-newlines
[       type]: Variable
[    package]: editor
[    seealso]: next-line
[    section]: |WV
[description]: 
obt@̍Ōnext-linen̈ړƂ̓ݒ肵܂B

  t   s}܂
  nil ܂

gpF
  (setq next-line-add-newlines t)


next-page
[       type]: Function
[  arguments]: next-page &optional (ARG 1)
[    package]: editor
[    seealso]: previous-page , *page-scroll-half-window* , *page-scroll-keep-window-position* , *next-screen-context-lines*
[       file]: page.l
[    section]: EBhE
[description]: 
wy[WʂXN[܂B[C-v], [PageDown]
*page-scroll-half-window*  non nil Ȃ甼ʂXN[܂B


next-pseudo-frame
[       type]: Function
[  arguments]: next-pseudo-frame
[    package]: editor
[    seealso]: previous-pseudo-frame , other-pseudo-frame , switch-pseudo-frame
[    section]: EBhE
[description]: 
other-pseudo-frame ̕ʖłB


next-virtual-line
[       type]: Function
[  arguments]: next-virtual-line &optional (N 1)
[    package]: editor
[    seealso]: next-line
[       file]: cmds.l
[    section]: |WV
[description]: 
Ns̕\sɈړ܂B [C-n], [Down]
  t    ŏIsȊȌꍇ
  nil  ŏIs̏ꍇ


next-window
[       type]: Function
[  arguments]: next-window WINDOW &optional MINIBUF
[    package]: editor
[    seealso]: previous-window , set-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
WINDOW ̎̃EBhEԂ܂B

  MINIBUF : ~jobt@EBhEɓ邩
       nil    
   non-nil    ɓ


next-word
[       type]: Function
[  arguments]: next-word &optional (ARG 1)
[    package]: editor
[    seealso]: forward-word
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\O̒P̐擪Ɉړ܂B


next-xyzzy-window
[       type]: Function
[  arguments]: next-xyzzy-window
[    package]: editor
[    seealso]: previous-xyzzy-window , list-xyzzy-windows
[       file]: builtin.l
[    section]: vZX
[description]: 
xyzzyɈړ܂B
ړ͋NłB


nil
[       type]: Variable
[    package]: lisp
[    seealso]: t
[    section]: ϐƒ萔
[description]: 
U\萔łB


nintersection
[       type]: Function
[  arguments]: nintersection LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: intersection
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 ̗Ɋ܂܂vf̃XgĕԂ܂B
intersection ƈႢ LIST1 ͔j󂳂܂B

gp:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 5 7 11))
  => (2 3 5 7 11)
  (nintersection x y)
  => (3 5 7)
  x
  => (1 3 5 7)
  y
  => (2 3 5 7 11)


ninth
[       type]: Function
[  arguments]: ninth X
[    package]: lisp
[    seealso]: nth
[       file]: list.l
[    section]: Xg
[description]: 
list  9 Ԗڂ̗vfԂ܂B

  (ninth X) = (nth 8 X)

gpF
  (ninth '(1 2 3 4 5 6 7 8 9 0))
  => 9


no-or-yes-p
[       type]: Function
[  arguments]: no-or-yes-p FMT &rest ARGS
[    package]: lisp
[    seealso]: yes-or-no-p , y-or-n-p , yes-no-or-cancel-p
[       file]: misc.l
[    section]: _CAO
[description]: 
u͂vuṽ{^tbZ[W{bNX\܂B
ftHǵuvłB

  t     u͂vI
  nil   uvI

gpF
  ;;; _CAO\đIB
  (no-or-yes-p "foo")
  => t          ; u͂vI


not
[       type]: Function
[  arguments]: not X
[    package]: lisp
[    seealso]: null
[   referred]: complement
[       file]: evalmacs.l
[    section]: ̑
[description]: 
ےԂ܂B
non nilȂnilԂAnilȂtԂ܂B@\ƂĂnullƓłB


not-modified
[       type]: Function
[  arguments]: not-modified
[    package]: editor
[    seealso]: set-buffer-modified-p
[       file]: buffer.l
[    section]: obt@
[description]: 
obt@̕ύXtONA܂B[ESC ~]
܂ύXĂȂƂɂȂ܂B
(set-buffer-modified-p nil)interactivełłB


notany
[       type]: Function
[  arguments]: notany PREDICATE SEQUENCE &rest MORE-SEQUENCES
[    package]: lisp
[    seealso]: notevery , some
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE̐擪̗vf珇ԂPREDICATEKpĂAPREDICATE
nilȒlԂƁA nil ɕԂ܂B
PREDICATE𖞂vfȂ t Ԃ܂B

MORE-SEQUNCES^ꂽASEQUENCE̒ōłẐ̏I܂Ŏs܂B


notevery
[       type]: Function
[  arguments]: notevery PREDICATE SEQUENCE &rest MORE-SEQUENCES
[    package]: lisp
[    seealso]: notany , every
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE̐擪̗vf珇ԂPREDICATEKpĂAPREDICATE
nil ԂƁAt ɕԂ܂B
SĂ̗vfPREDICATE𖞂ꍇA nil Ԃ܂B

MORE-SEQUNCES^ꂽASEQUENCE̒ōłẐ̏I܂Ŏs܂B


nreconc
[       type]: Function
[  arguments]: nreconc X Y
[    package]: lisp
[    seealso]: revappend
[       file]: builtin.l
[    section]: Xg
[description]: 
X 𔽓] Y XgԂ܂B
 X ͔j󂳂܂B

  (nreconc x y) == (nconc (nreverse x) y)

nreconc̕ǂ悤łB


nreverse
[       type]: Function
[  arguments]: nreverse SEQUENCE
[    package]: lisp
[    seealso]: reverse
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE tɂVV[PX쐬ĕԂ܂B
 SEQUENCE ͔j󂳂܂B

gpF
  (setq lst '(a b c))
  => (a b c)
  (nreverse lst)
  => (c b a)
  lst
  => (a)


nset-difference
[       type]: Function
[  arguments]: nset-difference LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: set-difference
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 ɂ܂܂vfÃXgԂ܂B
set-difference ƈႢ LIST1 ͔j󂳂܂B

gp:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 7))
  => (2 3 7)
  (nset-difference x y)
  => (1 5 9)
  x
  => (1 5 9)


nset-exclusive-or
[       type]: Function
[  arguments]: nset-exclusive-or LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: set-exclusive-or
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 ̂ꂩɂ̂݊܂܂vf̃XgĕԂ܂B
set-exclusive-or ƈႢ LIST2 ͔j󂳂܂B

gp:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 5 7 11))
  => (2 3 5 7 11)
  (nset-exclusive-or x y)
  => (9 1 2 11)
  x
  => (1 3 5 7 9)
  y
  => (2 11)


nstring-capitalize
[       type]: Function
[  arguments]: nstring-capitalize STRING &key :start :end
[    package]: lisp
[    seealso]: string-capitalize
[       file]: builtin.l
[    section]: 
[description]: 
STRING ̓̒P̐擪啶ɁAȊOɂԂ܂B
 STRING ͔j󂳂܂B

gpF  
  (setq foo "tHis iS a pEn.")
  => "tHis iS a pEn."
  (nstring-capitalize foo)
  => "This Is A Pen."
  foo
  => "This Is A Pen."


nstring-downcase
[       type]: Function
[  arguments]: nstring-downcase STRING &key :start :end
[    package]: lisp
[    seealso]: string-downcase
[       file]: builtin.l
[    section]: 
[description]: 
STRING ɂԂ܂B STRING ͔j󂳂܂B

gpF  
  (setq foo "XyZzY")
  => "XyZzY"
  (nstring-downcase foo)
  => "xyzzy"
  foo
  => "xyzzy"  


nstring-upcase
[       type]: Function
[  arguments]: nstring-upcase STRING &key :start :end
[    package]: lisp
[    seealso]: string-upcase
[       file]: builtin.l
[    section]: 
[description]: 
STRING 啶ɂԂ܂B STRING ͔j󂳂܂B

gpF
  (setq foo "xyzzy")
  => "xyzzy"
  (nstring-upcase foo)
  => "XYZZY"
  foo
  => "XYZZY"


nsublis
[       type]: Function
[  arguments]: nsublis ALIST TREE &key :test :test-not :key
[    package]: lisp
[    seealso]: sublis , nsubst
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE ̒ ALIST  :key Ƃ :test 𖞂̂ VALUE ɒuXgԂ܂B
 TREE ͔j󂳂܂B

gpF
  ;;; foo̕ϊe[u̓eɊÂbarϊ܂B
  (setq foo '((1 . #\a) (2 . #\b) (3 . #\c)))
  => ((1 . #\a) (2 . #\b) (3 . #\c))
  (setq bar '(1 (2 3) ((4 5 6) (7 8 9))))
  => (1 (2 3) ((4 5 6) (7 8 9)))
  (nsublis foo bar)
  => (#\a (#\b #\c) ((4 5 6) (7 8 9)))
  bar
  => (#\a (#\b #\c) ((4 5 6) (7 8 9)))


nsubst
[       type]: Function
[  arguments]: nsubst NEW OLD TREE &key :test :test-not :key
[    package]: lisp
[    seealso]: subst , nsublis , nsubst-if , nsubst-if-not , nsubstitute
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE ̒ OLD  NEW ɒuTREEԂ܂B
 TREE ͔j󂳂܂B

gpF
  ;;; Kŵc[nsubstĂ݂Ba͔j󂳂B
  (setq a '((1 2) ((1 3) (1 4))))       => ((1 2) ((1 3) (1 4)))
  (nsubst 5 1 a)                        => ((5 2) ((5 3) (5 4)))
  a                                     => ((5 2) ((5 3) (5 4)))


nsubst-if
[       type]: Function
[  arguments]: nsubst-if NEW TEST TREE &key :key
[    package]: lisp
[    seealso]: subst-if , nsubst-if-not , nsubst , nsubstitute-if
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE̒TEST𖞂̂NEWɒûԂ܂B
TREEj󂳂_subst-ifƓłB

  NEW  : uvf
  TEST : u邩ǂ𔻒肷eXg
         non-nilԂu܂B
  TREE : Ώۂ̃c[

TEST̈ɂĂsubst-ifQƂĉB

gpF
  ;;; Kȃc[pӂāA̗vfȂ0ɒuB
  (setq a '((1 2) ((1 3) (1 (1 3)))))
  => ((1 2) ((1 3) (1 (1 3))))
  (nsubst-if 0 #'(lambda (x) (and (integerp x) (oddp x))) a)
  => ((0 2) ((0 0) (0 (0 0))))
  a
  => ((0 2) ((0 0) (0 (0 0))))


nsubst-if-not
[       type]: Function
[  arguments]: nsubst-if-not NEW TEST TREE &key :key
[    package]: lisp
[    seealso]: subst-if , nsubst-if , nsubst , nsubstitute-if-not
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE̒TEST𖞂Ȃ̂NEWɒûԂ܂B
TREEj󂳂_subst-if-notƓłB

  NEW  : uvf
  TEST : u邩ǂ𔻒肷eXg
         nilԂu܂B
  TREE : Ώۂ̃c[

TEST̈ɂĂsubst-ifQƂĉB

gpF
  ;;; Kȃc[pӂāAȊÔ̂0ɕϊB
  (setq a '((123 "abc") '(456 "123") (789 #\a)))
  => ((123 "abc") '(456 "123") (789 #\a))
  (nsubst-if-not 0 #'(lambda (x) (or (listp x) (integerp x))) a)
  => ((123 0) (0 (456 0)) (789 0))
  a
  => ((123 0) (0 (456 0)) (789 0))


nsubstitute
[       type]: Function
[  arguments]: nsubstitute NEWITEM OLDITEM SEQUENCE &key :from-end :test :test-not :start :end :count :key
[    package]: lisp
[    seealso]: nsubst , nsubstitute , nsubstitute-if , nsubstitute-if-not , substitute , nsbulis
[   referred]: sublis
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE ɑ΂ OLDITEM Ƃ :test 𖞑vf NEWITEM ɒuV[PXԂ܂B
 SEQUENCE ͔j󂳂܂B

  :test     : eXgs2Zq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇSEQUENCE̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪Anon-nil ŖusB :count
              ^ꂽ݈̂ӖB


nsubstitute-if
[       type]: Function
[  arguments]: nsubstitute-if NEWITEM TEST SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: nsubst-if , nsubstitute , nsubstitute-if-not , substitute-if
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCEɑ΂TEST𖞑vfNEWITEMɒuV[PXԂ܂B
 SEQUENCE ͔j󂳂܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇSEQUENCE̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪A non-nil ŖusB :count
              ^ꂽ݈̂ӖB


nsubstitute-if-not
[       type]: Function
[  arguments]: nsubstitute-if-not NEWITEM TEST SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: nsubst-if-not , nsubstitute , nsubstitute-if , substitute-if-not
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCEɑ΂TEST𖞑ȂvfNEWITEMɒuV[PXԂ܂B
 SEQUENCE ͔j󂳂܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇSEQUENCE̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪A non-nil ŖusB :count
              ^ꂽ݈̂ӖB


nth
[       type]: Function
[  arguments]: nth N LIST
[    package]: lisp
[    seealso]: nthcdr , elt , first , second , third , fourth , fifth , sixth , seventh , eighth , ninth , tenth
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg N Ԗڂ̗vfԂ܂B

  N    : Xg̃CfbNXw肵܂B0Ƃ܂B
  LIST : vfԂXgłB

N Xg̒zĂ nil Ԃ܂B N ł΃G[
Ԃ܂B

  (nth n x) == (car (nthcdr n x))

gpF
  (nth 2 '(1 2 3 4))
  => 3
  (nth 10 '(1 2 3 4))
  => nil
  (nth -3 '(1 2 3 4))
  => ͈͊O̒lł: -3


nthcdr
[       type]: Function
[  arguments]: nthcdr N LIST
[    package]: lisp
[    seealso]: nth
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg N Ԗڂ cdr Ԃ܂B

  N    : Xg̃CfbNXw肵܂B0Ƃ܂B
  LIST : vfԂXgłB

N Xg̒zĂ nil Ԃ܂B N ł΃G[
Ԃ܂B

gpF
  (nthcdr 1 '(1 2 3 4))
  => (2 3 4)
  (nthcdr 10 '(1 2 3 4))
  => nil
  (nthcdr -3 '(1 2 3 4))
  => ͈͊O̒lł: -3


null
[       type]: Function
[  arguments]: null OBJECT
[    package]: lisp
[    seealso]: not , endp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT()Ȃ t AȊOȂ nil Ԃ܂B

  (null x) == (typep x 'null) == (eq x '())


number-of-function-bar-labels
[       type]: Function
[  arguments]: number-of-function-bar-labels
[    package]: editor
[    seealso]: set-number-of-function-bar-labels
[       file]: builtin.l
[    section]: ̑
[description]: 
t@NVo[̃x̐Ԃ܂B\̏ꍇłlԂ܂B


numberp
[       type]: Function
[  arguments]: numberp OBJECT
[    package]: lisp
[    seealso]: integerp , floatp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTlȂtAȊOȂnilԂ܂B

  (numberp x) == (typep x 'number)


numerator
[       type]: Function
[  arguments]: numerator RATIONAL
[    package]: lisp
[    seealso]: denominator , /
[       file]: builtin.l
[    section]: l
[description]: 
̕qԂ܂B


nunion
[       type]: Function
[  arguments]: nunion LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: union
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 𕹂XgĕԂ܂B
union ƈႢ LIST1 ͔j󂳂܂B

gp:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 5 7 11))
  => (2 3 5 7 11)
  (nunion x y)
  => (1 9 2 3 5 7 11)
  x
  => (1 9 2 3 5 7 11)
  y
  => (2 3 5 7 11)


oddp
[       type]: Function
[  arguments]: oddp INTEGER
[    package]: lisp
[    seealso]: evenp
[       file]: builtin.l
[    section]: l
[description]: 
INTEGERȂtAłȂnilԂ܂B

gpF  
  (oddp 1)
  => t
  (oddp 0)
  => nil
  (oddp -35)
  => t


open
[       type]: Function
[  arguments]: open FILENAME &key :direction :if-exists :if-does-not-exist :encoding :share
[    package]: lisp
[    seealso]: close , clear-input , xyzzyŒ񋟂ĂXg[̎ , with-open-file , with-open-stream
[       file]: builtin.l
[    section]: o
[description]: 
t@Cւ̃Xg[쐬ĕԂ܂BXg[̃N[Yɂ close 
g܂A with-open-stream g close ̎ԂȂɈSłB

  FILENAME           : Xg[쐬t@Cw肵܂B
  :direction         : Xg[̓o͂̕w肵܂B
        :input          ́iȗj
        :output         o
        :io             o
        :probe          t@CeXgH
                        ߂l̃Xg[͖ɂȂĂ܂B
  :if-exists         : t@C݂ꍇ̓w肵܂B
        :error          G[o͂܂Biȗj
        :skip           G[͏o͂AnilԂ܂B
        :append         t@Cɒǉ܂B
                        Xg[̈ʒu̓t@CI[ɂȂ܂B
        :overwrite      ㏑܂B
        :new-version    t@C쐬܂B
                        ɂΏ㏑܂B
        ---- ȉڍוs ----
        :supersede      XVH
        :rename         l[pɃXg[JH
        :rename-and-delete  l[pɃXg[JH
  :if-does-not-exist : t@C݂Ȃꍇ̓w肵܂B
        :error          G[o͂܂Biȗj
        :create         G[͏o͂A̓t@C쐬܂B
  :encoding          : GR[fBÕ[hw肵܂B
        :binary         oCi[hłB
        :text           eLXg[hłBiȗ:textj
        :canonical      :text ƓӖɂȂ܂B
        :raw            sR[ḧALF ݂̂ɂȂ܂B
                        ȊO :text ƓłB
  :share             : t@C̋L[hw肵܂B
        ȗ@@@@@:direction  :input ܂ :probe Ȃ :read ɁA
                        ȊO͋LsɂȂ܂B
        :read           ǂݎ̋L\ɂȂ܂B
        :write          ݂̋L\ɂȂ܂B
        :read-write     ǂݏ̋L\ɂȂ܂B

gpF
  ;;; Xg[oRŃt@CɏoĂ݂B
  (setq foo (open "abc.txt" :direction :output))
  => #<file-output stream: C:/applications/xyzzy/abc.txt>
  (princ "test" foo)
  => "test"
  (close foo)
  => t


open-filer
[       type]: Function
[  arguments]: open-filer
[    package]: editor
[    seealso]: filer
[       file]: filer.l
[    section]: t@C
[description]: 
t@CJ܂B[C-c C-f]
filerinteractivełłB


open-line
[       type]: Function
[  arguments]: open-line &optional (ARG 1)
[    package]: editor
[    seealso]: split-line
[       file]: cmds.l
[    section]: eLXg
[description]: 
J[\ʒuςȂŉs}܂B[C-o]


open-network-stream
[       type]: Function
[  arguments]: open-network-stream BUFFER HOSTNAME SERVICE &key :incode :outcode :eol-code
[    package]: editor
[    seealso]: connect , make-process
[       file]: builtin.l
[    section]: vZX
[description]: 
zXg̃|[gƂTCPڑJ܂B
ΐڑBUFFER̃TuvZXƂĕԂ܂B

gpF
  ;;; http://www.yahoo.co.jp/擾Ă݂B
  (progn
    (defun filter (proc in) (insert in))
    (setq proc (open-network-stream (selected-buffer) "www.yahoo.co.jp" 80))
    (process-send-string proc "GET / HTTP/1.0\n\n")
    (set-process-filter proc 'filter))
  => HTTP/1.1 200 OK
     Server: ...


open-rectangle
[       type]: Function
[  arguments]: open-rectangle P1 P2
[    package]: editor
[    seealso]: clear-rectangle , open-rectangle-selection , operate-on-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
P1  P2 Ŏw肳`̈ #\SPC }܂B


open-rectangle-selection
[       type]: Function
[  arguments]: open-rectangle-selection
[    package]: editor
[    seealso]: clear-rectangle-selection , open-rectangle , operate-on-rectangle-selection
[       file]: select.l
[    section]: [W
[description]: 
`IꂽZNV̗̈ #\SPC }܂B


open-session-dialog
[       type]: Function
[  arguments]: open-session-dialog
[    package]: editor
[    seealso]: load-session
[       file]: session.l
[    section]: obt@
[description]: 
_CAOZbVt@Cw肵ăZbVJ܂B
[C-x 6 F]


open-stream-p
[       type]: Function
[  arguments]: streamp OBJECT
[    package]: lisp
[    seealso]: streamp
[       file]: builtin.l
[    section]: o
[description]: 
OBJECTJXg[ۂԂ܂B
  t    OBJECT͊JXg[łB
  nil  OBJECT̓Xg[łȂAĂ܂B


operate-on-rectangle
[       type]: Function
[  arguments]: operate-on-rectangle P1 P2 C1 C2 &key :copy :delete :clear :open :string
[    package]: editor
[    seealso]: operate-on-rectangle-selection
[   referred]: clear-rectangle , delete-rectangle , open-rectangle , string-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
P1  P2 Ŏw肳郊[ẂA C1  C2 Œ܂`̈ɑ΂
ăL[[hŎw肳ꂽs܂B

  :copy     Rs[
  :delete   폜
  :clear    #\SPC ŏ㏑
  :open     #\SPC }
  :string   폜Ċes STRING }

C1, C2 ɂ nil w肷邱Ƃł܂B̏ꍇA[W̊Jn
uƏIʒu̕\g܂B

-rectangle ñR}h̑͂pĎĂ܂B


`ɂĂ̕⑫F
  ႦΎ̐} / [W̏ꍇ * ̑̕ΏۂƂȂ܂B
         C1             C2                     C1             C2
  ----------------------------      ----------------------------
  -------------/////////////////      -------------*******--------
  ////////////////////////////////      -------*************--------
  ////////////////////////////////      -------*************--------
  ////////////////////////////////      -------*************--------
  /////////////////////////-------      -------*************--------
  ----------------------------      ----------------------------
  
  C1, C2 𖾎IɎw肷邱Ƃ͂܂ȂÂꂩ̌`ɂȂꍇقƂǂł傤B
  --------------------      --------------------
  ------------////////      ------********//////
  /////*******////////      //////********//////
  /////*******////////      //////********//////
  /////*******////////      //////********//////
  /////*******////////      //////********//////
  /////---------------      //////********------
  --------------------      --------------------


operate-on-rectangle-selection
[       type]: Function
[  arguments]: operate-on-rectangle-selection &key :copy :delete :clear :open :string
[    package]: editor
[    seealso]: operate-on-rectangle , copy-rectangle-selection , kill-rectangle-selection , delete-rectangle-selection , clear-rectangle-selection , open-rectangle-selection , string-rectangle-selection , *dont-clear-selection*
[       file]: select.l
[    section]: [W
[description]: 
`IꂽZNV̗̈ɑ΂ăL[[hŎw肳ꂽs
܂B

  :copy     Rs[
  :delete   폜
  :clear    #\SPC ŏ㏑
  :open     #\SPC }
  :string   폜Ċes STRING }


or
[       type]: Macro
[  arguments]: or &rest FORMS
[    package]: lisp
[    seealso]: and
[       file]: evalmacs.l
[    section]: \
[description]: 
tH[nil̊ԂԂɕ]܂B
tH[łnon-nilȂ΁Aŕ]𒆒fătH[̒lԂ
ďI܂BSẴtH[nilȂ΁AnilԂ܂B

  ;;; exp1 nilȂexp2sA
  ;;; exp2 nilȂexp3sA
  ;;; exp3 nilȂ......
  ;;; ŌɎsexp̒lԂB
  (or exp1 exp2 exp3 ...)

[ɏ]Ĉl߂ꍇɌĂƎv܂B

  (or (get-buffer-file-name) ; obt@Ƀt@C΂gB
      *foo*                  ; t@CȂ΁Aϐ*foo*̒lgB
      (read-string "foo: ")) ; *foo*ɂlΓ͂Ă炤B


os-build-number
[       type]: Function
[  arguments]: os-build-number
[    package]: editor
[       file]: builtin.l
[    section]: VXe
[description]: 
Windows NT 4.00.13811 + Service Pack 3 ̏ꍇ

gpF  
  (os-build-number)
  => 1381


os-csd-version
[       type]: Function
[  arguments]: os-csd-version
[    package]: editor
[       file]: builtin.l
[    section]: VXe
[description]: 
Windows NT 4.00.1381 + Service Pack 3 ̏ꍇ

gpF
  (os-csd-version)
  => "Service Pack 3"


os-major-version
[       type]: Function
[  arguments]: os-major-version
[    package]: editor
[    seealso]: machine-name
[       file]: builtin.l
[    section]: VXe
[description]: 
OS̃W[o[WԂ܂B

gpF
  (os-major-version)
  => 4


os-minor-version
[       type]: Function
[  arguments]: os-minor-version
[    package]: editor
[    seealso]: machine-name
[       file]: builtin.l
[    section]: VXe
[description]: 
OS̃}Ci[o[WԂ܂B

gpF
  (os-minor-version)
  => 0


os-platform
[       type]: Function
[  arguments]: os-platform
[    package]: editor
[    seealso]: machine-name , si:getenv
[       file]: builtin.l
[    section]: VXe
[description]: 
OS̎ނԂ܂BOS95NTœςƂȂǂɎg܂BԂ
l͕ł͂ȂV{łB

QlF
  OS            V{
  ----          ----
  Windows???    win32s
  Windows95     windows-95
  Windows98     windows-98
  WindowsMe     windows-me
  WindowsNT     windows-nt
  Windows2000   windows-2000
  WindowsXP     windows-xp

gpF
  (os-platform)
  => windows-nt


other-buffer
[       type]: Function
[  arguments]: other-buffer &optional BUFFER
[    package]: editor
[    seealso]: bury-buffer , next-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
ŋ߁A\Ăobt@Ԃ܂B


other-pseudo-frame
[       type]: Function
[  arguments]: other-pseudo-frame
[    package]: editor
[    seealso]: previous-pseudo-frame , next-pseudo-frame , switch-pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
̃t[Ɉړ܂B[C-x 6 o]


other-window
[       type]: Function
[  arguments]: other-window &optional (ARG 1 F) NO-ERROR
[    package]: editor
[    seealso]: move-previous-window , selected-window , count-windows
[       file]: window.l
[    section]: EBhE
[description]: 
ꂽEBhE̒ړ܂B[C-x o]

  ARG      : ARGԖڂ̃EBhEɈړ܂B
             ł΁AARGԑÕEBhEɈړ܂B
  NO-ERROR : (count-windows)ȏ̐lw肵ꍇ̓𐧌䂵܂B
        nil     (count-windows)ȏ̐lw肷ƃG[𔭐܂B
        t       (count-windows)ȏ̐lw肵ĂtԂB


overwrite-char
[       type]: Function
[  arguments]: overwrite-char C &optional (ARG 1)
[    package]: editor
[       file]: cmds.l
[    section]: eLXg
[description]: 
㏑܂B

gpF
  ;;; p󔒂ŏ㏑B
  (overwrite-char #\SPC)
  => t


overwrite-mode
[       type]: Function
[  arguments]: overwrite-mode &optional (ARG () SV)
[    package]: editor
[    seealso]: toggle-over
[       file]: cmds.l
[    section]: [h
[description]: 
㏑p}Ci[[h𐧌䂵܂B toggle-over ƓłB


overwrite-rectangle
[       type]: Function
[  arguments]: overwrite-rectangle
[    package]: editor
[       file]: rectangl.l
[    section]: [W
[description]: 
Rs[Ă`\t܂B̃eLXgɏ㏑܂B


package-name
[       type]: Function
[  arguments]: package-name PACKAGE
[    package]: lisp
[    seealso]: package-nicknames , find-package
[   referred]: defpackage
[       file]: builtin.l
[    section]: pbP[W
[description]: 
pbP[Ŵ̖擾܂B

gpF
  (package-name (find-package "ed"))
  => "editor"


package-use-list
[       type]: Function
[  arguments]: package-use-list PACKAGE
[    package]: lisp
[    seealso]: package-used-by-list , use-package
[       file]: builtin.l
[    section]: pbP[W
[description]: 
w肳ꂽpbP[WgpĂpbP[WԂ܂

  PACKAGE : pbP[Ŵ̂̓pbP[W̕

gpF
  (package-use-list "user")
  =>(#<package: lisp> #<package: editor>)


package-used-by-list
[       type]: Function
[  arguments]: package-used-by-list PACKAGE
[    package]: lisp
[    seealso]: use-package , package-use-list
[       file]: builtin.l
[    section]: pbP[W
[description]: 
w肳ꂽpbP[WgpĂpbP[WԂ܂

  PACKAGE : pbP[Ŵ̂̓pbP[W̕

gp:
  (package-used-by-list (find-package "lisp"))
  =>(#<package: system> #<package: editor> #<package: user>)


packagep
[       type]: Function
[  arguments]: packagep OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTpackageȂtAȊOȂnilԂ܂B

gpF
  ;;; w肳ꂽ̃pbP[W邩𒲂ׂB
  (setq pkg (find-package "win32"))     => nil
  (packagep pkg)                        => nil
  (setq pkg (find-package "winapi"))    => #<package: winapi>
  (packagep pkg)                        => t


pairlis
[       type]: Function
[  arguments]: pairlis KEYS DATA &optional A-LIST
[    package]: lisp
[       file]: builtin.l
[    section]: Xg
[description]: 
̃Xg KEYS  DATA vfgݍ킹AzXgĕԂ܂B
A-LIST ^΂ɉĕԂ܂B

  '(1 2 3 4 5)  '((5 . e) (4 . d) (3 . c) (2 . b) (1 . a))
  '(a b c d e) 

gpF
  (pairlis '(one two) '(1 2) '((three . 3)))
  => ((two . 2) (one . 1) (three . 3))


parse-integer
[       type]: Function
[  arguments]: parse-integer STRING &key :start :end :radix :junk-allowed
[    package]: lisp
[   referred]: read-from-string
[       file]: builtin.l
[    section]: o
[description]: 
񂩂琮ǂݎ܂B
Catoiɑ܂B

  STRING  : Ώۂ̕
  :start  : ǂݎJnʒu
  :end    : ǂݎIʒu
  :radix  : 
  :junk-allowed
          : non-nilȂŐ󔒂𖳎܂

lœ̒lԂ܂B
ڂ͓ǂݍ񂾐lłBǂݍ߂ȂꍇnilԂ܂B
ڂ͓ǂ񂾍Ō̎̃̕̕CfbNXłB̍Ō܂œ
񂾏ꍇ͕̒ɂȂ܂B

:
  (parse-integer "16")
  =>16
  =>2
  (parse-integer "016")
  =>16
  =>3
  (parse-integer " 16 ")
  =>sȐľ`ł: " 16 "
  (parse-integer " 16 " :junk-allowed t)
  =>16
  =>3

l:
  Common Lisp̓̊֐Ɠ삪قȂ܂B
  Common Lispparse-integer:junk-allowednilłŐ󔒂𖳎A
  non-nil̂Ƃ͑Ő󔒂݂̂Ȃ炸ȊO̕܂B


parse-point-syntax
[       type]: Function
[  arguments]: parse-point-syntax &optional POINT
[    package]: editor
[    seealso]: syntax-table , html-highlight-mode , set-syntax-string , set-syntax-comment-column , set-syntax-start-c++-comment , set-syntax-end-c++-comment , set-syntax-start-comment , set-syntax-end-comment , set-syntax-start-multi-comment , set-syntax-end-multi-comment , set-syntax-start-column-comment , set-syntax-tag
[       file]: builtin.l
[    section]: V^bNX
[description]: 
w肳ꂽʒũV^bNXԂ܂B

  :string  set-syntax-string Ŏw肳ꂽLN^Ɉ͂܂ꂽ̈           
  :comment set-syntax-comment-column
           set-syntax-start-c++-comment
           set-syntax-end-c++-comment
           set-syntax-start-comment
           set-syntax-end-comment
           set-syntax-start-multi-comment
           set-syntax-end-multi-comment
           set-syntax-start-column-comment
           Ŏw肳ꂽ̈
  :tag     set-syntax-tag Ŏw肳ꂽLN^Ɉ͂܂ꂽ̈
           ( html-highlight-mode non-nil̂Ƃ̂)
  nil      LȊÖ̗


paste-from-clipboard
[       type]: Function
[  arguments]: paste-from-clipboard
[    package]: editor
[    seealso]: paste-rectangle-from-clipboard , si:*paste-hook*
[   referred]: copy-to-clipboard
[       file]: select.l
[    section]: [W
[description]: 
Nbv{[h̓e\t܂B[S-Insert]


paste-rectangle-from-clipboard
[       type]: Function
[  arguments]: paste-rectangle-from-clipboard
[    package]: editor
[    seealso]: paste-from-clipboard
[   referred]: copy-to-clipboard
[       file]: select.l
[    section]: [W
[description]: 
paste-from-clipboardƂ͈قȂANbv{[h̓e`œ\t܂B
[S-C-Insert]


path-equal
[       type]: Function
[  arguments]: path-equal PATHNAME1 PATHNAME2
[    package]: lisp
[    seealso]: sub-directory-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAME1PATHNAME2pXwĂtAłȂnilԂ܂B

gpF
  (path-equal "C:/Windows/" "c:/windows")
  => t


pathname-device
[       type]: Function
[  arguments]: pathname-device PATHNAME
[    package]: lisp
[    seealso]: pathname-type , pathname-name , pathname-directory , pathname-host
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMẼhCuԂ܂B
gpF
  (setq a "//SAMURAI/Applications/xyzzy/xyzzy.exe")
  => "//SAMURAI/Applications/xyzzy/xyzzy.exe"

  (pathname-device a)
  => nil

  (setq a (merge-pathnames "xyzzy.exe" (si:system-root)))
  => "C:/Applications/xyzzy/xyzzy.exe"

  (pathname-device a)
  "C"


pathname-directory
[       type]: Function
[  arguments]: pathname-directory PATHNAME
[    package]: lisp
[    seealso]: pathname-type , pathname-name , pathname-device , pathname-host , directory-namestring
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMẼfBNgԂ܂BeKwƂ̖OvfƂ郊Xg`
ŕԂ܂B
gpF
  (setq a (merge-pathnames "xyzzy.exe" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.exe"

  (pathname-directory a)
  =>("Applications" "xyzzy")


pathname-host
[       type]: Function
[  arguments]: pathname-host PATHNAME
[    package]: lisp
[    seealso]: pathname-type , pathname-name , pathname-directory , pathname-device
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMẼzXgԂ܂B
gpF
  (setq a "//SAMURAI/Applications/xyzzy/xyzzy.exe")
  =>"//SAMURAI/Applications/xyzzy/xyzzy.exe"

  (pathname-host a)
  =>"SAMURAI"

  (setq a (merge-pathnames "xyzzy.exe" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.exe"

  (pathname-host a)
  =>nil


pathname-match-p
[       type]: Function
[  arguments]: pathname-match-p PATHNAME WILDNAME
[    package]: lisp
[    seealso]: wild-pathname-p , *brackets-is-wildcard-character*
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAME  WILDNAME Ŏw肳ꂽChJ[hɃ}b`邩ǂ
Ԃ܂B

  PATHNAME : Ώۂ̃pX
  WILDNAME : ChJ[h
             擪 | ̏ꍇ͔ے̈ӖƂȂB
             *brackets-is-wildcard-character* ̒l non-nil ̏ꍇ
             񒆂 [...] ChJ[hƌȂB

߂lF
  t    PATHNAME  WILDNAME Ƀ}b`B
  nil  PATHNAME  WILDNAME Ƀ}b`ȂB

gpF
  (setq p (merge-pathnames "xyzzy.exe" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.exe"

  (setq w (merge-pathnames "xyzzy.*" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.*"

  (wild-pathname-p p)
  =>nil

  (wild-pathname-p w)
  =>t

  (pathname-match-p p w)
  =>t

  (pathname-match-p p (concat "|" w))
  =>nil

  (setq w "*/xyzzy.ini")
  =>"*/xyzzy.ini"

  (pathname-match-p p w)
  =>nil

  (pathname-match-p p (concat "|" w))
  =>t


pathname-name
[       type]: Function
[  arguments]: pathname-name PATHNAME
[    package]: lisp
[    seealso]: pathname-type , pathname-directory , pathname-device , pathname-host , file-namestring
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMẼt@CigqjԂ܂B
gpF
  (setq a (merge-pathnames "xyzzy.exe" (si:system-root)))
  =>"C:/Applications/xyzzy/xyzzy.exe"

  (pathname-name a)
  =>"xyzzy"


pathname-type
[       type]: Function
[  arguments]: pathname-type PATHNAME
[    package]: lisp
[    seealso]: pathname-name , file-namestring
[   referred]: pathname-device , pathname-directory , pathname-host
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@C̊gqo܂BgqȂnilԂ܂B

  PATHNAME : gqot@Cw肵܂B

gpF
  ;;; foo.lzh
  (pathname-type "foo.lzh")
  =>"lzh"
  (pathname-type "foo/bar/zzz.txt")
  =>"txt"


peek-char
[       type]: Function
[  arguments]: peek-char &optional PEEK-TYPE INPUT-STREAM EOF-ERROR-P EOF-VALUE RECURSIVE-P
[    package]: lisp
[    seealso]: read-char
[       file]: builtin.l
[    section]: o
[description]: 
Xg[當`܂Bread-charunread-char悤ȂłB

  PEEK_TYPE      : `镶̎ނw肵܂B
        nil        SĂ̎ނ̕󂯕t܂B
               w肳ꂽEOF݂̂󂯕t܂B
        LȊO   󔒈ȊO󂯕t܂B
                   󔒂ɂ ^u s ^u y[W sA Xy[X Y܂B
                   L[ł TAB C-i LFD C-j RET C-m SPC Y܂B
  INPUT-STREAM   : ͌̃Xg[w肵܂B
  EOF-ERROR-P    : EOFG[Ƃ邩ǂw肵܂B
        t          G[Ƃ܂B
        nil        G[ƂAnilԂ܂B
  EOF-VALUE      : EOF̂Ƃnil̑ɕԂw肵܂B
  RECURSIVE-P    : ʂɉe܂B

߂l͕łB

gpF
  ;;; W͂̕B
  (peek-char nil *standard-input* nil nil)


perform-replace
[       type]: Function
[  arguments]: perform-replace PATTERN REPLACEMENT QUERY REGEXP INTERACTIVE-P NOERROR
[    package]: editor
[    seealso]: replace-buffer , replace-string , substitute-string
[   referred]: scan-buffer
[       file]: search.l
[    section]: EK\
[description]: 
obt@ĕu܂BɔfȂ̂Ȃ
scan-bufferȒPłBreplace-buffergĎĂ܂B
  
  PATTERN       : uOłB
  REPLACEMENT   : u㕶łB\1, \2 ... \9gpł܂B
  QUERY         : mFH
  REGEXP        : K\H
  INTERACTIVE-P : ΘbIǂH
                  undőL^̎dƁAbZ[W̏oႤ
  NOERROR       : 񂪌ȂƂG[oH

݊F
  muleɂ͂ȂB


phase
[       type]: Function
[  arguments]: phase Z
[    package]: lisp
[       file]: number.l
[    section]: l
[description]: 
f̕Ίp߂܂B
߂l̓WAPʂłB

  (phase -1)
  =>3.141593


pipe-command
[       type]: Function
[  arguments]: pipe-command CMD
[    package]: editor
[    seealso]: execute-shell-command
[       file]: process.l
[    section]: vZX
[description]: 
CMD sAvZX̏I҂ĕWo͂ *Shell output* obt@
ɏo͂܂B[C-x @]


plain-error
[       type]: Function
[  arguments]: plain-error &rest REST
[    package]: lisp
[       file]: misc.l
[    section]: G[
[description]: 
iڍוsj


plusp
[       type]: Function
[  arguments]: plusp NUMBER
[    package]: lisp
[    seealso]: minusp
[       file]: builtin.l
[    section]: l
[description]: 
NUMBER[傫tAłȂnilԂ܂B

gpF
  (plusp 0)
  => nil
  (plusp 1)
  => t
  (plusp 0.00001)
  => t


point
[       type]: Function
[  arguments]: point
[    package]: editor
[   referred]: region-beginning , region-end , what-cursor-position
[       file]: builtin.l
[    section]: |WV
[description]: 
̊֐́A|Cg̈ʒu integer ƂĕԂ܂B 
goto-char ł̈ʒuɔԂƂo܂Bobt@̐擪łpoint-min
Aobt@̍Ōłpoint-maxɓłB

gpF
  (point)
  => 175


point-marker
[       type]: Function
[  arguments]: point-marker
[    package]: editor
[    seealso]: set-marker
[   referred]: make-marker
[       file]: cmds.l
[    section]: |WV
[description]: 
V}[J[쐬Ã݂J[\ʒuɃZbgĕԂ܂B


point-max
[       type]: Function
[  arguments]: point-max
[    package]: editor
[    seealso]: point-min , narrow-to-region
[   referred]: goto-char
[       file]: builtin.l
[    section]: |WV
[description]: 
Jgobt@̈ԑ傫ȃ|CglԂ܂Bnarrow-to-regionŁA
clipping pĂȂAJgobt@̑傫ɂȂ܂B 

gpF
  (point-max)
  => 189568


point-min
[       type]: Function
[  arguments]: point-min
[    package]: editor
[    seealso]: point-max , narrow-to-region
[   referred]: goto-char
[       file]: builtin.l
[    section]: |WV
[description]: 
Jgobt@̈ԏȃ|CglԂ܂Bnarrow-to-regionŁA
clipping pĂȂ 0 ɂȂ܂B 

gpF
  (point-min)
  => 0


point-to-register
[       type]: Function
[  arguments]: point-to-register R
[    package]: editor
[    seealso]: jump-to-register
[       file]: register.l
[    section]: |WV
[description]: 
V}[J[Č݈ʒuɃZbgAWX^ R Ɋi[܂B
[C-x r SPC]


pop
[       type]: Macro
[  arguments]: pop PLACE
[    package]: lisp
[       file]: setf.l
[    section]: Xg
[description]: 
Xg̐擪vf菜܂B菜vfԂ܂B

  PLACE : setfɓKpł̂łȂ΂Ȃ܂B

gpF
  (setq x '(a (b c d) e f))     => (a (b c d) e f)
  (pop (cdr (second x)))        => c
  x                             => (a (b d) e f)

݊F
  Common LispxyzzyɂB
  mule͂ȂB


pop-to-buffer
[       type]: Function
[  arguments]: pop-to-buffer BUFFER &optional POPUP-WINDOWS VERT-P
[    package]: editor
[    seealso]: split-window , split-window-vertically
[       file]: window.l
[    section]: EBhE
[description]: 
w肳ꂽobt@\܂BPOPUP-WINDOWS w肳ꂽꍇʂ𕪊
ăobt@\܂BEBhEɕĂAVɕ
ɂ̃EBhEɈړ\܂B

\w肳ꂽꍇɂ́Acw肳ĂȂꍇA[hs\
ĂԂŁA悻w肳ꂽl̍s\ł傫̃EBh
Eł܂B
cw肳ꂽꍇɂ́A㉺ł͂ȂEɕAsԍ\Ă
ȂԂŁA悻w肳ꂽl̗񐔂\ł傫̃EChE
ł܂B

  BUFFER        : obt@A܂́Aobt@̖Ow肵܂B
  POPUP-WINDOWS : s^񐔂w肵܂B
        t             j܂B
                  ws^񐔂ŕ܂B
        nil           EBhEĂȂꍇłV
                      ܂B
  VERT-P        : cɕ܂B
        non-nil       EɃj܂B
        nil           ㉺Ƀj܂B

gpF
  ;;; den8̏ꍇ
  (defvar *den8-summary-window-ratio* 1/4)

  (defun den8-viewer ()
    (let ((view (switch-to-buffer "*Den8 View*")))     ; View
      (let ((sum (switch-to-buffer "*Den8 Summary*"))) ; Summary
           <Eȗ> ))
    (delete-other-windows)        ; ȊȎS̃EChE
    (den8-popup-summary-buffer))  ; QāA㉺ɃT}Ɠe\

  (defun den8-popup-summary-buffer ()
    (pop-to-buffer den8-summary-buffer
       (truncate (* (screen-height) *den8-summary-window-ratio*))))


popup-list
[       type]: Function
[  arguments]: popup-list LIST CALLBACK &optional POINT
[    package]: editor
[    seealso]: dabbrev-popup , popup-string
[       file]: builtin.l
[    section]: ̑
[description]: 
|bvAbvXg\܂BIꂽڂɃR[ob
N֐Ăяo܂B

gpF
  (defun func ()
    (popup-list
       '("123" "abc" "xyz")
       #'(lambda (x) (msgbox "\"~A\" selected" x))))
  => func


popup-string
[       type]: Function
[  arguments]: popup-string STRING POINT &optional TIMEOUT
[    package]: editor
[    seealso]: popup-list , continue-popup , track-popup-menu
[       file]: builtin.l
[    section]: ̑
[description]: 
|bvAbv܂Bc[`bṽ|bv݂ȕ\łB

  STRING  : |bvAbv镶w肵܂B
  POINT   : \ʒu|CgŎw肵܂B
  TIMEOUT : \~߂܂ł̕bw肵܂B


pos-not-visible-in-window-p
[       type]: Function
[  arguments]: pos-not-visible-in-window-p POINT &optional WINDOW
[    package]: editor
[    seealso]: pos-visible-in-window-p
[       file]: builtin.l
[    section]: EBhE
[description]: 
w肳ꂽ|CgPOINTEBhE̕\͈͓ɂȂԂ܂B

  t     \͈͓ɂȂB
  nil   \͈͓ɂB


pos-visible-in-window-p
[       type]: Function
[  arguments]: pos-visible-in-window-p POINT &optional WINDOW
[    package]: editor
[    seealso]: pos-not-visible-in-window-p
[       file]: window.l
[    section]: EBhE
[description]: 
|CgEBhE̕\͈͓ɂ邩Ԃ܂B

  t     \͈͓ɂB
  nil   \͈͓ɂȂB


position
[       type]: Function
[  arguments]: position ITEM SEQUENCE &key :from-end :test :test-not :start :end :key
[    package]: lisp
[    seealso]: position-if , position-if-not , find , member
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE ̒ ITEM Ƃ :test 𖞂̂΂̃CfbNXԂ܂B
Ȃ nil Ԃ܂B

gpF
  ;;; Xg̒'ãCfbNX𒲂ׂ
  (position 'a '(e c a b))
  => 2


position-if
[       type]: Function
[  arguments]: position-if PREDICATE SEQUENCE &key :from-end :start :end :key
[    package]: lisp
[    seealso]: position , position-if-not
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒PREDICATE𖞂̂΂̃CfbNXԂ܂B
ȂnilԂ܂B


position-if-not
[       type]: Function
[  arguments]: position-if-not PREDICATE SEQUENCE &key :from-end :start :end :key
[    package]: lisp
[    seealso]: position , position-if
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒PREDICATE𖞂Ȃ̂΂̃CfbNXԂ܂B
ȂnilԂ܂B


post-buffer-modified-hook
[       type]: Variable
[    package]: editor
[    seealso]: enable-post-buffer-modified-hook , post-buffer-modified-hook-enabled-p
[    section]: ϐƒ萔
[description]: 
obt@CꂽƂɎs܂B

ݒ肳ꂽ֐͈ȉ5ŌĂяo܂B
  BUFFER    : Cꂽobt@
  OPERATION : Cꂽ̎
               :insert  ̑}
               :delete  ̍폜
               :modify  C(downcase-wordȂ)
  FROM      : Jnʒũ|Cg
  TO        : Iʒũ|Cg
              OPERATION:deletȅꍇFROMTO͓lɂȂ܂B
  UNDO-P    : Cꂽ
               undo     undo
               redo     redo
               nil      ̑

ӁF
  enable-post-buffer-modified-hookŃtbNLɂȂƎs܂B
  ΘbIłȂĂs܂B
  obt@ɏCsread-only-bufferG[ɂȂ܂B
  Ȃ炩̃G[ƃtbNɂȂ܂B
  EBhEEobt@폜A
  ߂ƂɃEBhEEobt@؂ւĂ肷ƁA
  ƗǂȂƂN̂ŁA܂薳ȂƂ͂ȂłB

gpF
  (enable-post-buffer-modified-hook t)
  (defun buffer-modified-hook (buffer operation from to undo-p)
    (message "ope:~A  undo:~A from:~d to:~d" operation undo-p from to))
  (add-hook 'post-buffer-modified-hook 'buffer-modified-hook)


post-buffer-modified-hook-enabled-p
[       type]: Function
[  arguments]: post-buffer-modified-hook-enabled-p &optional BUFFER
[    package]: editor
[    seealso]: enable-post-buffer-modified-hook , post-buffer-modified-hook
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
obt@post-buffer-modified-hookL𔻒肵܂B
[xyzzy:06354]Q
xyzzy 0.2.1.186` 


pre-selection-p
[       type]: Function
[  arguments]: pre-selection-p
[    package]: editor
[    seealso]: selection-point , selection-mark , get-selection-type , start-selection
[       file]: builtin.l
[    section]: |WV
[description]: 
ZNV݂ t Ȃ nil Ԃ܂B


preceding-char
[       type]: Function
[  arguments]: preceding-char
[    package]: editor
[    seealso]: following-char , char-before
[       file]: builtin.l
[    section]: eLXg
[description]: 
J[\̑O̕Ԃ܂B
obt@̐擪ɃJ[\ꍇɂ́A#\NULԂ܂B

gpF
  ;;; J[\̒O#\LFDH܂J[\͍sɂ邩H
  (char= (preceding-char) #\LFD)
  => t


prepend-to-register
[       type]: Function
[  arguments]: prepend-to-register R START END &optional DELETE
[    package]: editor
[    seealso]: append-to-register
[       file]: register.l
[    section]: [W
[description]: 
START  END Ŏw肳郊[WAWX^ R Ɋi[ĂeL
Xg̐擪֒ǉ܂B
R ɃeLXgĂȂƃG[ɂȂ܂B
DELETE  non-nil ȂΓɃ[W폜܂B


previous-buffer
[       type]: Function
[  arguments]: previous-buffer
[    package]: editor
[    seealso]: next-buffer
[       file]: buffer.l
[    section]: obt@
[description]: 
Õobt@ɐؑւ܂Bnext-buffer̔΂łB[S-Home]


previous-line
[       type]: Function
[  arguments]: previous-line &optional (N 1)
[    package]: editor
[    seealso]: forward-line , next-line , previous-virtual-line
[       file]: cmds.l
[    section]: |WV
[description]: 
NsOɈړ܂B
ړ̑O goal-column ۑ܂B
(previous-line n)  (next-line (- n)) ͓łB

gp:
  (previous-line)


previous-page
[       type]: Function
[  arguments]: previous-page
[    package]: editor
[    seealso]: next-page
[   referred]: *next-screen-context-lines* , *page-scroll-half-window*
[       file]: page.l
[    section]: EBhE
[description]: 
1y[WʂXN[܂B[ESC v], [PageUp], [C-z]
*page-scroll-half-window*  non nil Ȃ甼ʂXN[܂B


previous-pseudo-frame
[       type]: Function
[  arguments]: previous-pseudo-frame
[    package]: editor
[    seealso]: next-pseudo-frame , other-pseudo-frame , switch-pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
Õt[Ɉړ܂B[C-x 6 p]


previous-virtual-line
[       type]: Function
[  arguments]: previous-virtual-line &optional (N 1)
[    package]: editor
[    seealso]: previous-line
[       file]: cmds.l
[    section]: |WV
[description]: 
NsO̕\sɈړ܂B [C-p], [Up]
  t    擪sȊȌꍇ
  nil  擪s̏ꍇ


previous-window
[       type]: Function
[  arguments]: previous-window WINDOW &optional MINIBUF
[    package]: editor
[    seealso]: next-window , set-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
WINDOW ̑ÕEBhEԂ܂B
  
  MINIBUF : ~jobt@EBhEɓ邩
       nil    
   non-nil    ɓ


previous-word
[       type]: Function
[  arguments]: previous-word &optional (ARG 1)
[    package]: editor
[    seealso]: backward-word
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\̒P̐擪Ɉړ܂B


previous-xyzzy-window
[       type]: Function
[  arguments]: previous-xyzzy-window
[    package]: editor
[    seealso]: next-xyzzy-window , list-xyzzy-windows
[       file]: builtin.l
[    section]: vZX
[description]: 
OxyzzyɈړ܂B
ړ͋N̋tłB


prin1
[       type]: Function
[  arguments]: prin1 OBJECT &optional STREAM
[    package]: lisp
[    seealso]: princ
[       file]: stream.l
[    section]: o
[description]: 
IuWFNgXg[ɏo͂܂B

  OBJECT : o͂IuWFNgw肵܂B
  STREAM : Xg[w肵܂B

STREAMȗꂽƂ́AWo͂ɏo͂܂Bprincł̏o͂Ƃ悭
܂AGXP[vo͂邱Ƃ╶񂪈pň͂܂_ق
܂B

gpF
  ;;; princprin1̏o͂̈Ⴂ
  (princ "abc") => abc  (prin1 "abc") => "abc"
  (princ #\a)   => a    (prin1 #\a)   => #\a


princ
[       type]: Function
[  arguments]: princ OBJECT &optional STREAM
[    package]: lisp
[    seealso]: prin1
[       file]: stream.l
[    section]: o
[description]: 
IuWFNgXg[ɏo͂܂B

  OBJECT : o͂IuWFNgw肵܂B
  STREAM : Xg[w肵܂B

STREAMȗꂽƂ́AWo͂ɏo͂܂Bprin1ł̏o͂Ƃ悭
܂AGXP[vo͂ȂƂ╶񂪈pň͂܂Ȃ_
قȂ܂B
CLtL2(Common Lisp the Language, 2nd edition)ɂƐlԂɓǂ݈Ղ悤
  ɈӐ}Ă邻łB

gpF
  ;;; princprin1̏o͂̈Ⴂ
  (princ "abc") => abc  (prin1 "abc") => "abc"
  (princ #\a)   => a    (prin1 #\a)   => #\a


print-buffer
[       type]: Function
[  arguments]: print-buffer &optional BUFFER
[    package]: editor
[    seealso]: print-dialog
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@܂B


print-dialog
[       type]: Function
[  arguments]: print-dialog &optional BUFFER
[    package]: editor
[    seealso]: print-buffer
[       file]: builtin.l
[    section]: _CAO
[description]: 
w肳ꂽobt@BUFFER̈p̃_CAO\܂B


process-buffer
[       type]: Function
[  arguments]: process-buffer PROCESS
[    package]: editor
[    seealso]: buffer-process
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXѕtĂobt@Ԃ܂B


process-eol-code
[       type]: Function
[  arguments]: process-eol-code PROCESS
[    package]: editor
[    seealso]: set-process-eol-code
[       file]: builtin.l
[    section]: vZX
[description]: 
PROCESSɐݒ肳ꂽsR[hԂ܂B


process-exit-code
[       type]: Function
[  arguments]: process-exit-code PROCESS
[    package]: editor
[    seealso]: signal-process , process-status
[       file]: builtin.l
[    section]: vZX
[description]: 
w肳ꂽvZXPROCESS̏IR[h擾܂B


process-filter
[       type]: Function
[  arguments]: process-filter PROCESS
[    package]: editor
[    seealso]: set-process-filter
[   referred]: process-marker
[       file]: builtin.l
[    section]: vZX
[description]: 
PROCESSɐݒ肳ꂽFILTERp̊֐Ԃ܂B


process-incode
[       type]: Function
[  arguments]: process-incode PROCESS
[    package]: editor
[    seealso]: set-process-incode
[       file]: builtin.l
[    section]: vZX
[description]: 
PROCESSɐݒ肳ꂽ͗p̕GR[fBOw肵܂B


process-marker
[       type]: Function
[  arguments]: process-marker PROCESS
[    package]: editor
[    seealso]: make-marker , make-process , delete-marker , process-filter
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXɊ֘Atꂽ}[J[Ԃ܂B
vZX̏o͂̓}[J[ʒuɑ}A
}[J[ʒu͑}eLXgi݂܂B

process-filter Zbgꍇ́A}[J[ɑ΂鏈͋N܂B
Kvȏꍇ́Aʏ process-filter Ŏŏ܂B
vZXɊ֘Atꂽ}[J[́A delete-marker ō폜邱Ƃ͂ł܂B


process-outcode
[       type]: Function
[  arguments]: process-outcode PROCESS
[    package]: editor
[    seealso]: set-process-outcode
[       file]: builtin.l
[    section]: vZX
[description]: 
PROCESSɐݒ肳ꂽo͗p̕GR[fBOw肵܂B


process-send-n
[       type]: Function
[  arguments]: process-send-n
[    package]: editor
[    seealso]: process-send-y
[       file]: process.l
[    section]: vZX
[description]: 
obt@ɌѕtĂvZX "n\n" 𑗂܂B


process-send-string
[       type]: Function
[  arguments]: process-send-string PROCESS STRING
[    package]: editor
[    seealso]: make-process
[   referred]: command-output-send-input , set-process-filter
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXɕ𑗂܂B

  PROCESS : 𑗂vZXw肵܂B 
  STRING  : 镶w肵܂B

gpF
  ;;; sort.exeNāA"abc" "aab" "aac"𑗂B
  (setq proc (make-process "sort"))
  => #<process 135271372>
  (process-send-string proc "abc\n") => t
  (process-send-string proc "aab\n") => t
  (process-send-string proc "aac\n") => t
  (process-send-string proc "^Z")    => t
  aab
  aac
  abc


process-send-y
[       type]: Function
[  arguments]: process-send-y
[    package]: editor
[    seealso]: process-send-n
[       file]: process.l
[    section]: vZX
[description]: 
obt@ɌѕtĂvZX "y\n" 𑗂܂B


process-sentinel
[       type]: Function
[  arguments]: process-sentinel PROCESS
[    package]: editor
[    seealso]: set-process-sentinel
[       file]: builtin.l
[    section]: vZX
[description]: 
PROCESSɐݒ肳ꂽSENTINELp̊֐Ԃ܂B


process-status
[       type]: Function
[  arguments]: process-status PROCESS
[    package]: editor
[    seealso]: kill-process , make-process
[   referred]: process-exit-code
[       file]: builtin.l
[    section]: vZX
[description]: 
w肳ꂽvZX̏ԂԂ܂B

  :run  쒆
  :exit ~


processp
[       type]: Function
[  arguments]: processp OBJECT
[    package]: editor
[       file]: builtin.l
[    section]: f[^^
[description]: 
w肳ꂽOBJECTvZXԂ܂B

  t     OBJECT̓vZX
  nil   OBJECT̓vZXł͂Ȃ


proclaim
[       type]: Function
[  arguments]: proclaim DECL-SPEC
[    package]: lisp
[    seealso]: declaim , declare
[       file]: typespec.l
[    section]: ϐƒ萔
[description]: 
ϐXyVϐɂ܂B
declare Ƃ̈Ⴂ́A֐ł邽߈]邱ƂƁAʂI
_łB

ȉ̌`Ŏgp܂B

  (proclaim '(special var1 var2...))

xyzzy ł special ȊO̎wĂʂ͂܂B


prog
[       type]: Macro
[  arguments]: prog VARLIST &body BODY
[    package]: lisp
[    seealso]: prog* , let , tagbody
[   referred]: go
[       file]: evalmacs.l
[    section]: \
[description]: 
let  block  tagbody 킹\łB

VARLIST ɂċǏϐ BODY ]_ let ƓłA
BODY ̒ return g_AxăWvł_قȂ܂B

F
  (let ((x 1)) (return x))
  => `return-from'̃Lb`QƂł܂: nil

  (prog ((x 1)) (return x))
  => 1

  (prog ((x 0))
    tag
    (princ x)
    (incf x)
    (if (= x 10)
        (return x)
      (go tag)))
  -> 0123456789
  => 10


prog*
[       type]: Macro
[  arguments]: prog* VARLIST &body BODY
[    package]: lisp
[    seealso]: tagbody , prog , let*
[       file]: evalmacs.l
[    section]: \
[description]: 
prog Ƃ悭Ă܂A VARLIST ̒Őɒ`̕ϐQƂł
_قȂ܂B


prog1
[       type]: Macro
[  arguments]: prog1 FIRST &body BODY
[    package]: lisp
[   referred]: multiple-value-prog1 , prog2
[       file]: evalmacs.l
[    section]: \
[description]: 
tH[Ԃɕ]čŏ̃tH[̌ʂԂ܂B

gpF
  (prog1 (print "The first form")
         (print "The second form")
         (print "The third form"))
  -> "The first form"
  -> "The second form"
  -> "The third form"
  => "The first form"


prog2
[       type]: Macro
[  arguments]: prog2 FIRST SECOND &body BODY
[    package]: lisp
[    seealso]: progn , prog1
[       file]: evalmacs.l
[    section]: \
[description]: 
tH[Ԃɕ]ēԖڂ̃tH[̌ʂԂ܂B

gpF
  (prog2 (print "The first form")
         (print "The second form")
         (print "The third form"))
  -> "The first form"
  -> "The second form"
  -> "The third form"
  => "The second form"


progn
[       type]: Special Form
[  arguments]: progn {FORM}*
[    package]: lisp
[   referred]: prog2
[       file]: builtin.l
[    section]: \
[description]: 
tH[Ԃɕ]čŌ̃tH[̌ʂԂ܂B

gpF
  (progn (print "The first form")
         (print "The second form")
         (print "The third form"))
  -> "The first form"
  -> "The second form"
  -> "The third form"
  => "The third form"


provide
[       type]: Function
[  arguments]: provide MODULE-NAME
[    package]: lisp
[    seealso]: require , *modules*
[       file]: evalmacs.l
[    section]: ]
[description]: 
@\W[[hꂽ߂Ƀt@C̐擪ɏ
Ău܂ȂvłBɏW[ϐ*modules*ɓo
^܂B

requireW[̃[hۂɂ̕ϐ`FbNă[hς
[h܂BėpIȃW[ꍇɂ͎g悤ɂ
傤B

݊F
  Common Lispɂ͂B
  muleɂ͂ȂB

gpF
  ;;; lispmode.l
  (provide "lispmode")


psetq
[       type]: Macro
[  arguments]: psetq {VAR FORM}*
[    package]: lisp
[    seealso]: setq , psetf
[       file]: evalmacs.l
[    section]: ϐƒ萔
[description]: 
ϐɒlݒ肵܂B

  (psetq ϐ1 l1 ϐ2 l2 ... ϐN lN)

L̗lɕϐƒl̑gCӂׂ̐邱Ƃł܂B 

setqƎĂ܂setq珇ɕϐɒlݒ肵Ă̂ɑ΂Apsetq
͒lSĕ]Őݒ肵܂B

gpF
  ; psetq ̏ꍇ
  (let ((from 1)
        (to 100))
    (psetq from to to from)
    (values from to))
  =>100
  =>1

  ; setq ̏ꍇ
  (let ((from 1)
        (to 100))
    (setq from to to from)
    (values from to))
  =>100
  =>100


pseudo-frame-selector
[       type]: Function
[  arguments]: pseudo-frame-selector
[    package]: editor
[    seealso]: switch-pseudo-frame , select-pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
_CAOt[I܂B


push
[       type]: Macro
[  arguments]: push ITEM PLACE
[    package]: lisp
[    seealso]: pushnew
[       file]: setf.l
[    section]: Xg
[description]: 
Xg̐擪ɗvfǉ܂B

  ITEM  : XgɒǉvfłB
  PLACE : pushꏊsetfɓKpł̂łȂ΂Ȃ܂B

gpF
  ;;; Xg̓rpushĂ݂B
  (setq x '(a (b c d) e f))     => (a (b c d) e f)
  (push 99 (cdr (second x)))    => (99 c d)
  x                             => (a (b 99 c d) e f)

݊F
  Common LispxyzzyɂB
  mule͖B


pushnew
[       type]: Macro
[  arguments]: pushnew ITEM PLACE &KEY :test :test-not :key
[    package]: lisp
[    seealso]: push , adjoin
[       file]: setf.l
[    section]: Xg
[description]: 
push ƂقړłAXg̍ŏʂɌĂvfłȂ΃Xg
擪ɒǉ܂Bǉ邩ǂ́A :test  :test-not Ŏw
reXggăXg̑Svfɂă`FbNČ߂܂B

  ITEM      : o^ełB
  PLACE     : o^ꏊłB
  :test     : r֐łBWł#'eqlH
  :test-not : r֐łB
  :key      : L[p̊֐łBWł#'identityH

gpF
  (setq *a* nil)                ;; ̎ *a* ̒l nil
  (pushnew 'a *a*)  => (a)      ;; ̎ *a* ̒l (a)
  (pushnew 'b *a*)  => (b a)    ;; ̎ *a* ̒l (b a)
  (pushnew 'a *a*)  => (b a)    ;; ̎ *a* ̒l (b a)

݊F
  Common LispxyzzyɂB
  mule͖B


quietly-read-abbrev-file
[       type]: Function
[  arguments]: quietly-read-abbrev-file &optional FILE
[    package]: editor
[    seealso]: abbrev-mode
[       file]: abbrev.l
[    section]: [h
[description]: 
Q.݁A[h؂ւĊ abbrev Lɂɂ́A
  
  M-x: sql-mode,                                                
  M-x: abbrev-mode                                              
  M-x: read-abbrev-file,                                        
  Read-abbrev-file: C:/xyzzy/.abbrev_defs                       
  
  ̂悤ɂSiK܂ȂĂ͂Ȃ܂Bŏ M-x: sql-mode ̎A
  t@NVL[Ɋ蓖ĂĈxɍs@͂Ȃł傤H

A.[xyzzy:02017]Ԓˌc
  .xyzzy 
  
  ; N abbrev file ǂݍ                             
  (quietly-read-abbrev-file)                                    
  
  ƂĂƁA  .abbrev_defs Ăł܂B

  [xyzzy:02020]TN킳
  ɉāA
  
  (add-hook 'ed::*sql-mode-hook* #'(lambda () (abbrev-mode t))) 
  
  Ă΁AM-x sql-mode łƎv܂(Ԃ)B


quit
[       type]: Function
[  arguments]: quit
[    package]: editor
[    seealso]: error
[       file]: cmds.l
[    section]: G[
[description]: 
R}h̎sȂǂ𒆎~܂B[C-g]

sɎԂ肷ꍇ△[vɊׂƂȂǂɎg܂B


quote
[       type]: Special Form
[  arguments]: quote OBJECT
[    package]: lisp
[    seealso]: ``'(backquote) , function
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
OBJECT]ɕԂ܂B
single quoteőp܂B

gpF
  ;;; quote'gĂ݂B
  (quote x)             => x
  'x                    => x
  (eq (quote x) 'x)     => t


quote-char
[       type]: Function
[  arguments]: quote-char &optional (ARG 1)
[    package]: editor
[       file]: cmds.l
[    section]: 
[description]: 
vvg\āA͂ɏ]ăobt@ɕ}܂B[C-q]
䕶̓͂ȂǂɎg܂B
R[hɂ͂\łB


quote-region
[       type]: Function
[  arguments]: quote-region FROM TO
[    package]: editor
[    seealso]: *quotation-prefix*
[       file]: region.l
[    section]: [W
[description]: 
w肳ꂽ[W̐擪Ɉp\ړq}܂B
p\ړqƂ *quotation-prefix* }܂B


quote-string
[       type]: Function
[  arguments]: quote-string STRING TARGET-CHAR QUOTE-CHAR
[    package]: editor
[    seealso]: substitute-string
[       file]: builtin.l
[    section]: 
[description]: 
񒆂̓蕶̑OɃGXP[v܂B

  STRING      : u镶
  TARGET-CHAR : GXP[v镶
  QUOTE-CHAR  : GXP[v

gpF
  ;;;   Xy[X̑O'܂B
  (quote-string  "a b  c"  #\SPC #\')
  => "a' b' ' c"


quoted-printable-decode-region
[       type]: Function
[  arguments]: quoted-printable-decode-region FROM TO
[    package]: editor
[    seealso]: si:quoted-printable-decode , quoted-printable-decode-region-to-file
[       file]: encdec.l
[    section]: [W
[description]: 
[WQuoted-PrintablefR[h܂B


quoted-printable-decode-region-to-file
[       type]: Function
[  arguments]: quoted-printable-decode-region-to-file FILENAME FROM TO
[    package]: editor
[    seealso]: si:quoted-printable-decode , quoted-printable-decode-region
[       file]: encdec.l
[    section]: [W
[description]: 
[WQuoted-PrintablefR[hăt@Cɕۑ܂B


random
[       type]: Function
[  arguments]: random NUMBER &optional STATE
[    seealso]: *random-state* , make-random-state
[       file]: builtin.l
[    section]: l
[description]: 
0ȏNUMBER̗Ԃ܂B

  STATE: ̏ԕϐłBjIɏ܂B


rassoc
[       type]: Function
[  arguments]: rassoc ITEM A-LIST &key :test :test-not :key
[    package]: lisp
[    seealso]: rassoc-if , rassoc-if-not , assoc
[       file]: builtin.l
[    section]: Xg
[description]: 
AzXg A-LIST ̒ cdr  ITEM Ƃ :test 𖞂ŏ̃yAԂ܂B

gpF
  (rassoc 'a '((a . b) (b . c) (c . a) (z . a)))
  => (c . a)


rassoc-if
[       type]: Function
[  arguments]: rassoc-if PREDICATE A-LIST &key :key
[    package]: lisp
[    seealso]: rassoc , rassoc-if-not
[       file]: builtin.l
[    section]: Xg
[description]: 
AzXg A-LIST ̒ cdr  PREDICATE 𖞂ŏ̃yAԂ܂B

gpF
  (rassoc-if #'numberp '((a . b) (1 . c) (2 . 4)))
  => (2 . 4)


rassoc-if-not
[       type]: Function
[  arguments]: rassoc-if-not PREDICATE A-LIST &key :key
[    package]: lisp
[    seealso]: rassoc , rassoc-if
[       file]: builtin.l
[    section]: Xg
[description]: 
AzXg A-LIST ̒ cdr  PREDICATE 𖞂Ȃŏ̃yAԂ܂B

gpF
  (rassoc-if-not #'numberp '((a . b) (1 . c) (2 . d)))
  => (a . b)


rational
[       type]: Function
[  arguments]: rational NUMBER
[    package]: lisp
[    seealso]: rationalize
[       file]: builtin.l
[    section]: l
[description]: 
Lɕϊ܂BA NUMBER łɗLÂ
ܕԂ܂B rational ̏ꍇ́A_S덷܂܂Ȃ̂Ƃ
ĈA̕_𐔊wIɗL܂B
  
  ;;; 0.5 2ił傤Ǖ\
  (rational 0.5)
  =>1/2
  ;;; 0.1 2ił͌덷܂
  (rational 0.1)
  =>13421773/134217728
  ;;; {xƂ܂Ⴄ
  (rational 0.1d0)
  =>3602879701896397/36028797018963968


rationalize
[       type]: Function
[  arguments]: rationalize NUMBER
[    package]: lisp
[    seealso]: rational , float
[       file]: builtin.l
[    section]: l
[description]: 
Lɕϊ܂BA NUMBER łɗLÂ
ܕԂ܂B rationalize ̏ꍇ́A_\͈͂܂ł̐
xňAߎėL܂B


rationalp
[       type]: Function
[  arguments]: rationalp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTratiointegerȂtAȊOȂnilԂ܂B

  (rationalp x) == (typep x 'rational)


re-search-backward
[       type]: Function
[  arguments]: re-search-backward REGEXP &optional NOERROR
[    package]: editor
[    seealso]: re-search-forward
[       file]: search.l
[    section]: EK\
[description]: 
K\ɂ܂B[ESC C-s]

  REGEXP  : K\ɂ錟
  NOERROR : 񂪌ȂƂ̓w肵܂B
        t   nil Ԃ܂B
        nil G[bZ[Wo͂܂B


re-search-backward-again
[       type]: Function
[  arguments]: re-search-backward-again
[    package]: editor
[    seealso]: ed::*last-search-regexp* , re-search-forward-again
[       file]: search.l
[    section]: EK\
[description]: 
O̐K\p^[Ō܂B


re-search-forward
[       type]: Function
[  arguments]: re-search-forward REGEXP &optional NOERROR
[    package]: editor
[    seealso]: re-search-backward
[       file]: search.l
[    section]: EK\
[description]: 
K\ɂO܂B[ESC s]

  REGEXP  : K\ɂ錟
  NOERROR : 񂪌ȂƂ̓w肵܂B
        t   nil Ԃ܂B
        nil G[bZ[Wo͂܂B


re-search-forward-again
[       type]: Function
[  arguments]: re-search-forward-again
[    package]: editor
[    seealso]: ed::*last-search-regexp* , re-search-backward-again
[   referred]: repeat-backward-search , repeat-forward-search
[       file]: search.l
[    section]: EK\
[description]: 
O̐K\p^[őO܂B


read
[       type]: Function
[  arguments]: read &optional INPUT-STREAM EOF-ERROR-P EOF-VALUE RECURSIVE-P
[    package]: lisp
[   referred]: buffer-stream-point , read-as-string , read-delimited-list , read-into , read-line-into , read-preserving-whitespace , write
[       file]: builtin.l
[    section]: o
[description]: 
INPUT-STREAM  Lisp ̃IuWFNgǂݍŕԂ܂B

  INPUT-STREAM : ͌̃Xg[
  EOF-ERROR-P  : EOF̏Ԃread-charƂɂǂ邩H
        t               G[ƂB
        nil             G[ƂAnilԂ܂B
  EOF-VALUE    : EOF̏ԂreadƂnil̑ɕԂw肵܂B
  RECURSIVE-P  : iڍוsj


read-as-string
[       type]: Function
[  arguments]: read-as-string STREAM &optional EOF-ERROR-P EOF-VALUE
[    package]: editor
[    seealso]: read
[       file]: builtin.l
[    section]: o
[description]: 
Xg[g[NǂݍŕƂĕԂ܂B
}NGXP[v͓ǂݎ܂B


read-buffer-name
[       type]: Function
[  arguments]: read-buffer-name PROMPT &key :default :history
[    package]: editor
[    seealso]: interactive
[   referred]: read-exist-buffer-name
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[obt@͂̂҂
܂B[U[̓͂obt@Ԃ܂B͂obt@݂Ȃ
ꍇ́Â܂ܕԂ܂B
(interactive "B") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂

gp:
  ;;; ~jobt@obt@ǂݍ
  (read-buffer-name "Buffer: ")   ; *scratch* Ɠ
  =>#<buffer: *scratch*>


read-char
[       type]: Function
[  arguments]: read-char &optional INPUT-STREAM EOF-ERROR-P EOF-VALUE RECURSIVE-P
[    package]: lisp
[    seealso]: read-char-no-hang , write-char
[   referred]: peek-char
[       file]: builtin.l
[    section]: o
[description]: 
w肳ꂽ̓Xg[ꕶǂݍŁAԂ܂B

  INPUT-STREAM : ̓Xg[
  EOF-ERROR-P  : EOF̏Ԃread-charƂɂǂ邩H
        t               G[ƂB
        nil             G[ƂAnilԂ܂B
  EOF-VALUE    : EOF̏Ԃread-charƂnil̑ɕԂw肵܂B
  RECURSIVE-P  : iڍוsj

gpF
  (read-char *keyboard*) <-- "a"
  => #\a

⑫F
  ֑łAEOFEnd Of File̗łBt@CXg[
  ݏIĂ܂Ԃw܂B


read-char-encoding
[       type]: Function
[  arguments]: read-char-encoding PROMPT &key :history
[    package]: editor
[    seealso]: read-exact-char-encoding , *char-encoding-list* , interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[GR[fBO͂
̂҂܂B[U[̓͂GR[fBOԂ܂B⊮
Xg *char-encoding-list* QƂĂ悤łB
(interactive "z") ɑ܂B

  PROMPT     : vvg
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂

gp:
  ;;; ~jobt@當GR[fBOǂݍ
  (read-char-encoding "Encoding: ") ; utf8n Ɠ
  =>#.(make-utf8-encoding "utf8n" "Unicode (UTF-8N)" :signature nil :windows t :byte-order nil :cjk :jp)


read-char-no-hang
[       type]: Function
[  arguments]: read-char-no-hang &optional INPUT-STREAM EOF-ERROR-P EOF-VALUE
[    package]: lisp
[    seealso]: read-char , listen
[       file]: builtin.l
[    section]: o
[description]: 
read-char ƓłBA͂ȂΑ҂ nil Ԃ܂B


read-command-name
[       type]: Function
[  arguments]: read-command-name PROMPT &key :default :history
[    package]: editor
[    seealso]: interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[R}h͂̂҂
B[U[̓͂R}h̃V{Ԃ܂B(uR}hv́uinteractive錾ꂽ֐v̈ӖŎgĂ܂)
(interactive "C") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂


read-delimited-list
[       type]: Function
[  arguments]: read-delimited-list CHAR &optional INPUT-STREAM RECURSIVE-P
[    package]: lisp
[    seealso]: read
[       file]: builtin.l
[    section]: o
[description]: 
w肵܂ Lisp IuWFNgǂݍ݁Aʂ̃XgԂ܂B

  CHAR         : Xg̏I\
  INPUT-STREAM : ͌̃Xg[
  RECURSIVE-P  : nil ȂgbvxAnon-nil ȂċAĂяoƂēǂݍ


read-directory-name
[       type]: Function
[  arguments]: read-directory-name PROMPT &key :default :title :history
[    package]: editor
[    seealso]: interactive
[   referred]: directory-name-dialog , file-name-dialog
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[fBNg͂̂
҂܂B͒ TAB L[ŃfBNg⊮ł܂B "~" ̓[U
[̃z[fBNgɁA ".." ͐efBNgɕϊ܂B[U[
̓͂fBNgԂ܂B
(interactive "D") ɑ܂B

  PROMPT     : vvg
  :default   : \fBNg
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂

gpF
  ;;; ~jobt@fBNgǂݎB
  (read-directory-name "directory: ")
  => "C:/applications/xyzzy/etc"


read-exact-char-encoding
[       type]: Function
[  arguments]: read-exact-char-encoding PROMPT &key :history
[    package]: editor
[    seealso]: read-char-encoding
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
read-char-encodingƂقړłA肪₩珜O܂B
(interactive "Z") ɑ܂B


read-exist-buffer-name
[       type]: Function
[  arguments]: read-exist-buffer-name PROMPT &key :default :history
[    package]: editor
[    seealso]: read-buffer-name , interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
read-buffer-name ƂقƂǓłA read-exist-buffer-name ͂ł
݂obt@wł܂B
(interactive "b") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂


read-exist-file-name
[       type]: Function
[  arguments]: read-exist-file-name PROMPT &key :default :title :history
[    package]: editor
[    seealso]: read-file-name , interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
read-file-name ƂقƂǓłA read-exist-file-name ͂łɑ
Ăt@Cwł܂B
(interactive "f") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :title     : ʃt@C̃^Cg
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂


read-file
[       type]: Function
[  arguments]: read-file FILENAME &optional ENCODING NOMSG
[    package]: editor
[    seealso]: find-file , insert-file-contents , insert-file
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
obt@NA FILENAME ̓e݂܂B[C-x C-r]
obt@уobt@Ɋ֘Atꂽt@C͕ύX܂B

  ENCODING : GR[fBOw肵܂B
  NOMSG    : non-nil ȂXe[^Xo[Ɍo߃bZ[W\܂B


read-file-name
[       type]: Function
[  arguments]: read-file-name PROMPT &key :default :title :history
[    package]: editor
[    seealso]: read-exist-file-name , read-file-name-list , interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[t@C͂̂҂
܂B͒ TAB L[Ńt@C⊮ł܂B "~" ̓[U[̃z[
fBNgɁA ".." ͐efBNgɕϊ܂B[U[̓͂
t@CԂ܂B
(interactive "F") ɑ܂B

  PROMPT     : vvg
  :default   : \t@C
  :title     : ʃt@C̃^Cg
  :history   : 
               minibuffer-history-variable vpeBV{w肵܂

gpF
  ;;; ~jobt@t@CǂݎB
  (read-file-name "filename: ")
  => "C:/applications/xyzzy/xyzzy.exe"


read-file-name-list
[       type]: Function
[  arguments]: read-file-name-list PROMPT &key :default :title :history
[    package]: editor
[    seealso]: read-file-name , interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
read-file-name ƂقƂǓłA read-file-name-list ͕̃t@C
wł܂B̃t@Cw肵ꍇ́ÃXgԂ܂B
(interactive "l") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :title     : ʃt@C̃^Cg
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂


read-from-string
[       type]: Function
[  arguments]: read-from-string STRING &optional EOF-ERROR-P EOF-VALUE &key :start :end :preserve-whitespace
[    package]: lisp
[    seealso]: parse-integer
[       file]: stream.l
[    section]: o
[description]: 
ǂ݁Al2̒lԂ܂B1ڂ̖߂l Lisp Reader 
ݍ񂾃IuWFNĝ́A2ڂ̖߂l͕񒆂ɂēǂ܂Ȃ
ŏ̈̕ʒułBŌ܂œǂ񂾏ꍇA2ڂ̖߂l͂
̒ƓȂ܂B

  STRING               : ǂޑΏۂł镶
  EOF-ERROR-P          : EOF̏Ԃread-from-stringƂɂǂ邩H
                non-nil    G[Ƃ܂B(ftHg)
                nil        G[ƂAnilԂ܂B
  EOF-VALUE            : EOF̏Ԃread-from-stringƂnil̑
                         ɕԂw肵܂B
  :start               : ǂݎn߂ʒu(ftHg0)
  :end                 : ǂݏIʒu(ftHg͕̒)
  :preserve-whitespace : (ڍוs)                non-nil                    nil        

read-function-name
[       type]: Function
[  arguments]: read-function-name PROMPT &key :default :history
[    package]: editor
[    seealso]: interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[֐͂̂҂܂B
[U[̓͂֐̃V{Ԃ܂B(interactive "a") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂


read-integer
[       type]: Function
[  arguments]: read-integer PROMPT
[    package]: editor
[    seealso]: interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[͂҂܂B
[U[̓͂Ԃ܂B
(interactive "n") ɑ܂B

  PROMPT     : vvg

gpF
  ;;; ~jobt@琔lǂݎB
  (read-integer "num: ")
  => 123


read-into
[       type]: Function
[  arguments]: read-into STRING &optional INPUT-STREAM EOF-ERROR-P EOF-VALUE MAX-LENGTH
[    package]: editor
[    seealso]: read
[   referred]: read-line-into
[       file]: builtin.l
[    section]: o
[description]: 
w肳ꂽ̓Xg[當ǂݍ݁Aw肳ꂽɊi[܂B
ʂ݂͔̏jIɍs܂B

  STRING       : ʂi[镶BtB|C^Ȃ΂ȂȂ
  INPUT-STREAM : ͌̃Xg[
  EOF-ERROR-P  : non-nil ȂA̓Xg[I[ɒBĂƃG[
  EOF-VALUE    : ̓Xg[ŏI[ɒBĂꍇ̖߂l
  MAX-LENGTH   : ǂݍޒ̏BftHg STRING ̖{̒

INPUT-STREAM I[ɒBĂꍇĖ߂l STRING łB

gpF
  (let ((x (make-vector 2 :element-type 'character :fill-pointer 0)))
    (read-into x (make-string-input-stream "abcdef")))
  => "ab"

  (let ((x (make-vector 10 :element-type 'character :fill-pointer 0)))
    (read-into x (make-string-input-stream "abcdef")))
  => "abcdef"

  (let ((x (make-vector 10 :element-type 'character :fill-pointer 0)))
    (read-into x (make-string-input-stream "abcdef") t nil 3))
  => "abc"


read-line
[       type]: Function
[  arguments]: read-line &optional INPUT-STREAM EOF-ERROR-P EOF-VALUE RECURSIVE-P
[    package]: lisp
[   referred]: read-line-into
[       file]: builtin.l
[    section]: o
[description]: 
w肳ꂽ̓Xg[sǂݍŕƂĕԂ܂B

  INPUT-STREAM : ͌̃Xg[
  EOF-ERROR-P  : nil ȊȌꍇA̓Xg[I[ɒBĂƃG[
  EOF-VALUE    : ̓Xg[ŏI[ɒBĂꍇ̖߂l

ڂ̖߂lƂāAsǂݍ񂾏ꍇ nil AɒBꍇ
 t Ԃ܂B

RECURSIVE-P ́A^邱Ƃ͂ł܂gp܂B


read-line-into
[       type]: Function
[  arguments]: read-line-into STRING &optional INPUT-STREAM EOF-ERROR-P EOF-VALUE
[    package]: editor
[    seealso]: read-line , read-into , read
[       file]: builtin.l
[    section]: o
[description]: 
w肳ꂽ̓Xg[sǂݍŁAw肳ꂽɊi[܂B
i[͔̕j󂳂܂B

  STRING       : ʂ𖄂ߍސ̕B
                 tB|C^AAWX^ułȂ΂ȂȂ
  INPUT-STREAM : ͌̃Xg[
  EOF-ERROR-P  : non-nil ȂA̓Xg[I[ɒBĂƃG[
  EOF-VALUE    : ̓Xg[ŏI[ɒBĂꍇ̖߂l

INPUT-STREAM I[ɒBĂꍇĖ߂l STRING łB
܂ڂ̖߂lƂāAsǂݍ񂾏ꍇ nil AI[ɒB
ꍇ t Ԃ܂B

gpF
  (let ((x (make-vector 2 :element-type 'character :fill-pointer 0 :adjustable t)))
    (read-line-into x (make-string-input-stream "abcdef")))
  => "abcdef"
  => t

  (let ((x (make-vector 2 :element-type 'character :fill-pointer 0 :adjustable t)))
    (read-line-into x (make-string-input-stream "abc\ndef")))
  => "abc"
  => nil


read-preserving-whitespace
[       type]: Function
[  arguments]: read-preserving-whitespace &optional IN-STREAM EOF-ERROR-P EOF-VALUE RECURSIVE-P
[    package]: lisp
[    seealso]: read
[       file]: builtin.l
[    section]: o
[description]: 
Xg[ Lisp ̃IuWFNgǂݍŕԂ܂B
read ƂقړłAǂ񂾍Ō̕󔒕ꍇA̕
Xg[֖߂܂B


read-registry
[       type]: Function
[  arguments]: read-registry SECTION KEY &optional ROOT
[    package]: editor
[   referred]: write-registry
[       file]: builtin.l
[    section]: VXe
[description]: 
WXgǂݍ݂܂B

  SECTION : ZNVw肵܂B
  KEY     : L[w肵܂B
  ROOT    : [gL[w肵܂B
     nil             HKEY_CURRENT_USER\Software\Free Software\Xyzzy
     :current-user   HKEY_CURRENT_USER
     :classes-root   HKEY_CLASSES_ROOT
     :local-machine  HKEY_LOCAL_MACHINE
     :users          HKEY_USERS

gpF
  ;;; HKEY_CURRENT_USER/software/Microsoft/devstudio/5.0/Recent File List/project1 ̒lǂ
  (read-registry "software\\Microsoft\\devstudio\\5.0\\Recent File List" "project1"  :current-user)


read-sexp
[       type]: Function
[  arguments]: read-sexp PROMPT
[    package]: editor
[    seealso]: interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[S͂̂҂܂B
[U[̓͂Sƕ𑽒lŕԂ܂B
(interactive "x") ɑ܂B

  PROMPT     : vvg

gpF
  ;;; ~jobt@S͂B
  (read-sexp "sexp: ")
  => (+ 3 3)
  => 7


read-string
[       type]: Function
[  arguments]: read-string PROMPT &key :default :history
[    package]: editor
[    seealso]: completing-read , interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[͂̂҂܂B
[U[̓͂Ԃ܂B
(interactive "s") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂

gpF
  ;;; ~jobt@URL͂B
  (read-string "URL: ")
  => "http://www.yahoo.co.jp"


read-symbol-name
[       type]: Function
[  arguments]: read-symbol-name PROMPT &key :default :history
[    package]: editor
[    seealso]: interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[V{͂̂҂܂B
[U[̓͂V{Ԃ܂B(interactive "S") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂


read-variable-name
[       type]: Function
[  arguments]: read-variable-name PROMPT &key :default :history
[    package]: editor
[    seealso]: interactive
[       file]: builtin.l
[    section]: ~jobt@
[description]: 
~jobt@Ƀvvg\ă[U[ϐ͂̂҂܂B
[U[̓͂ϐ̃V{Ԃ܂B(interactive "v") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : 
               minibuffer-history-variablevpeBV{w肵܂


readtable-case
[       type]: Function
[  arguments]: readtable-case READTABLE
[    package]: lisp
[    seealso]: si:*set-readtable-case , *readtable*
[       file]: builtin.l
[    section]: o
[description]: 
READTABLE  case sensitivity Ԃ܂B
̒l̓V{ read  print ̍ۂ̋ɉe܂B

߂l
  :upcase       read ̍ۂɃAt@xbg啶ɕϊ
                print ̍ۂɏ܂ރV{GXP[v
  :downcase     read ̍ۂɃAt@xbgɕϊ
                print ̍ۂɑ啶܂ރV{GXP[v
  :preserve     啶̕ϊEGXP[vȂ (ftHg)
  :invert       read  :preserve ƓH
                print ̍ۂɃAt@xbg܂ރV{GXP[v

[he[u case sensitivity ύXɂ si:*set-readtable-case
܂ setf g܂B

:
  (let ((*readtable* (copy-readtable *readtable*)))
    (dolist (rtc '(:upcase :downcase :preserve :invert))
      (setf (readtable-case *readtable*) rtc)
      (print (read-from-string "Foo"))))
  -> FOO
  -> foo
  -> Foo
  -> |Foo|
  => nil


readtablep
[       type]: Function
[  arguments]: readtablep OBJECT
[    package]: lisp
[    seealso]: *readtable*
[       file]: builtin.l
[    section]: o
[description]: 
OBJECT [he[uȂ t AȊOȂ nil Ԃ܂B


realp
[       type]: Function
[  arguments]: realp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT  real number Ȃ t AȊOȂ nil Ԃ܂B


realpart
[       type]: Function
[  arguments]: realpart NUMBER
[    package]: lisp
[    seealso]: imagpart , complex
[       file]: builtin.l
[    section]: l
[description]: 
f̎擾܂B

gpF
  (setq a (complex 1 3))
  =>#C(1 3)

  (realpart a)
  =>1


recenter
[       type]: Function
[  arguments]: recenter &optional ARG
[    package]: editor
[       file]: window.l
[    section]: EBhE
[description]: 
obt@XN[ĉʏ̕\ʒu𒲐܂B[C-l]
w肵ȂΌݍsʂ̒Ɉʒu܂B
(recenter 0) ŌݍsEChËԏɗ܂B

  ARG : ̃J[\ʒu
   nil          ʒ̍sɈړB
   ̏ꍇ   ̐ȂAEBhȄォ̍sB
                ̐ȂAEBhẺ̍sB

߂l
  J[\ړt
            ړȂnil


redo
[       type]: Function
[  arguments]: redo
[    package]: editor
[    seealso]: undo , buffer-can-redo-p
[       file]: builtin.l
[    section]: obt@
[description]: 
ɖ߂ēxs܂B[C-_],[S-End],[F12]

buffer-can-redo-p  t ̎̂ݎs\łB


reduce
[       type]: Function
[  arguments]: reduce FUNCTION SEQUENCE &key :from-end :start :end :initial-value
[    package]: lisp
[       file]: sequence.l
[    section]: V[PX
[description]: 
2ZqłFUNCTIONŁASEQUENCEɑ΂ďݍ݂s܂B
  
  FUNCTION  : 2ZqB
  :from-end : nil Ȃ擪Anon-nil ȂŌ̗vfݍ݂s܂B
  :start    : ݍ݂s SEQUENCE ̊JnCfbNXłBftHg 0 łB 
              :from-end  non-nil ȂICfbNXɂȂ܂B
  :END      : ݍ݂s SEQUENCE ̏ICfbNXłBftHg nil łB
              :from-end  non-nil ȂJnCfbNXɂȂ܂B
  :INITIAL-VALUE : non-nil Ȃ΂̒llƂĎgp܂B

 (reduce #'- '(1 2 3)) = (- (- 1 2) 3)
 (reduce #'- '(1 2 3) :initial-value 10) = (- (- (- 10 1) 2) 3)
 (reduce #'- '(1 2 3) :from-end t :initial-value 10) = (- 1 (- 2 (- 3 10)))


refresh-screen
[       type]: Function
[  arguments]: refresh-screen &optional F
[    package]: editor
[    seealso]: do-events , sit-for , sleep-for
[   referred]: get-window-line
[       file]: builtin.l
[    section]: ̑
[description]: 
ʂtbV܂B
L[͂̕ʂ̍ĕ`D悳܂B]āAOvZX
ɓ͂镶obt@ɏo͂A̓rŃ_CAO\
ƁAʂǂĂȂꍇ܂B̂悤ȏꍇɎs܂B


refresh-tool-bars
[       type]: Function
[  arguments]: refresh-tool-bars
[    package]: editor
[       file]: builtin.l
[    section]: j[
[description]: 
c[o[tbV܂B
lisp/optprop.l̒狤ʐݒ̕ύXeAc[o[ɔf邽߂ɗp
Ă܂B


regexp-keyword-list
[       type]: Variable
[    package]: editor
[    seealso]: K\̕\L
[   referred]: compile-regexp-keyword-list
[    section]: EK\
[description]: 
K\pL[[h̐F@\łBL[[h256
x炵łB

gpF
  (defvar *c-number-formats*
    (compile-regexp-keyword-list
     '(("\\(^\\|\\_S\\)\\(?:[0-9]+\\.[0-9]*\\|\\.[0-9]+\\)\\(?:e[-+]?[0-9]+\\)?[fl]?\\($\\|\\_S\\)"
        t (:keyword 0 :bold) nil -1 -2)
       ("\\_<[0-9]+e[-+]?[0-9]+[fl]?\\_>" t 1)
       ("\\_<\\([1-9][0-9]*\\|0[0-7]*\\|0x[0-9a-f]+\\)\\(u?l\\|l?u\\|u?i64\\)?\\_>"
        t (:color 1 2 :underline)))))
  (make-local-variable 'regexp-keyword-list)
  (setq regexp-keyword-list *c-number-formats*)

`F
  (compile-regexp-keyword-list
   '((regexp1 case-fold color [ context [ begin [ end ] ] ] )
     (regexp2 case-fold color [ context [ begin [ end ] ] ] )
     ...
     (regexpN case-fold color [ context [ begin [ end ] ] ] )))

p^F
  regexp  
      K\
  case-fold
      non-nil  K\̃}b`Oő啶ʂȂ
      nil      K\̃}b`Oő啶ʂ
  color
      ̉ꂩ̌`Ŏw肵܂B
      keyword-color
          0-2       L[[h1-3̐F
          3-5       L[[h1-3̐Fł̃L[[h] 
          6-8       L[[h1-3̐Fł̍s̒[[܂Ŕ]
          9         PȂbold 
          10-18     0-8ƓFbold
          :string   ̐F 
          :comment  Rg̐F 
          :tag      ^O̐F 
      (:keyword keyword-color [attributes])
          keyword-color
              keyword-color̒l
          attributes
              :bold        {[h 
              :underline   A_[C 
              :strike-out   
              :line        s܂邲 
      (:color foreground [background [attributes]]) 
          foreground
              0-15  OiF
          background 
              0     w肵Ȃ
              1-15  wiF
  context
      L[[hLȕw肵܂B̃V{
      V{̃Xgw肵܂Bw肵Ȃꍇɂ́Anilw
      肳ꂽ̂Ƃē삵܂B
      :string   ŗL
      :tag      ^O̓ŗL
      :comment  Rg̓ŗL
      nil       LȊOŗL
      t         SĂ̕ŗL
  begin
      }b`eLXg̐Ft镔̊Jnʒuw肵܂B
      0-9Ȃ(match-beginning begin)̈ʒułB-1--9Ȃ
      (match-end (- begin))̈ʒułBw肵Ȃnil̏ꍇ
      (match-beginning 0)̈ʒułB
  end
      }b`eLXg̐Ft镔̏Iʒuw肵܂B
      0-9Ȃ(match-end end)̈ʒu܂łłB-1--9Ȃ
      (match-beginning (- end))̈ʒu܂łłBw肵Ȃnil̏ꍇ
      (match-end 0)̈ʒu܂łłB


regexp-quote
[       type]: Function
[  arguments]: regexp-quote REGEXP
[    package]: editor
[       file]: builtin.l
[    section]: EK\
[description]: 
REGEXP̃^GXP[v\Ԃ܂B
Ⴆ΁AuK\̃^܂ޕv܂
K\Ōꍇɕ֗łB
gpF
  (regexp-quote "a+b*")
  =>"a\\+b\\*"


regexpp
[       type]: Function
[  arguments]: regexpp OBJECT
[    package]: editor
[    seealso]: compile-regexp
[       file]: builtin.l
[    section]: f[^^
[description]: 
w肳ꂽOBJECTRpCςݐK\Ԃ܂B

  t     OBJECT̓RpCςݐK\
  nil   OBJECT̓RpCςݐK\ł͂Ȃ


region-beginning
[       type]: Function
[  arguments]: region-beginning
[    package]: editor
[    seealso]: region-end , selection-mark , mark , point
[       file]: builtin.l
[    section]: |WV
[description]: 
[W̊Jñ|CgԂ܂B

  ; markpointƂ̊֌W
  (= (region-beginning) (min (mark) (point)))
  =>t


region-end
[       type]: Function
[  arguments]: region-end
[    package]: editor
[    seealso]: region-beginning , selection-point , mark , point
[       file]: builtin.l
[    section]: |WV
[description]: 
[W̏I[̃|CgԂ܂B

  ; markpointƂ̊֌W
  (= (region-end) (max (mark) (point)))
  =>t


register-history-variable
[       type]: Function
[  arguments]: register-history-variable VAR
[    package]: editor
[    seealso]: define-history-variable , unregister-history-variable
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
łɒ`ꂽϐ VAR qXgϐɓo^܂B
t@Cɏ܂邽߁Aϐ̓e readable łKv܂B
readable łƂ́A̓IɌƁuAAlAV{
̃Xgō\f[^v̂ƂłB
  VAR : qXgϐɓo^ϐ̃V{A͂̃Xg


rem
[       type]: Function
[  arguments]: rem NUMBER DIVISOR
[    package]: lisp
[    seealso]: truncate , mod
[       file]: builtin.l
[    section]: l
[description]: 
(truncate NUMBER DIVISOR)̖߂l̓ڂԂ܂B

gpF  
  (rem 13 4)
  => 1
  (rem -13 4)
  => -1


remhash
[       type]: Function
[  arguments]: remhash KEY HASH-TABLE
[    package]: lisp
[    seealso]: make-hash-table
[       file]: builtin.l
[    section]: nbV
[description]: 
nbVe[u̒L[v̂폜܂B

  KEY        : 폜L[w肵܂B
  HASH-TABLE : nbVe[uw肵܂B

vL[݂΍폜tԂ܂B
ȂnilԂ܂B

gpF
  (setq hash-table (make-hash-table))
  => #<hash table>
  (setf (gethash 'a hash-table) 1)
  => 1
  (remhash 'b hash-table)
  => nil
  (remhash 'a hash-table)
  => t


remove
[       type]: Function
[  arguments]: remove ITEM SEQUENCE &key :from-end :test :test-not :start :end :count :key
[    package]: lisp
[    seealso]: delete , remove-if , remove-if-not , remove-duplicates
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE ̒ ITEM ƈv̂폜V[PXԂ܂B
 SEQUENCE ͕ۑ܂B

  :count    : 폜镶𐧌܂B
  :from-end : :countw肳ꂽꍇɂ݈̂Ӗ܂B
         nil    SEQUENCE̐擪폜܂B
         t      SEQUENCĚ폜܂B

gpF
  ;;; removedeletegĂ݂B
  (setq foo "abcabcdef")        => "abcabcdef"
  (remove #\b foo)              => "acacdef"
  foo                           => "abcabcdef"
  (delete #\b foo)              => "acacdef"
  foo                           => "acacdef"


remove-duplicates
[       type]: Function
[  arguments]: remove-duplicates SEQUENCE &key :from-end :test :test-not (:start 0) :end (:key #'identity)
[    package]: lisp
[    seealso]: remove , delete-duplicates
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE ̒dvf폜V[PXԂ܂B
remove lA SEQUENCE ͕ۑ܂B

  :from-end  non-nil ȂV[PX̏I肩dvf폜Ă܂B


remove-if
[       type]: Function
[  arguments]: remove-if PREDICATE SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: remove , remove-if-not , delete-if
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE ̒ PREDICATE 𖞂̂폜V[PXԂ܂B
 SEQUENCE ͕ۑ܂B


remove-if-not
[       type]: Function
[  arguments]: remove-if-not PREDICATE SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: remove , remove-if , delete-if-not
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE̒PREDICATE𖞂Ȃ̂폜V[PXԂ܂B
SEQUENCE͕ۑ܂B


remove-trail-slash
[       type]: Function
[  arguments]: remove-trail-slash STRING
[    package]: editor
[    seealso]: append-trail-slash
[   referred]: directory-namestring
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
STRING̖"/"΍폜Ԃ܂B
gpF
  (remove-trail-slash "ffjfj")
  =>"ffjfj"

  (remove-trail-slash "ffjfj/")
  =>"ffjfj"


remprop
[       type]: Function
[  arguments]: remprop SYMBOL INDICATOR
[    package]: lisp
[    seealso]: get
[       file]: builtin.l
[    section]: V{
[description]: 
V{̃vpeB폜܂B

  SYMBOL    : vpeBԂV{
  INDICATOR : vpeB̃CWQ[^[

gpF
  ;;; ֐̐폜Ă݂B
  (defun foo (x) "increment" (1+ x))            => foo
  (get 'foo 'lisp::function-documentation)      => "increment"
  (remprop 'foo 'lisp::function-documentation)  => t
  (get 'foo 'lisp::function-documentation)      => nil


rename
[       type]: Function
[  arguments]: rename FILENAME &optional NOWARN
[    package]: editor
[    seealso]: rename-buffer , set-buffer-file-name , rename-file
[       file]: buffer.l
[    section]: obt@
[description]: 
obt@Ɋ֘AÂꂽt@CύX܂Bobt@ɕύX܂B
ύXɐnilȊO̒lAsnilԂ܂B[C-x C-n]

gpF
  ;;; Jgobt@̃t@C"c:/foo.baz"ɕύX܂B
  ;;; ɁAobt@"foo.baz"ɂȂ܂B
  (rename "c:/foo.baz")


rename-buffer
[       type]: Function
[  arguments]: rename-buffer BUFFER-NAME &optional BUFFER
[    package]: editor
[    seealso]: rename , buffer-name
[   referred]: rename-file
[       file]: builtin.l
[    section]: obt@
[description]: 
t@C͕ςɃobt@ύX܂B


rename-file
[       type]: Function
[  arguments]: rename-file FILE NEW-NAME &key :if-exists :if-access-denied
[    package]: lisp
[    seealso]: rename , rename-buffer
[   referred]: copy-file , delete-file
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@CύX܂B
  
  FILE              : ύXÕt@Cw肵܂B
  NEW-NAME          : ύX̃t@Cw肵܂B
  :if-exists        : t@C݂ꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
        :overwrite      ㏑܂B
        :newer          VΏ㏑܂B
  :if-access-denied : ANZXۂꂽꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂B
        :force          IɃt@C̕ύX݂܂B

ύXłǂŖ߂lς܂B

  t   ύXɐ
  nil ύXɎs

gpF
  (rename-file "C:/xyzzy/test.txt" "C:/xyzzy/test2.txt")
  => t


rename-pseudo-frame
[       type]: Function
[  arguments]: rename-pseudo-frame NAME
[    package]: editor
[       file]: pframe.l
[    section]: EBhE
[description]: 
ݑIĂt[̖O NAME ɕύX܂B


repeat-backward-search
[       type]: Function
[  arguments]: repeat-backward-search
[    package]: editor
[    seealso]: repeat-forward-search , search-forward-again , re-search-forward-again
[       file]: search.l
[    section]: EK\
[description]: 
O񌟍ēx܂B[S-F5]

ǑK\ɂ̂łΐK\gāAłȂ
̂悤Ɏs܂B


repeat-complex-command
[       type]: Function
[  arguments]: repeat-complex-command SEXP
[    package]: editor
[    seealso]: execute-extended-command
[       file]: cmds.l
[    section]: ~jobt@
[description]: 
execute-extended-commandiM-xjł̃R}hŝ܂܂̈
ōēxs܂B[ESC p]


repeat-forward-search
[       type]: Function
[  arguments]: repeat-forward-search
[    package]: editor
[    seealso]: repeat-backward-search , search-forward-again , re-search-forward-again
[       file]: search.l
[    section]: EK\
[description]: 
O񌟍ēxO܂B[F5]

ǑK\ɂ̂łΐK\gāAłȂ
̂悤Ɏs܂B


replace
[       type]: Function
[  arguments]: replace SEQUENCE1 SEQUENCE2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: substitute-string
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE1  SEQUENCE2 Œu܂B SEQUENCE ͒u܂B
SEQUENCE1  :start1-:end1 ̈ʒuɁA SEQUENCE2  :start2-:end2 }
܂B

gpF
  (setq foo (make-sequence 'string 8 :initial-element #\a))
  => "aaaaaaaa"
  (setq bar (make-sequence 'string 3 :initial-element #\b))
  => "bbb"
  (replace foo bar)
  => "bbbaaaaa"
  (replace foo bar :start1 4 :end1 5)
  => "bbbabaaa"


replace-buffer
[       type]: Function
[  arguments]: replace-buffer PATTERN REPLACEMENT &key :case-fold :tail :regexp :left-bound :right-bound :once :literal :last-match
[    package]: editor
[    seealso]: replace-string , perform-replace , substitute-string , gresreg , K\̕\L
[   referred]: replace-match
[       file]: builtin.l
[    section]: EK\
[description]: 
obt@̕Ēu܂Breplace-stringperform-replace
gĎĂ܂B

gpF
 ;;;  pƊ̊Ԃɋ󔒂P
 (replace-buffer "\\([A-Za-z0-9_]\\) *\\([\X8200-\X9fff\Xe000-\Xfcff]\\)"
    "\\1 \\2" :regexp t)


replace-match
[       type]: Function
[  arguments]: replace-match STRING &key :literal
[    package]: editor
[    seealso]: replace-buffer , match-data , store-match-data
[       file]: builtin.l
[    section]: EK\
[description]: 
ǑʂɊÂāA STRING ɂ郁^߂u
܂B :literal  nil ȊȌꍇ́A^ӎ܂B

^F
   \0, \&    vS
   \1 ` \9  K\ł\(\)ɑΉ镶

gpF
  ;;; <!---->[]ɒuꍇ
  (when (scan-buffer "<!--\\(.+\\)-->" :regexp t)
    (replace-match "[\\1]"))
  => t


replace-string
[       type]: Function
[  arguments]: replace-string PATTERN REPLACEMENT &optional NOERROR
[    package]: editor
[    seealso]: query-replace , replace-buffer , substitute-string
[   referred]: perform-replace
[       file]: search.l
[    section]: EK\
[description]: 
obt@ĕŒu܂Bperform-replacegĎ
܂B [M-r]

  PATTERN     : uOłB
  REPLACEMENT : u㕶łB
  NOERROR     : 񂪌ȂƂɃG[oH

replacen̊֐̌nF
  replace-string         FinteractiveȊ֐ƂĐ錾ĂB
    perform-replace    Fʂ͂ŏ\̔
        replace-buffer F낢ƍׂݒ肵΂ōsB

gpF
  (defun test-proc ()
    (interactive)
    (replace-string "aaa" "xxx"))   ;; aaaxxxɒu


require
[       type]: Function
[  arguments]: require MODULE-NAME &optional PATHNAME
[    package]: lisp
[    seealso]: load-library , provide , *modules* , e탍[h֌W̊֐̈Ⴂ
[       file]: evalmacs.l
[    section]: ]
[description]: 
w肵W[ǂݍ݂܂BɓǍς݂łΉ܂B

݊F
  Common Lispɂ͂B
  muleɂ͂ȂB

gpF
  (require "foreign")


resolve-shortcut
[       type]: Function
[  arguments]: resolve-shortcut PATHNAME
[    package]: editor
[    seealso]: create-shortcut
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
V[gJbgt@C߂܂B

  PATHNAME : V[gJbgw肵܂B

gpF
  (resolve-shortcut "d:/winnt/profiles/henmi2/personal/my documentsւ̃V[gJbg.lnk")
  => "G:/My Documents"


rest
[       type]: Function
[  arguments]: rest LIST
[    package]: lisp
[    seealso]: cdr
[       file]: evalmacs.l
[    section]: Xg
[description]: 
cdr̕ʖłB 
S܂B 

gpF 
  ;;; cdrƓB 
  (cdr '(1 2 3))
  => (2 3)
  (rest '(1 2 3))
  => (2 3)
  (symbol-function 'cdr)
  => #<function: cdr>
  (symbol-function 'rest)
  => #<function: cdr>
 
QlF 
  ;;; evalmacs.l̒`
  (si:*fset 'rest #'cdr)


restore-window-configuration-register
[       type]: Function
[  arguments]: restore-window-configuration-register R
[    package]: editor
[    seealso]: save-window-configuration-to-register
[       file]: register.l
[    section]: EBhE
[description]: 
WX^ R ɕۑEBhEԂɖ߂܂B[C-x r c]
R  window-configuration ĂȂƃG[ɂȂ܂B


return
[       type]: Macro
[  arguments]: return &optional RESULT
[    package]: lisp
[    seealso]: return-from
[       file]: evalmacs.l
[    section]: \
[description]: 
w肳ꂽlŃubNEo܂B
catchĂubNȂƗO܂B

  (return RESULT) = (return-from nil RESULT)

gpF
  ;;; [v̒Eȍꍇ
  (loop (if (yes-or-no-p "quit?") (return 123)))
  => 123

  ;;; ubN̂catchłȂꍇ
  (if (yes-or-no-p "quit?") (return 123))
  => `return-from'̃Lb`QƂł܂: nil


return-from
[       type]: Special Form
[  arguments]: return-from NAME [RESULT]
[    package]: lisp
[   referred]: block , return
[       file]: builtin.l
[    section]: \
[description]: 
ubNEo܂B


revappend
[       type]: Function
[  arguments]: revappend X Y
[    package]: lisp
[    seealso]: nreconc
[       file]: builtin.l
[    section]: Xg
[description]: 
X 𔽓] Y XgԂ܂B
 X ͕ۑ܂B

  (revappend x y) == (append (reverse x) y)
  
revappend̕ǂ悤łB


reverse
[       type]: Function
[  arguments]: reverse SEQUENCE
[    package]: lisp
[    seealso]: nreverse
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE tɂVV[PX쐬ĕԂ܂B
 SEQUENCE ͕ۑ܂B


reverse-region
[       type]: Function
[  arguments]: reverse-region FROM TO &optional TEMPORARY
[    package]: editor
[    seealso]: clear-reverse-region
[       file]: builtin.l
[    section]: [W
[description]: 
[W𔽓]\܂B
TEMPORARYnon nilȂ΁ÃL[͂Ŕ]\ɖ߂܂B


rewind-ime-composition
[       type]: Function
[  arguments]: rewind-ime-composition &optional NODELETE POP
[    package]: editor
[    seealso]: ime-push-composition-string
[       file]: kanji.l
[    section]: 
[description]: 
O IME ŕϊmԂɖ߂܂B[C-c C-c]
ϊłȂ΁AOɕϊmԂő}܂B


rotatef
[       type]: Macro
[  arguments]: rotatef {PLACE}*
[    package]: lisp
[    seealso]: setf , shiftf
[       file]: setf.l
[    section]: ϐƒ萔
[description]: 
Ƃė^ꂽl̊i[ꏊ̓e[e[V܂B

        a   b   c 
sOF 1   2   3
            
          
   (*)      (*)
                      
        a   b   c 
sF 2   3   1
            
gpF
  ;;; a b cɐlrotatefB
  (setq a 1 b 2 c 3)    => 3
  (list a b c)          => (1 2 3)
  (rotatef a b c)       => 1
  (list a b c)          => (2 3 1)


round
[       type]: Function
[  arguments]: NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: floor , ceiling , truncate , fround
[       file]: builtin.l
[    section]: l
[description]: 
NUMBER߂̐Ɋۂ߂܂B
傤0.5̏ꍇɂ͋Ɋۂ߂܂B

gpF 
  (round 2.5)
  => 2
  (round 2.6)
  => 3
  (round 3.5)
  => 4
  (round -2.5)
  => -2
  (round -2.6)
  => -3
  (multiple-value-list (round 2.5))
  => (2 0.5)


row-major-aref
[       type]: Function
[  arguments]: row-major-aref ARRAY INDEX
[    package]: lisp
[    seealso]: aref , svref , array-row-major-index
[       file]: builtin.l
[    section]: z
[description]: 
ARRAY ꎟ̔zƂ݂ȂƂɁAINDEX ԖڂɂȂvfԂ܂B

gp:
  (setf x (make-array '(2 3) :initial-contents '((a b c) (d e f))))
  => #2A((a b c) (d e f))
  (row-major-aref x 0)
  => a
  (row-major-aref x 2)
  => c
  (row-major-aref x 3)
  => d


rplaca
[       type]: Function
[  arguments]: rplaca X Y
[    package]: lisp
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg X  car  Y ɒuāAu X Ԃ܂B
(progn (setf (car X) Y) X)Ɠł傤B

gpF
  ;;; uĂ݂B
  (setq g '(a b c)) 
  => (a b c)
  (rplaca (cdr g) 'd)
  => (d c) 
  g
  => (a d c)


rplacd
[       type]: Function
[  arguments]: rplacd X Y
[    package]: lisp
[       file]: builtin.l
[    section]: Xg
[description]: 
Xg X  cdr  Y ɒuāAu X Ԃ܂B
(progn (setf (cdr X) Y) X)Ɠł傤B

gpF
  ;;; uĂ݂B
  (setq x '(a b c)) 
  (rplacd x 'd)
  => (a . d) 
  x
  => (a . d)


run-console
[       type]: Function
[  arguments]: run-console
[    package]: editor
[       file]: process.l
[    section]: vZX
[description]: 
xyzzy ̊OŃR\[N܂B
ϐ *eshell* ܂ *shell* ̒lsR}hƂĎg܂B


run-hook-with-args
[       type]: Function
[  arguments]: run-hook-with-args HOOK &rest ARGS
[    package]: editor
[    seealso]: run-hooks
[   referred]: run-hook-with-args-until-success , run-hook-with-args-while-success
[       file]: builtin.l
[    section]: [h
[description]: 
run-hooksƓ悤Ɋ֐s܂Brun-hooksƈقȂ
wł܂B


run-hook-with-args-until-success
[       type]: Function
[  arguments]: run-hook-with-args-until-success HOOK &rest ARGS
[    package]: editor
[    seealso]: run-hook-with-args , run-hook-with-args-while-success
[   referred]: *before-save-buffer-hook* , *find-file-file-not-found-hook* , run-hooks
[       file]: builtin.l
[    section]: [h
[description]: 
run-hooksƓ悤Ɋ֐s܂Brun-hooksƈقȂ߂l
non-nilɂȂ܂ŏԂɎs܂B


run-hook-with-args-while-success
[       type]: Function
[  arguments]: run-hook-with-args-while-success HOOK &rest ARGS
[    package]: editor
[    seealso]: run-hook-with-args , run-hook-with-args-until-success
[   referred]: *query-kill-buffer-hook* , run-hooks
[       file]: builtin.l
[    section]: [h
[description]: 
run-hooksƓ悤Ɋ֐s܂Brun-hooksƈقȂ߂l
non-nil̊ԂԂɎs܂B


run-hooks
[       type]: Function
[  arguments]: run-hooks &rest HOOKLIST
[    package]: editor
[    seealso]: run-hook-with-args , run-hook-with-args-until-success , run-hook-with-args-while-success
[   referred]: add-hook
[       file]: builtin.l
[    section]: [h
[description]: 
tbNϐԂɎs܂BtbNϐ̏ڍׂadd-hookQƂĉB

  HOOKLIST : tbNϐw肵܂Bׂď܂B
             ׂďԂɎs܂B

tbNϐ̎sɂ͈邱Ƃo܂B
ǂĂꍇɂ́Arun-hook-with-argsg܂傤B

gpF
  ;;; c-mode.l
  (run-hooks 'c-mode-hook)


safe-caaaar
[       type]: Function
[  arguments]: safe-caaaar X
[    package]: lisp
[    seealso]: safe-car
[       file]: list.l
[    section]: Xg
[description]: 
safe-caaaar Ԃ܂B

  (safe-caaaar X) = (safe-car (safe-car (safe-car (safe-car X))))


safe-caaadr
[       type]: Function
[  arguments]: safe-caaadr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-caaadr Ԃ܂B

  (safe-caaadr X) = (safe-car (safe-car (safe-car (safe-cdr X))))


safe-caaar
[       type]: Function
[  arguments]: safe-caaar X
[    package]: lisp
[    seealso]: safe-car
[       file]: list.l
[    section]: Xg
[description]: 
safe-caaar Ԃ܂B

  (safe-caaar X) = (safe-car (safe-car (safe-car X)))


safe-caadar
[       type]: Function
[  arguments]: safe-caadar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-caadar Ԃ܂B

  (safe-caadar X) = (safe-car (safe-car (safe-cdr (safe-car X))))


safe-caaddr
[       type]: Function
[  arguments]: safe-caaddr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-caaddr Ԃ܂B

  (safe-caaddr X) = (safe-car (safe-car (safe-cdr (safe-cdr X))))


safe-caadr
[       type]: Function
[  arguments]: safe-caadr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-caadr Ԃ܂B

  (safe-caadr X) = (safe-car (safe-car (safe-cdr X)))


safe-caar
[       type]: Function
[  arguments]: safe-caar X
[    package]: lisp
[    seealso]: safe-car
[       file]: list.l
[    section]: Xg
[description]: 
safe-caar Ԃ܂B

  (safe-caar X) = (safe-car (safe-car X))


safe-cadaar
[       type]: Function
[  arguments]: safe-cadaar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cadaar Ԃ܂B

  (safe-cadaar X) = (safe-car (safe-cdr (safe-car (safe-car X))))


safe-cadadr
[       type]: Function
[  arguments]: safe-cadadr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cadadr Ԃ܂B

  (safe-cadadr X) = (safe-car (safe-cdr (safe-car (safe-cdr X))))


safe-cadar
[       type]: Function
[  arguments]: safe-cadar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cadar Ԃ܂B

  (safe-cadar X) = (safe-car (safe-cdr (safe-car X)))


safe-caddar
[       type]: Function
[  arguments]: safe-caddar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-caddar Ԃ܂B

  (safe-caddar X) = (safe-car (safe-cdr (safe-cdr (safe-car X))))


safe-cadddr
[       type]: Function
[  arguments]: safe-cadddr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cadddr Ԃ܂B

  (safe-cadddr X) = (safe-car (safe-cdr (safe-cdr (safe-cdr X))))


safe-caddr
[       type]: Function
[  arguments]: safe-caddr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-caddr Ԃ܂B

  (safe-caddr X) = (safe-car (safe-cdr (safe-cdr X)))


safe-cadr
[       type]: Function
[  arguments]: safe-cadr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cadr Ԃ܂B

  (safe-cadr X) = (safe-car (safe-cdr X))


safe-car
[       type]: Function
[  arguments]: safe-car X
[    package]: lisp
[    seealso]: car
[   referred]: safe-caaaar , safe-caaadr , safe-caaar , safe-caadar , safe-caaddr , safe-caadr , safe-caar , safe-cadaar , safe-cadadr , safe-cadar , safe-caddar , safe-cadddr , safe-caddr , safe-cadr , safe-cdaaar , safe-cdaadr , safe-cdaar , safe-cdadar , safe-cdaddr , safe-cdadr , safe-cdar , safe-cddaar , safe-cddadr , safe-cddar , safe-cdddar
[       file]: list.l
[    section]: Xg
[description]: 
(car X)  X  nil  cons łȂ΃G[ɂȂ܂
 safe-car ̓G[𔭐 nil Ԃ܂B

gpF
  ;;; carsafe-car̈Ⴂ
  (car "abc")
  => sȃf[^^ł: "abc": cons
  (safe-car "abc")
  => nil


safe-cdaaar
[       type]: Function
[  arguments]: safe-cdaaar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdaaar Ԃ܂B

  (safe-cdaaar X) = (safe-cdr (safe-car (safe-car (safe-car X))))


safe-cdaadr
[       type]: Function
[  arguments]: safe-cdaadr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdaadr Ԃ܂B

  (safe-cdaadr X) = (safe-cdr (safe-car (safe-car (safe-cdr X))))


safe-cdaar
[       type]: Function
[  arguments]: safe-cdaar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdaar Ԃ܂B

  (safe-cdaar X) = (safe-cdr (safe-car (safe-car X)))


safe-cdadar
[       type]: Function
[  arguments]: safe-cdadar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdadar Ԃ܂B

  (safe-cdadar X) = (safe-cdr (safe-car (safe-cdr (safe-car X))))


safe-cdaddr
[       type]: Function
[  arguments]: safe-cdaddr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdaddr Ԃ܂B

  (safe-cdaddr X) = (safe-cdr (safe-car (safe-cdr (safe-cdr X))))


safe-cdadr
[       type]: Function
[  arguments]: safe-cdadr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdadr Ԃ܂B

  (safe-cdadr X) = (safe-cdr (safe-car (safe-cdr X)))


safe-cdar
[       type]: Function
[  arguments]: safe-cdar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdar Ԃ܂B

  (safe-cdar X) = (safe-cdr (safe-car X))


safe-cddaar
[       type]: Function
[  arguments]: safe-cddaar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cddaar Ԃ܂B

  (safe-cddaar X) = (safe-cdr (safe-cdr (safe-car (safe-car X))))


safe-cddadr
[       type]: Function
[  arguments]: safe-cddadr X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cddadr Ԃ܂B

  (safe-cddadr X) = (safe-cdr (safe-cdr (safe-car (safe-cdr X))))


safe-cddar
[       type]: Function
[  arguments]: safe-cddar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cddar Ԃ܂B

  (safe-cddar X) = (safe-cdr (safe-cdr (safe-car X)))


safe-cdddar
[       type]: Function
[  arguments]: safe-cdddar X
[    package]: lisp
[    seealso]: safe-car , safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdddar Ԃ܂B

  (safe-cdddar X) = (safe-cdr (safe-cdr (safe-cdr (safe-car X))))


safe-cddddr
[       type]: Function
[  arguments]: safe-cddddr X
[    package]: lisp
[    seealso]: safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cddddr Ԃ܂B

  (safe-cddddr X) = (safe-cdr (safe-cdr (safe-cdr (safe-cdr X))))


safe-cdddr
[       type]: Function
[  arguments]: safe-cdddr X
[    package]: lisp
[    seealso]: safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cdddr Ԃ܂B

  (safe-cdddr X) = (safe-cdr (safe-cdr (safe-cdr X)))


safe-cddr
[       type]: Function
[  arguments]: safe-cddr X
[    package]: lisp
[    seealso]: safe-cdr
[       file]: list.l
[    section]: Xg
[description]: 
safe-cddr Ԃ܂B

  (safe-cddr X) = (safe-cdr (safe-cdr X))


safe-cdr
[       type]: Function
[  arguments]: safe-cdr X
[    package]: lisp
[    seealso]: cdr
[   referred]: safe-caaadr , safe-caadar , safe-caaddr , safe-caadr , safe-cadaar , safe-cadadr , safe-cadar , safe-caddar , safe-cadddr , safe-caddr , safe-cadr , safe-cdaaar , safe-cdaadr , safe-cdaar , safe-cdadar , safe-cdaddr , safe-cdadr , safe-cdar , safe-cddaar , safe-cddadr , safe-cddar , safe-cdddar , safe-cddddr , safe-cdddr , safe-cddr
[       file]: list.l
[    section]: Xg
[description]: 
(cdr X)  X  nil  cons łȂ΃G[ɂȂ܂
 safe-cdr ̓G[𔭐 nil Ԃ܂B


save-all-buffers
[       type]: Function
[  arguments]: save-all-buffers
[    package]: editor
[    seealso]: save-all-buffers-kill-xyzzy , save-some-buffers
[   referred]: save-buffer
[       file]: files.l
[    section]: t@CVXe
[description]: 
ׂẴobt@ۑ܂B
t@Cobt@ɑ΂Ă͊mFɕۑ܂B
t@CȂobt@ɑ΂ẮA_CAOŕۑt@Cw肳܂B


save-all-buffers-kill-xyzzy
[       type]: Function
[  arguments]: save-all-buffers-kill-xyzzy
[    package]: editor
[    seealso]: save-buffers-kill-xyzzy , kill-xyzzy , save-some-buffers , save-all-buffers
[       file]: files.l
[    section]: t@CVXe
[description]: 
ׂẴobt@ۑ xyzzy I܂B
save-all-buffers  kill-xyzzy ̑gݍ킹łB


save-buffer
[       type]: Function
[  arguments]: save-buffer &optional CHAR-ENCODING EOL-CODE
[    package]: editor
[    seealso]: emacs-write-file , write-file , *before-save-buffer-hook* , *after-save-buffer-hook* , *save-buffer-no-filenames-hook* , make-backup-files , buffer-truncated-p , buffer-modified-p , save-all-buffers , save-some-buffers
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
obt@̓eAobt@Ɋ֘Atꂽt@Cɏ݂܂B[C-x C-s]

obt@ɕύXꍇ͉܂B
obt@ɕύXA֘Atꂽt@CȂꍇAG[ɂȂ܂B

  CHAR-ENCODING : GR[fBOw肵܂B
  EOL-CODE      : sR[hw肵܂B


save-buffers-kill-xyzzy
[       type]: Function
[  arguments]: save-buffers-kill-xyzzy &optional VERBOSE
[    package]: editor
[    seealso]: save-all-buffers-kill-xyzzy , kill-xyzzy , save-some-buffers
[       file]: files.l
[    section]: t@CVXe
[description]: 
JĂobt@ۑ xyzzy I܂B
save-some-buffers  kill-xyzzy ̑gݍ킹łB

  VERBOSE : non-nil ̏ꍇۑt@CƂɃ_CAO\ĊmF܂B


save-excursion
[       type]: Special Form
[  arguments]: save-excursion {FORM}*
[    package]: editor
[    seealso]: save-window-excursion , save-restriction , set-goal-column
[       file]: builtin.l
[    section]: |WV
[description]: 
̑OŃJgobt@ƃ|Cgۑ܂BEBhẼCAE
g͕ۑȂ̂ŒӂĂB

EBhẼCAEgۑꍇɂ́Asave-window-excursiong܂B


save-restriction
[       type]: Special Form
[  arguments]: save-restriction {FORM}*
[    package]: editor
[    seealso]: narrow-to-region , save-excursion
[       file]: builtin.l
[    section]: |WV
[description]: 
narrow-to-regionȌԂۑ܂B|Cgobt@̈ʒu͕ۑ
܂B|Cgobt@̈ʒuۑꍇɂ́Asave-excursion
gp܂B

̏̑Orestriction̏Ԃƃ|Cg̗ۑꍇɂ́A
ȉ̗lɂ܂B

  ;;; ܂
  (save-excursion (save-restriction ... )) 

ȉ̗lɏĂ܂ꍇA̒restriction|Ɠ
save-excursionł̃|Cg̕܂ȂƂ܂Bӂ
傤B

  ;;; ܂ȂƂ鏑
  (save-restriction (save-excursion ... ))

gpF
    ;;; ̎_ł narrow-to-region ĂȂƂB
    (save-restriction
      (narrow-to-region FROM-1 TO-1)             ; FROM-1TO-1ɐ
      (save-restriction
        (narrow-to-region FROM-2 TO-2)           ; FROM-2TO-2ɐ
        (msgbox "~A ~A" (point-min) (point-max))
      )                                          ; FROM-1TO-1ɐĂ
                                                 ; Ԃɖ߂
      (msgbox "~A ~A" (point-min) (point-max))
    )                                            ; ȂȂ
    (msgbox "~A ~A" (point-min) (point-max))


save-session
[       type]: Function
[  arguments]: save-session FILENAME &optional NOWARN
[    package]: editor
[    seealso]: load-session
[   referred]: *buffer-info-variable-list* , *default-session-directory* , save-session-dialog
[       file]: session.l
[    section]: obt@
[description]: 
݂̃obt@Ɗet[̃EBhȄԂZbVt@Cɕۑ
܂B file-visited łȂobt@ save-p  nil ȃt[
͕ۑ܂B [C-x 6 s]

ۑԂ load-session ŕ邱Ƃł܂B

  NOWARN : w肳ꂽt@Cłɑ݂Ƃ̓
        non-nil   قď㏑
        nil       bZ[W{bNX\ĊmF


save-session-dialog
[       type]: Function
[  arguments]: save-session-dialog
[    package]: editor
[    seealso]: save-session
[       file]: session.l
[    section]: obt@
[description]: 
_CAOZbVt@Cw肵ăZbVۑ܂B
[C-x 6 S]


save-some-buffers
[       type]: Function
[  arguments]: save-some-buffers &optional VERBOSE (FN #'WRITE-FILE)
[    package]: editor
[    seealso]: save-all-buffers , save-buffers-kill-xyzzy , save-buffer
[   referred]: save-all-buffers-kill-xyzzy
[       file]: files.l
[    section]: t@CVXe
[description]: 
JĂobt@ۑ܂B[C-x s]
  VERBOSE : non-nil̏ꍇۑt@CƂɃ_CAO\ĊmF܂B


save-window-configuration-to-register
[       type]: Function
[  arguments]: save-window-configuration-to-register R
[    package]: editor
[    seealso]: restore-window-configuration-register , current-window-configuration
[       file]: register.l
[    section]: EBhE
[description]: 
WX^ R Ɍ݂̃EBhȄԂۑ܂B[C-x r w]
g current-window-configuration œ̂ƓłB
ۑԂɖ߂ɂ restore-window-configuration-register g܂B


save-window-excursion
[       type]: Special Form
[  arguments]: save-window-excursion {FORM}*
[    package]: editor
[    seealso]: save-excursion , with-selected-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
̑OŃJgEBhEƃEBhẼCAEg̏Ԃۑ܂B


scan-buffer
[       type]: Function
[  arguments]: scan-buffer PATTERN &key :no-dup :case-fold :reverse :tail :regexp :limit :left-bound :right-bound :last-match
[    package]: editor
[    seealso]: match-beginning , match-end , perform-replace , make-marker , skip-chars-forward , K\̕\L
[   referred]: :case-fold , :no-dup , :regexp , :reverse , :right-bound , :tail , looking-at , match-data , match-string , store-match-data
[       file]: builtin.l
[    section]: EK\
[description]: 
obt@܂B

  PATTERN      : p^[ƂāA[]A[K\]A[RpC
                 ݐK\]̉ꂩw肷B
                 RpCςݐK\̏ꍇ :regexp ̒l͖B
                 ܂ :case-fold wAcompile-regexp ̑2
                 ̎w肪pB

  :no-dup      : ɑ΂Ď̃|Cǧw肷B
        nil     - ݂̃|Cg猟B
        non-nil - reverse  nil ̏ꍇ́Ã|Cg猟B
                  non-nil ̏ꍇ́AÕ|Cg猟B

  :case-fold   : ASCII ̑啶̋ʂ̕@w肷B
                 PATTERN [RpCςݐK\]̏ꍇ́A:case-fold
                 w͈ӖȂB
        nil     - 啶ʂČB
        :smart  - PATTERN ɑ啶܂܂ĂȂꍇA啶
                  ʂɌB
        LȊO- 啶ʂɌB

  :reverse     : w肷B
        nil     - obt@̖ɌČB
        non-nil - obt@̐擪ɌČB

  :tail        : ̈ړ|Cgǂɂ邩w肷B
        nil     - A}b`͈͂̐擪((match-beginning 0)̃|C
                  g)ɈړB
                  bar ꍇA:tail  nil Ȃ
                      foo bar baz qux quux ...
                          ^ |Cg͂ɈړB
        non-nil - A}b`͈̖͂((match-end 0)̃|Cg)
                  ɈړB
                  bar ꍇA:tail  non-nil Ȃ
                     foo bar baz qux quux ...
                            ^ |Cg͂ɈړB

  :regexp      : PATTERN  [K\] ł邱Ƃw肷B
                 PATTERN [RpCςݐK\]̏ꍇ́A:regexp w
                 ͈ӖȂB
        nil     - PATTERN []Ƃ݂ȂB
        non-nil - PATTERN [K\]Ƃ݂ȂB

  :limit       : ͈͂|CgʒuŐB 
                 ł͂ȂB
        nil     - ȂB
        INTEGER - :reverse  nil ̏ꍇ́A}b`̃|Cg
                  INTEGER ƂȂ͈͂ŌBnon-nil ̏ꍇ́A
                  }b`擪̃|Cg INTEGER ȏƂȂ͈͂Ō
                  B
        MARKER  - MARKER ɐݒ肳ꂽ|CgL INTEGER ƌȂ
                  ͈͂𐧌B
                  MARKER Ƀ|Cgݒ肳ĂȂ((marker-point
                   MARKER)  nil)ꍇAscan-buffer  nil ԂB
        LȊO- type-error B

  :left-bound  : []̍E}b`w肷B
                 K\̏ꍇ͖B
        nil     - EɊւ炸}b`
        :symbol - }b`͈͍E((match-beginning 0)̃|Cg)A
                  ȉ̉ꂩ̏𖞂΃}b`
                    - obt@̐擪ł
                    - obt@̖ł
                  }b`͈͍Ẽ|CgÁȂÕ|C
                  g̕Aȉ̉ꂩ̏𖞂΃}b`
                    - ASCII łȂ
                    - syntax-table  word,symbol Ƃēo^ĂȂ
                      ((syntax-word-p ), (syntax-symbol-p ) 
                       nil ԂB)
        LȊO- }b`͈͍E((match-beginning 0)̃|Cg)A
                  ȉ̉ꂩ̏𖞂΃}b`
                    - obt@̐擪ł
                    - obt@̖ł
                  }b`͈͍Ẽ|CgÁȂÕ|C
                  g̕Aȉ̉ꂩ̏𖞂΃}b`
                    - ASCII łȂ
                    - syntax-table  word Ƃēo^ĂȂ
                      ((syntax-word-p )nilԂB)

  :right-bound : []̉EE}b`w肷B
                 K\̏ꍇ͖B
        nil     - EEɊւ炸}b`
        :symbol - }b`͈͉EE((match-end 0)̃|Cg)Aȉ
                  ꂩ̏𖞂΃}b`
                    - obt@̐擪ł
                    - obt@̖ł
                  }b`͈͉EẼ|CgÁȂÕ|C
                  g̕Aȉ̉ꂩ̏𖞂΃}b`
                    - ASCII łȂ
                    - syntax-table  word,symbol Ƃēo^ĂȂ
                      ((syntax-word-p ), (syntax-symbol-p ) 
                       nil ԂB)
        LȊO- }b`͈͉EE((match-end 0)̃|Cg)Aȉ
                  ꂩ̏𖞂΃}b`
                    - obt@̐擪ł
                    - obt@̖ł
                  }b`͈͉EẼ|CgÁȂÕ|C
                  g̕Aȉ̉ꂩ̏𖞂΃}b`
                    - ASCII łȂ
                    - syntax-table  word Ƃēo^ĂȂ
                      ((syntax-word-p )  nil ԂB)

  :last-match  : gpʕs
                 (perform-replace) ł̂ݗpĂB
                 (<last-match> . <last-match-char>) ȂB
                 <last-match> : Oscan-buffer
                     (match-beginning 0)̃|Cgw
                 <last-match-char>: Oscan-buffer
                     (match-end 0)̑Õ|Cg̕w

߂l͈ȉ̂ƂłB

  t    ɐ
  nil  Ɏs

gpF
  (scan-buffer  :regexp t)
  (scan-buffer  :tail t)
  (scan-buffer  :limit 3000)
  (scan-buffer  :reverse t)
  (scan-buffer  :regexp t :no-dup t)


schar
[       type]: Function
[  arguments]: schar SIMPLE-STRING INDEX
[    package]: lisp
[    seealso]: char , simple-string
[       file]: builtin.l
[    section]: 
[description]: 
SIMPLE-STRINGINDEXԖڂ̕Ԃ܂B
INDEX0Ƃ܂B

gpF
  ;;; simplełȂstringschargĂ݂B
  (setq foo (make-vector 10 :initial-element #\a :element-type 'character :fill-pointer 3))
                        => "aaa"
  (schar foo 0)         => sȃf[^^ł: "aaa": simple-string
  (setq bar "aaa")      => "aaa"
  (schar bar 0)         => #\a


screen-height
[       type]: Function
[  arguments]: screen-height
[    package]: editor
[    seealso]: screen-width , window-height
[       file]: builtin.l
[    section]: EBhE
[description]: 
xyzzỹEBhEŜ̍sɂȂ̂Ԃ܂B


screen-width
[       type]: Function
[  arguments]: screen-width
[    package]: editor
[    seealso]: screen-height , window-width
[       file]: builtin.l
[    section]: EBhE
[description]: 
xyzzỹEBhEŜ̕ɂȂ̂Ԃ܂B


scroll-down-both-window
[       type]: Function
[  arguments]: scroll-down-both-window
[    package]: editor
[    seealso]: scroll-up-both-window , scroll-down-other-window
[       file]: cmds.l
[    section]: EBhE
[description]: 
݂̃EBhEƁÃEBhE𓯎ɉXN[܂B[S-C-Up]


scroll-down-other-window
[       type]: Function
[  arguments]: scroll-down-other-window &optional (ARG 1)
[    package]: editor
[    seealso]: scroll-window , scroll-down-both-window
[   referred]: scroll-other-window
[       file]: cmds.l
[    section]: EBhE
[description]: 
̃EBhEwsXN[܂B


scroll-left
[       type]: Function
[  arguments]: scroll-left &optional ARG
[    package]: editor
[    seealso]: scroll-right , scroll-window-horizontally , scroll-window
[       file]: cmds.l
[    section]: EBhE
[description]: 
EBhEw茅AɃXN[܂B[C-x <]
̐lw肷ƋtɃXN[܂B


scroll-other-window
[       type]: Function
[  arguments]: scroll-other-window &optional ARG
[    package]: editor
[    seealso]: scroll-window , scroll-up-other-window , scroll-down-other-window
[       file]: cmds.l
[    section]: EBhE
[description]: 
̃EBhEXN[܂B[ESC C-v]
ARG  nil Ȃ牺XN[A non-nil łΏXN[܂B


scroll-right
[       type]: Function
[  arguments]: scroll-right &optional ARG
[    package]: editor
[    seealso]: scroll-left , scroll-window-horizontally , scroll-window
[       file]: cmds.l
[    section]: EBhE
[description]: 
EBhEw茅AEɃXN[܂B[C-x >]
̐lw肷ƋtɃXN[܂B


scroll-up-both-window
[       type]: Function
[  arguments]: scroll-up-both-window
[    package]: editor
[    seealso]: scroll-down-both-window , scroll-up-other-window
[       file]: cmds.l
[    section]: EBhE
[description]: 
݂̃EBhEƁÃEBhE𓯎ɏXN[܂B[S-C-Down]


scroll-up-other-window
[       type]: Function
[  arguments]: scroll-up-other-window &optional (ARG 1)
[    package]: editor
[    seealso]: scroll-window , scroll-up-both-window , scroll-other-window
[       file]: cmds.l
[    section]: EBhE
[description]: 
̃EBhEwsXN[܂B


scroll-window
[       type]: Function
[  arguments]: scroll-window ARG
[    package]: editor
[    seealso]: scroll-other-window , scroll-window-horizontally
[   referred]: fast-scroll-down , fast-scroll-up , scroll-down-other-window , scroll-left , scroll-right , scroll-up-other-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhEwsXN[܂B
̐lw肷ƋtɃXN[܂B

gpF
  ;;; 0.3b1sXN[B
  (dotimes (i 4) (scroll-window 1) (sit-for .3))
  => nil


scroll-window-horizontally
[       type]: Function
[  arguments]: scroll-window-horizontally ARG
[    package]: editor
[    seealso]: scroll-window
[   referred]: scroll-left , scroll-right
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhEw茅AEɃXN[܂B
̐lw肷ƋtɃXN[܂B


search-backward
[       type]: Function
[  arguments]: search-backward PATTERN &optional NOERROR
[    package]: editor
[    seealso]: search-forward
[       file]: search.l
[    section]: EK\
[description]: 
܂B[C-r]

  PATTERN: 
  NOERROR: 񂪌ȂƂ̓w肵܂B
        t   nil Ԃ܂B
        nil G[bZ[Wo͂܂B


search-backward-again
[       type]: Function
[  arguments]: search-backward-again
[    package]: editor
[    seealso]: ed::*last-search-string* , search-forward-again
[       file]: search.l
[    section]: EK\
[description]: 
ǑŌ܂B


search-forward
[       type]: Function
[  arguments]: search-forward PATTERN &optional NOERROR
[    package]: editor
[    seealso]: search-backward
[       file]: search.l
[    section]: EK\
[description]: 
O܂B[C-s]

  PATTERN: 
  NOERROR: 񂪌ȂƂ̓w肵܂B
        t   nil Ԃ܂B
        nil G[bZ[Wo͂܂B


search-forward-again
[       type]: Function
[  arguments]: search-forward-again
[    package]: editor
[    seealso]: ed::*last-search-string* , search-backward-again , *wrap-search*
[   referred]: repeat-backward-search , repeat-forward-search
[       file]: search.l
[    section]: EK\
[description]: 
ǑőO܂B


second
[       type]: Function
[  arguments]: second X
[    package]: lisp
[    seealso]: first , cadr , nth
[       file]: list.l
[    section]: Xg
[description]: 
cadr̕ʖłB
S܂B

gpF
  ;;; cadrƓB
  (cadr '(1 2 3))
  => 2
  (second '(1 2 3))
  => 2
  (symbol-function 'cadr)
  => #<lexical-closure: cadr>
  (symbol-function 'second)
  => #<lexical-closure: cadr>
 
QlF
  ;;; list.l̒`
  (si:*fset 'second #'cadr)


select-buffer
[       type]: Function
[  arguments]: select-buffer
[    package]: editor
[    seealso]: buffer-menu
[   referred]: buffer-selector
[       file]: buffer.l
[    section]: obt@
[description]: 
obt@I_CAO\܂B [F2]
ftHgłC-p/C-nŏ㉺AC-mőI܂B
buffer-menû悤ȃobt@̍폜Ȃǂ͂ł܂B
mɂ*std-control-xxx-char*̐ݒɈ˂܂B


select-pseudo-frame
[       type]: Function
[  arguments]: select-pseudo-frame FRAME
[    package]: editor
[    seealso]: switch-pseudo-frame , pseudo-frame-selector , find-pseudo-frame , new-pseudo-frame , *select-pseudo-frame-hook*
[   referred]: ed::pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
t[ FRAME I܂B

FRAME ̃Xbg selected-fn Ɋ֐ݒ肳ĂꍇA funcall ܂B
Ō *select-pseudo-frame-hook* s܂B


selected-buffer
[       type]: Function
[  arguments]: selected-buffer
[    package]: editor
[       file]: builtin.l
[    section]: obt@
[description]: 
ݑ쒆̃obt@iJgobt@jԂ܂B

gpF
  (selected-buffer)
  => #<buffer: reference.xml>

݊F
  ̊֐muleɂ͂܂B
  mulełcurrent-bufferɑ܂B


selected-pseudo-frame
[       type]: Function
[  arguments]: selected-pseudo-frame
[    package]: editor
[    seealso]: find-pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
ݑIĂt[Ԃ܂B


selected-window
[       type]: Function
[  arguments]: selected-window
[    package]: editor
[    seealso]: set-window
[   referred]: other-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
݃ANeBuȃEBhEԂ܂B

gpF
  ;;; ݂̃EBhEԂĂ݂B
  (selected-window)
  => #<window 54137832>


selection-backward-char
[       type]: Function
[  arguments]: selection-backward-char &optional (ARG 1)
[    package]: editor
[       file]: select.l
[    section]: [W
[description]: 
̕܂łZNVɂ܂B[S-Left]


selection-backward-word
[       type]: Function
[  arguments]: selection-backward-word &optional (ARG 1)
[    package]: editor
[    seealso]: selection-forward-word
[       file]: select.l
[    section]: [W
[description]: 
̒P܂łZNVɂ܂B[S-C-Left]


selection-beginning-of-buffer
[       type]: Function
[  arguments]: selection-beginning-of-buffer
[    package]: editor
[    seealso]: beginning-of-buffer , selection-end-of-buffer
[       file]: select.l
[    section]: [W
[description]: 
J[\ʒuobt@̐擪܂łZNVɂ܂B
beginning-of-bufferƈႢ}[N͕̂ω܂B


selection-beginning-of-line
[       type]: Function
[  arguments]: selection-beginning-of-line
[    package]: editor
[    seealso]: beginning-of-line , selection-end-of-line
[       file]: select.l
[    section]: [W
[description]: 
s܂łZNVɂ܂B


selection-beginning-of-virtual-line
[       type]: Function
[  arguments]: selection-beginning-of-virtual-line
[    package]: editor
[    seealso]: beginning-of-virtual-line , selection-end-of-virtual-line
[       file]: select.l
[    section]: [W
[description]: 
\s̐擪܂łZNVɂ܂B


selection-end-of-buffer
[       type]: Function
[  arguments]: selection-end-of-buffer
[    package]: editor
[    seealso]: end-of-buffer , selection-beginning-of-buffer
[       file]: select.l
[    section]: [W
[description]: 
obt@̍Ō܂łZNVɂ܂B
end-of-bufferƈႢ}[N͕̂ω܂B


selection-end-of-line
[       type]: Function
[  arguments]: selection-end-of-line
[    package]: editor
[    seealso]: selection-beginning-of-line , end-of-line
[       file]: select.l
[    section]: [W
[description]: 
s܂łZNVɂ܂B


selection-end-of-virtual-line
[       type]: Function
[  arguments]: selection-end-of-virtual-line
[    package]: editor
[    seealso]: end-of-virtual-line , selection-beginning-of-virtual-line
[       file]: select.l
[    section]: [W
[description]: 
\s̖܂łZNVɂ܂B


selection-forward-char
[       type]: Function
[  arguments]: selection-forward-char &optional (ARG 1)
[    package]: editor
[       file]: select.l
[    section]: [W
[description]: 
O̕܂łZNVɂ܂B[S-Right]


selection-forward-word
[       type]: Function
[  arguments]: selection-forward-word &optional (ARG 1)
[    package]: editor
[    seealso]: selection-backward-word
[       file]: select.l
[    section]: [W
[description]: 
O̒P܂łZNVɂ܂B[S-C-Right]


selection-mark
[       type]: Function
[  arguments]: selection-mark
[    package]: editor
[    seealso]: selection-point , region-beginning
[   referred]: pre-selection-p
[       file]: builtin.l
[    section]: |WV
[description]: 
ZNV̊Jñ|CgԂ܂B


selection-next-page
[       type]: Function
[  arguments]: selection-next-page &optional (ARG 1)
[    package]: editor
[    seealso]: selection-previous-page
[       file]: select.l
[    section]: [W
[description]: 
y[W܂łZNVɂ܂B[S-PageDown]


selection-next-virtual-line
[       type]: Function
[  arguments]: selection-next-virtual-line &optional (ARG 1)
[    package]: editor
[       file]: select.l
[    section]: [W
[description]: 
̕\s܂łZNVɂ܂B[S-Down]


selection-paragraph
[       type]: Function
[  arguments]: selection-paragraph
[    package]: editor
[       file]: paragrph.l
[    section]: [W
[description]: 
iZNVɂ܂B


selection-point
[       type]: Function
[  arguments]: selection-point
[    package]: editor
[    seealso]: selection-mark , region-end
[   referred]: pre-selection-p
[       file]: builtin.l
[    section]: |WV
[description]: 
ZNV̏I[̃|CgԂ܂B


selection-previous-page
[       type]: Function
[  arguments]: selection-previous-page &optional (ARG 1)
[    package]: editor
[    seealso]: selection-next-page
[       file]: select.l
[    section]: [W
[description]: 
Oy[W܂łZNVɂ܂B[S-PageUp]


selection-previous-virtual-line
[       type]: Function
[  arguments]: selection-previous-virtual-line &optional (ARG 1)
[    package]: editor
[       file]: select.l
[    section]: [W
[description]: 
O̕\s܂łZNVɂ܂B[S-Up]


selection-start-end
[       type]: Macro
[  arguments]: selection-start-end (START END) &body BODY
[    package]: editor
[    seealso]: ed::get-selection-start-end
[       file]: select.l
[    section]: [W
[description]: 
ZNV̊JnʒuAIʒu擾܂B
ZNV݂΁A
ǏISTARTɊJnʒuAENDɏIʒuZbgꂽ
BODY]܂B

gp:
  ;;; ZNVɊ܂܂镶Ԃ܂B
  (selection-start-end (start end)
    (buffer-substring start end))
  =>"foo"


selection-whole-buffer
[       type]: Function
[  arguments]: selection-whole-buffer
[    package]: editor
[       file]: select.l
[    section]: [W
[description]: 
obt@ŜZNVɂ܂B


self-insert-command
[       type]: Function
[  arguments]: self-insert-command &optional (ARG 1)
[    package]: editor
[    seealso]: *auto-fill-hook
[       file]: cmds.l
[    section]: eLXg
[description]: 
Ōɓ͂ꂽL[ *last-command-char* }[h̔@ɂ
insert / overwrite-char ܂B
ʂ͂ꂽɋ\Ȃ̂̒ł̍płB


sequencep
[       type]: Function
[  arguments]: sequencep OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECT  sequence Ȃ t AłȂnilԂ܂B


set
[       type]: Function
[  arguments]: set SYMBOL VALUE
[    package]: lisp
[    seealso]: setq , symbol-value , makunbound
[   referred]: set-default
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
V{̒lݒ肵܂B
setq ƈċǏϐɂ͉e^܂B

  SYMBOL : V{
  VALUE  : ݒ肷l

gpF
  ;;; foo ƂV{𑩔Ă݂
  (boundp 'foo)         => nil
  (set 'foo 2)          => 2
  (boundp 'foo)         => t
  foo                   => 2
  ;;; Ǐϐɂ͉eȂ
  (let ((foo 1))
    (set 'foo 2) foo)   => 1


set-buffer
[       type]: Function
[  arguments]: set-buffer BUFFER
[    package]: editor
[    seealso]: switch-to-buffer , with-set-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@I܂B


set-buffer-alternate-file-name
[       type]: Function
[  arguments]: set-buffer-alternate-file-name NAME &optional BUFFER
[    package]: editor
[    seealso]: get-buffer-alternate-file-name , set-buffer-file-name
[   referred]: get-alternate-file-buffer
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@BUFFERɃt@C̕ʖNAME܂Bset-buffer-file-nameł́A
肦ȂpXw肷ƃG[ɂȂ܂B
set-buffer-alternate-file-nameł͂ǂ̂悤ȕłw\łB

gpF
  ; c:/abc/݂͑ȂpX
  (set-buffer-file-name "c:/abc/def.txt")
  => c:/abc/def.txt
     w肳ꂽpX܂B 

  ; URLłȂłCӂ̕ݒ
  (set-buffer-alternate-file-name "http://www.asahi.com")
  => t

w肵́Aobt@̃t@Cnil̏ꍇi܂A
get-buffer-file-name̖߂lnil̏ꍇjɌA
ȉ̌Ŏgp܂

  1)select-bufferŕ\_CAÕt@C
  2)mode-line-format/title-bar-format̃t@C


set-buffer-colors
[       type]: Function
[  arguments]: set-buffer-colors COLORS &optional BUFFER
[    package]: editor
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̐Fݒ肵܂Bݒ肵F͌̃obt@ɂKp܂B

  COLORS : BGR\lxN^Ŏw肵܂B


set-buffer-eol-code
[       type]: Function
[  arguments]: set-buffer-eol-code CODE &optional BUFFER
[    package]: editor
[    seealso]: *eol-lf* , *eol-crlf* , *eol-cr* , set-buffer-fileio-encoding
[   referred]: buffer-eol-code
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̉sR[hݒ肵܂B
ƂĉsR[h̎ނ\萔pӂĂ܂B
̂́Aset-buffer-newline-codeƂ̂łAxyzzy 0.2.0.121 炱
̖OɕύX܂B

  CODEFobt@̉sR[h̎ނw肵܂B
        LF̏ꍇ        *eol-lf*        0
        CRLF̏ꍇ      *eol-crlf*      1
        CȐꍇ        *eol-cr*        2

gpF
  ;;; obt@̉sR[hLFɕύXB
  (set-buffer-eol-code *eol-lf*)
  => t

QlF
  Changelogxyzzy 0.2.0.121QƂ̂


set-buffer-file-name
[       type]: Function
[  arguments]: set-buffer-file-name FILE-NAME &optional BUFFER
[    package]: editor
[    seealso]: get-buffer-file-name , rename , set-buffer-alternate-file-name
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@ƌѕtĂt@CFILE-NAMEɂ܂B


set-buffer-fileio-encoding
[       type]: Function
[  arguments]: set-buffer-fileio-encoding CODE &optional BUFFER
[    package]: editor
[    seealso]: buffer-fileio-encoding , *char-encoding-list* , set-buffer-eol-code
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@̕GR[fBOCODEɂ܂Bݒ肵GR[fBO
buffer-fileio-encodingŎQƂ邱Ƃł܂B

  CODE   : GR[fBOw肵܂B
  BUFFER : ύXobt@w肵܂B

gpF
  (set-buffer-fileio-encoding *encoding-sjis*)
  (set-buffer-fileio-encoding *encoding-euc-jp*)
  (set-buffer-fileio-encoding *encoding-jis*)
  (set-buffer-fileio-encoding *encoding-utf8*)

QƁF
  kanji.l


set-buffer-fold-type-column
[       type]: Function
[  arguments]: set-buffer-fold-type-column
[    package]: editor
[    seealso]: set-buffer-fold-type-window , set-buffer-fold-type-none
[   referred]: set-buffer-fold-type-column-update
[       file]: window.l
[    section]: obt@
[description]: 
Jgobt@wʒuŐ܂Ԃ܂B


set-buffer-fold-type-column-update
[       type]: Function
[  arguments]: set-buffer-fold-type-column-update
[    package]: editor
[    seealso]: set-buffer-fold-type-column
[       file]: window.l
[    section]: obt@
[description]: 
Jgobt@wʒuŐ܂ԂɂȂĂ邩ǂԂ܂B

߂l͈ȉ̂ƂłB
  :check  ȂĂ
  nil     ȂĂȂ


set-buffer-fold-type-none
[       type]: Function
[  arguments]: set-buffer-fold-type-none
[    package]: editor
[    seealso]: set-buffer-fold-type-window , set-buffer-fold-type-column
[   referred]: set-buffer-fold-type-none-update
[       file]: window.l
[    section]: obt@
[description]: 
Jgobt@܂ԂȂɂ܂B


set-buffer-fold-type-none-update
[       type]: Function
[  arguments]: set-buffer-fold-type-none-update
[    package]: editor
[    seealso]: set-buffer-fold-type-none
[       file]: window.l
[    section]: obt@
[description]: 
Jgobt@܂ԂɂȂĂ邩ǂԂ܂B

߂l͈ȉ̂ƂłB
  :check  ȂĂ
  nil     ȂĂȂ


set-buffer-fold-type-window
[       type]: Function
[  arguments]: set-buffer-fold-type-window
[    package]: editor
[    seealso]: set-buffer-fold-type-none , set-buffer-fold-type-column
[   referred]: set-buffer-fold-type-window-update
[       file]: window.l
[    section]: obt@
[description]: 
Jgobt@EBhEŐ܂Ԃ܂B


set-buffer-fold-type-window-update
[       type]: Function
[  arguments]: set-buffer-fold-type-window-update
[    package]: editor
[    seealso]: set-buffer-fold-type-window
[       file]: window.l
[    section]: obt@
[description]: 
Jgobt@EBhEŐ܂ԂɂȂĂ邩ǂԂ܂B

߂l͈ȉ̂ƂłB
  :check  ȂĂ
  nil     ȂĂȂ


set-buffer-fold-width
[       type]: Function
[  arguments]: set-buffer-fold-width WIDTH &optional BUFFER
[    package]: editor
[    seealso]: buffer-fold-width
[       file]: builtin.l
[    section]: eLXg
[description]: 
eLXg̐܂Ԃ@𐧌䂵܂B[c[]-[[Jݒ]-[\]"e
LXg̐܂Ԃ"ƓŁÃ݂obt@ɉe܂B

  WIDTH  : ܂Ԃ̕@w肵܂B
        nil     ܂Ԃ܂B
        t       EBhE̕Ő܂Ԃ܂B
        l    ܂Ԃʒuw肵܂B
  BUFFER : [Jݒ肷obt@w肵܂B


set-buffer-modified-p
[       type]: Function
[  arguments]: set-buffer-modified-p FLAG &optional BUFFER
[    package]: editor
[    seealso]: buffer-modified-p , not-modified
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@ύXꂽǂ̃tOݒ肵܂B

  FLAG   : tOw肵܂B
        t       ύXĂԂɂ܂B
        nil     ύX݂ȂԂɂ܂B
  BUFFER : Ώۂ̃obt@

gpF 
  ;;; ύXtO̐ݒENA
  (set-buffer-modified-p t)
  (set-buffer-modified-p nil)


set-default
[       type]: Function
[  arguments]: set-default SYMBOL VALUE
[    package]: lisp
[    seealso]: setq-default , set
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
̊֐́A 1 symbol  1  value ݂̂_ƁA̗
]_Ƃ setq-default Ɠł (setq-default Q)B

gpF
  (set-default (car '(a b c)) 23)
  => 23


set-default-directory
[       type]: Function
[  arguments]: set-default-directory DIRECTORY &optional BUFFER
[    package]: editor
[    seealso]: default-directory
[   referred]: cd
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
obt@ƂĂfBNgύX܂B

  DIRECTORY : fBNgw肵܂B
  BUFFER    : obt@w肵܂B
              w肪Ȃ΃Jgobt@ɂȂ܂B


set-default-fold-width
[       type]: Function
[  arguments]: set-default-fold-width WIDTH
[    package]: editor
[       file]: builtin.l
[    section]: EBhE
[description]: 
eLXg̐܂Ԃ@𐧌䂵܂B[c[]-[ʐݒ]-[\]"eLX
g̐܂Ԃ"ƓŁAŜɉe܂B

  WIDTH : ܂Ԃ̕@w肵܂B
        nil     ܂Ԃ܂B
        t       EBhE̕Ő܂Ԃ܂B
        l    ܂Ԃʒuw肵܂B


set-difference
[       type]: Function
[  arguments]: set-difference LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: nset-difference , union , intersection , set-exclusive-or , ldiff , subsetp
[       file]: list.l
[    section]: Xg
[description]: 
̃Xg̍Ԃ܂B
nset-difference ƈႢ LIST1 ͕ۑ܂B

gpF
  (set-difference  '(3 6 9) '(2 4 6 8 10))
  => (9 3)


set-dispatch-macro-character
[       type]: Function
[  arguments]: set-dispatch-macro-character DISP-CHAR SUB-CHAR FUNCTION &optional READTABLE
[    package]: lisp
[    seealso]: make-dispatch-macro-character , get-dispatch-macro-character
[       file]: builtin.l
[    section]: o
[description]: 
fBXpb`}Nݒ肵܂B
SUB-CHAR ͑啶ʂ܂B

DISP-CHAR fBXpb`}NłȂ΃G[ƂȂ܂B
܂ SUB-CHAR  [0-9] ͎wł܂B


set-exclusive-or
[       type]: Function
[  arguments]: set-exclusive-or LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: nset-exclusive-or , intersection , union , set-difference , ldiff , subsetp
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 ̂ꂩɂ̂݊܂܂vf̃XgĕԂ܂B
nset-exclusive-or ƈႢ LIST2 ͕ۑ܂B

gp:
  (set-exclusive-or '(1 3 5 7 9) '(2 3 5 7 11))
  => (9 1 11 2)


set-extended-key-translate-table
[       type]: Function
[  arguments]: set-extended-key-translate-table KEY C
[    package]: editor
[       file]: keyboard.l
[    section]: L[}bv
[description]: 
ʏ͓łȂL[ʂ̃L[ɐUe[ułB

| c-modeŃVtgȂTAB
| CfgĂ炨ƎvłA
| #\TAB#\S-TABɂSHIFT͎g܂Ƃ̂ƂŁB

cOȂ܂ƂȎił Shift+Tab ͎g܂BA܂ƂłȂ
ipӂĂ܂B

  (set-extended-key-translate-table exkey-S-tab #\F20)

̂悤ɂĂƁAShift+Tab ꂽƂ F20 ꂽӂ̂

  (global-set-key #\F20 'foo)

Ƃ΂]ݒʂ(^^

exkey-... Ɏwł͈̂ȉ̒ʂB

  exkey-space
  exkey-S-space
  exkey-C-space
  exkey-S-C-space
  exkey-M-space
  exkey-S-M-space
  exkey-C-M-space
  exkey-S-C-M-space
                   
  exkey-backspace
  exkey-S-backspace
  exkey-C-backspace
  exkey-S-C-backspace
  exkey-M-backspace
  exkey-S-M-backspace
  exkey-C-M-backspace
  exkey-S-C-M-backspace
  
  exkey-tab
  exkey-S-tab
  exkey-C-tab
  exkey-S-C-tab
  
  exkey-return
  exkey-S-return
  exkey-C-return
  exkey-S-C-return
  exkey-M-return
  exkey-S-M-return
  exkey-C-M-return
  exkey-S-C-M-return
  
  exkey-escape
  exkey-S-escape

  exkey-zenkaku
  exkey-S-zenkaku
  exkey-C-zenkaku
  exkey-S-C-zenkaku
  exkey-S-M-zenkaku


set-file-write-time
[       type]: Function
[  arguments]: set-file-write-time FILENAME UNIVERSAL-TIME
[    package]: lisp
[    seealso]: file-write-time , decode-universal-time , format-date-string
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
t@C̍ŏIXVύX܂B

  FILENAME       : t@Cw肵܂BtpXłȂ
                   (default-directory)̑΃pXɂȂ܂B
  UNIVERSAL-TIME : ŏIXVjo[T^C`Ŏw肵܂B


set-fill-column
[       type]: Function
[  arguments]: set-fill-column &optional (COL (CURRENT-COLUMN))
[    package]: editor
[    seealso]: fill-column
[       file]: fill.l
[    section]: |WV
[description]: 
lߍ݌w肵܂B[C-x f]
w肳ꂽĺAϐ fill-column ɑ܂B

  COL : lߍ݌
        Ȃꍇ́Ã݂J[\ʒǔlߍ݌ɐݒ肵
        ܂B


set-fill-prefix
[       type]: Function
[  arguments]: set-fill-prefix
[    package]: editor
[    seealso]: fill-prefix , auto-fill-mode
[       file]: fill.l
[    section]: ̑
[description]: 
s|Cg܂łfill prefixɐݒ肵܂B [C-x .]
sŎsꂽꍇɂ́Afill prefix̓NA܂Bauto-fill-mode
ł́A܂ԂsȂƍsfill prefix}܂B


set-function-bar-label
[       type]: Function
[  arguments]: set-function-bar-label CHAR LABEL
[    package]: editor
[    seealso]: set-number-of-function-bar-labels
[       file]: builtin.l
[    section]: L[}bv
[description]: 
t@NVo[̃xύX܂B

  CHAR  : et@Nt@NVo[ɑΉLN^
  LABEL : \郉x

gp
  (global-set-key #\F3 'search-forward-again)
  => t
  (set-function-bar-label #\F3 "")
  => t


set-goal-column
[       type]: Function
[  arguments]: set-goal-column COLUMN
[    package]: editor
[    seealso]: goal-column
[   referred]: save-excursion
[       file]: builtin.l
[    section]: |WV
[description]: 
S[Jݒ肵܂Bsave-excursionĂgoal-columnj󂳂Ȃ
悤Ɏgp邮炢ł傤B

gpF
  ;;; goal-column厖ɂĕҏWĂ݂B
  (let ((g (goal-column)))
    (save-excursion ... )
    (set-goal-column g))
  => t  


set-kinsoku-chars
[       type]: Function
[  arguments]: set-kinsoku-chars BOL-CHARS EOL-CHARS &optional BUFFER
[    package]: editor
[    seealso]: kinsoku-bol-chars , kinsoku-eol-chars
[   referred]: kinsoku-extend-limit , kinsoku-mode , kinsoku-shorten-limit
[       file]: builtin.l
[    section]: eLXg
[description]: 
֑Zbg܂B
[c[] - [ʐݒ] - [֑] łAݒł܂B

  BOL-CHARS: sɂĂ͂Ȃ̏WB
  EOL-CHARS: sɂĂ͂Ȃ̏WB
  BUFFER:    nil Ȃ΋ʐݒƂāAobt@w肳
             ̃obt@ɑ΂ă[JɐݒB


set-local-window-flags
[       type]: Function
[  arguments]: set-local-window-flags WINDOW-OR-BUFFER FLAGS ON-OR-OFF
[    package]: editor
[    seealso]: set-window-flags , get-local-window-flags
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE̓obt@̊e\𐧌䂵܂B
قڑSĂ̍ڂŁAEBhEłobt@łݒ\łB
obt@̐ݒ > EBhE̐ݒ > Ŝ̐ݒ
̏ԂŎw肪D悳܂B

 BUFFER-OR-WINDOW : obt@EBhÊꂩw肵܂B
 FLAGS            : ̃tÔǂꂩw肵܂B
        *window-flag-alternate-vscroll-bar* obt@S̕\łĂ
                                            ꍇ̐XN[o[
        *window-flag-cursor-line*           sJ[\
        *window-flag-eof*                   EOF
        *window-flag-fold-line*             ܂ԂC
        *window-flag-fold-mark*             ܂Ԃ
        *window-flag-full-width-space*      SpXy[X
        *window-flag-half-width-space*      pXy[X
        *window-flag-hscroll-bar*           XN[o[
        *window-flag-just-inverse*          iڍוsj
        *window-flag-line-number*           sԍ
        *window-flag-mode-line*             [hs
        *window-flag-newline*               s
        *window-flag-ruler*                 [
        *window-flag-scrolling*             `ʒǔvZŃWvXN[
        *window-flag-tab*                   ^u
        *window-flag-vscroll-bar*           XN[o[
        *window-flag-zenkaku-space*         SpXy[X
                                            (*window-flag-full-width-space*Ɠ)
 ON-OR-OFF       : ύX̒lݒ肵܂B
        t        tOonɂ܂B
        nil      tOoffɂ܂B
        ȊO ftHgɖ߂܂B

gpF
  ;;; Jgobt@̍sԍ\Ȃ悤ɂB
  (set-local-window-flags (selected-buffer)
                          *window-flag-line-number* nil)
  => t


set-macro-character
[       type]: Function
[  arguments]: set-macro-character CHAR FUNCTION &optional NON-TERMINATING-P READTABLE
[    package]: lisp
[    seealso]: get-macro-character
[       file]: builtin.l
[    section]: o
[description]: 
}Nݒ肵܂B

  CHAR                  }Nɂ镶
  FUNCTION              CHAR ǂ܂ꂽƂɌĂ΂֐
  NON-TERMINATING-P     g[N̓rɌꂽ CHAR }NƂ݂ȂȂ
  READTABLE             ݒ肷郊[he[u

gpF
  (set-macro-character #\? 'read-test)
  (defun read-test (stream ch)
    (list '*question* (read stream)))
  (read-from-string "?a")
  => (*question* a)
  => 2


set-mark
[       type]: Function
[  arguments]: set-mark &optional POINT
[    package]: editor
[    seealso]: mark , set-mark-command
[       file]: builtin.l
[    section]: |WV
[description]: 
|Cg̈ʒuɃ}[Nݒ肵܂B

  POINT: }[Nݒ肷ʒuw肵܂B
         ͈͊O̒lw肵ĂG[ɂ͂ȂȂ悤łB


set-mark-command
[       type]: Function
[  arguments]: set-mark-command
[    package]: editor
[    seealso]: set-mark , mark-word , mark-sexp , mark-defun
[   referred]: beginning-of-buffer , end-of-buffer
[       file]: cmds.l
[    section]: |WV
[description]: 
}[Nݒ肵܂B[ESC SPC], [C-@]
rgC֐ set-mark Θbɍs߂̂̂łB

gpF
  ;;; }[Nݒ肵Ă̈ʒu擾B
  (set-mark-command)
  => t
  (mark)
  => 2554


set-marker
[       type]: Function
[  arguments]: set-marker MARKER &optional POINT
[    package]: editor
[    seealso]: point-marker , unset-marker , make-marker , marker-point , goto-marker
[       file]: builtin.l
[    section]: |WV
[description]: 
}[J[Ƀ|WVݒ肵܂B
POINT  nil ̏ꍇ݂͌̈ʒuݒ肵܂B

  POINT : }[J[ɐݒ肷ʒu

gpF
  (setq m (make-marker))
  => #<marker: *scratch*: ->
  (set-marker m)
  => #<marker: *scratch*: 62>
  (marker-point m)
  => 62


set-menu
[       type]: Function
[  arguments]: set-menu MENU
[    package]: editor
[    seealso]: use-local-menu , define-menu
[   referred]: create-menu
[       file]: builtin.l
[    section]: j[
[description]: 
w肳ꂽj[ftHg̃j[ɂ܂Bxyzzy㕔ɏ펞\
悤ɂȂ܂B

  MENU : ݒ肷郁j[w肵܂B
         j[svȂnilw肵܂B


set-meta-bit
[       type]: Function
[  arguments]: set-meta-bit CHAR SET
[    package]: editor
[       file]: builtin.l
[    section]: 
[description]: 
CHAR  MetatA̕ɑݕϊ܂B

  SET: non-nil ̎ACHAR  Metat̕Ԃ܂B
       nil ̎A    CHAR  Meta̕Ԃ܂B

:
  (set-meta-bit #\S-C-Right t)
  =>#\S-C-M-Right
  
  (set-meta-bit #\M-S-C-Right nil)
  =>#\S-C-Right


set-minor-mode-map
[       type]: Function
[  arguments]: set-minor-mode-map KEYMAP &optional BUFFER
[    package]: editor
[    seealso]: unset-minor-mode-map , minor-mode-map
[       file]: builtin.l
[    section]: [h
[description]: 
}Ci[[hp̃L[}bvݒ肵܂B


set-number-of-function-bar-labels
[       type]: Function
[  arguments]: set-number-of-function-bar-labels N
[    package]: editor
[    seealso]: number-of-function-bar-labels
[   referred]: set-function-bar-label
[       file]: builtin.l
[    section]: ̑
[description]: 
t@NVo[̃x̐ݒ肵܂Bwł鐔́A
4/5/8/10/12/15łB
[ʐݒ] - [\] - [t@NVL[] ̂Ƃłlݒł܂B


set-per-device-directory
[       type]: Function
[  arguments]: set-per-device-directory DIRECTORY
[    package]: lisp
[    seealso]: *auto-update-per-device-directory*
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
hCũftHg̃fBNgݒ肵܂BhCũf
tHg̃fBNǵAt@CňړƖXV܂B
XVꂽȂꍇɂ́A*auto-update-per-device-directory*nil
ɐݒ肵܂B

gpF
  (set-per-device-directory "D:/foo/bar")
  (set-per-device-directory "E:/bar/foo")


set-process-eol-code
[       type]: Function
[  arguments]: set-process-eol-code PROCESS CODE
[    package]: editor
[    seealso]: process-eol-code
[       file]: builtin.l
[    section]: vZX
[description]: 
PROCESSŏꍇ̉sR[hCODEݒ肵܂B


set-process-filter
[       type]: Function
[  arguments]: set-process-filter PROCESS FILTER
[    package]: editor
[    seealso]: process-filter , set-process-outcode , set-process-incode , set-process-sentinel , process-send-string
[   referred]: make-process
[       file]: builtin.l
[    section]: vZX
[description]: 
vZX̏o͂H邽߂̃tB^w肵܂B
vZX̓͂set-process-filter֐ŃvZXƊ֌WÂꂽ
tB^֐Ă΂܂B
tB^̑̓vZXő͓͕łB
tB^̖߂l͎̂Ă悤łB

gp:
  ;;; vZXւ̏o͂~j}ł͂Ȃ
  (let ((buf (create-new-buffer "hoge")))
    (unwind-protect ;;Ö׊
        (progn
           (make-process *eshell* :output buf)
           (set-process-filter (buffer-process buf)
                               (lambda (prc str)
                                 (yes-or-no-p "proc ~S str ~S" prc str)))
           (process-send-string (buffer-process buf)
                                (concat "dir&exit" *shell-ret*))
           (sleep-for 0.9))
      (delete-buffer buf)))


set-process-incode
[       type]: Function
[  arguments]: set-process-incode PROCESS CODE
[    package]: editor
[    seealso]: set-process-outcode
[   referred]: process-incode , set-process-filter
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXset-process-filterɓ͂ꍇ̕GR[fBOw肵܂B


set-process-outcode
[       type]: Function
[  arguments]: set-process-outcode PROCESS CODE
[    package]: editor
[    seealso]: set-process-incode
[   referred]: process-outcode , set-process-filter
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXɑ΂send-process-stringꍇ̕GR[fBOw肵܂B


set-process-sentinel
[       type]: Function
[  arguments]: set-process-sentinel PROCESS SENTINEL
[    package]: editor
[    seealso]: process-sentinel , set-process-filter
[   referred]: make-process
[       file]: builtin.l
[    section]: vZX
[description]: 
vZXIꍇɌĂ΂֐iSENTINELjw肵܂B


set-syntax-comment-column
[       type]: Function
[  arguments]: set-syntax-comment-column SYNTAX-TABLE COLUMN
[    package]: editor
[    seealso]: set-syntax-option , set-syntax-start-column-comment , syntax-table , parse-point-syntax
[   referred]: set-syntax-start-c++-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
w肳ꂽ#\SPCȊÕLN^ꍇɃRgsƌ
܂B̃LN^ɂꍇɂ́A
set-syntax-option QƂĉB
  
gpF
  ;;; cobol-mode.l̒`
  (set-syntax-comment-column *cobol-mode-syntax-table* 6)


set-syntax-end-c++-comment
[       type]: Function
[  arguments]: set-syntax-end-c++-comment SYNTAX-TABLE CHAR &optional PARSE-SEXP-IGNORE-COMMENT-P
[    package]: editor
[    seealso]: set-syntax-start-c++-comment , syntax-end-c++-comment-p
[   referred]: parse-point-syntax
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARC++X^C̃Rg̏IƂċK肵܂B
JnƈقȂAI͓A˂܂B

gpF
  ;;; cc-mode.l
  (set-syntax-end-c++-comment *c++-mode-syntax-table* #\LFD)


set-syntax-end-comment
[       type]: Function
[  arguments]: set-syntax-end-comment SYNTAX-TABLE CHAR &optional PARSE-SEXP-IGNORE-COMMENT-P MAYBE-COMMENT-END-P
[    package]: editor
[    seealso]: set-syntax-start-comment , syntax-end-comment-p
[   referred]: parse-point-syntax
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARRgIƂċK肵܂B

gpF
  ;;; perl.l
  (set-syntax-end-comment *perl-mode-syntax-table* #\LFD)


set-syntax-end-multi-comment
[       type]: Function
[  arguments]: set-syntax-end-multi-comment SYNTAX-TABLE STRING
[    package]: editor
[    seealso]: set-syntax-start-multi-comment , syntax-start-multi-comment-1-p , syntax-start-multi-comment-2-p
[   referred]: parse-point-syntax , syntax-end-multi-comment-1-p , syntax-end-multi-comment-2-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
STRINGSYNTAX-TABLEɕs̃RgI\ƂċK肵܂B

gpF
  ;;; c-mode.l̒`
  (set-syntax-end-multi-comment *c-mode-syntax-table* "*/")


set-syntax-escape
[       type]: Function
[  arguments]: set-syntax-escape SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: set-syntax-string , syntax-escape-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARGXP[vƂċK肵܂B
񒆂Ɍ炸̈ꕶ̍\̋@\}܂B

gpF
  ;;; c-mode.l
  (set-syntax-escape *c-mode-syntax-table* #\\)


set-syntax-from-char
[       type]: Function
[  arguments]: set-syntax-from-char TO-CHAR FROM-CHAR &optional TO-READTABLE FROM-READTABLE
[    package]: lisp
[       file]: builtin.l
[    section]: }N
[description]: 
̃V^bNXύX܂B
lisp ̃[_̋ς܂B

  TO-CHAR        : V^bNXύX镶
  FROM-CHAR      : ݒ肷V^bNX
  TO-READTABLE   : ύX郊[he[u (w肵Ȃ *readtable*)
  FROM-READTABLE : ύX̃[he[u (w肵Ȃ΃ftHg̃[he[u)

gpF
  ;;; J} whitespace ƂĈ悤ɂĂ݂
  (let ((readtab (copy-readtable)))
    (set-syntax-from-char #\, #\SPC readtab *readtable*)
    (let ((*readtable* readtab))
      (read-from-string "(a,b,c)")))
  => (a b c)
  => 7


set-syntax-junk
[       type]: Function
[  arguments]: set-syntax-junk SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-junk-p , skip-syntax-spec-forward
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARS~ƂċK肵܂B
skip-syntax-spec-forward / skip-syntax-spec-backward ŃS~XLb
v̂ɖɗ܂B


set-syntax-match
[       type]: Function
[  arguments]: set-syntax-match SYNTAX-TABLE OPEN-CHAR CLOSE-CHAR
[    package]: editor
[    seealso]: syntax-open-p , syntax-close-p , skip-syntax-spec-forward , goto-matched-parenthesis , *show-matched-parenthesis*
[       file]: builtin.l
[    section]: V^bNX
[description]: 
OPEN-CHARCLOSE-CHARSYNTAX-TABLEɑΉt̂镶ƂċK肵܂B

gpF
  ;;; c-mode.l̒`
  (set-syntax-match *c-mode-syntax-table* #\( #\))
  (set-syntax-match *c-mode-syntax-table* #\{ #\})
  (set-syntax-match *c-mode-syntax-table* #\[ #\])


set-syntax-math
[       type]: Function
[  arguments]: set-syntax-math SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-math-p , skip-syntax-spec-forward
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHAR΂ɂȂ؂蕶ƂċK肵܂B
Latex̐[h̋؂ɑ܂B

gpF
  ;;; Latex.l
  (set-syntax-math *LaTeX-mode-syntax-table* #\$)


set-syntax-option
[       type]: Function
[  arguments]: set-syntax-option SYNTAX-TABLE OPTION
[    package]: editor
[    seealso]: set-syntax-comment-column , set-syntax-start-column-comment
[       link]: [xyzzy:07988]
[       file]: builtin.l
[    section]: V^bNX
[description]: 
V^bNX̕⏕IȐݒ܂B

  *syntax-option-c-preprocessor* : iڍוsj
  *syntax-option-indent-c++*     : iڍוsj
  *syntax-option-indent-java*    : iڍוsj
  *syntax-option-indent-csharp*  : iڍוsj
  *syntax-option-column-comment-char* :
        set-syntax-comment-column ł́AwJɋ󔒈ȊO
        RgƌȂ܂ÃLN^ꂽꍇɂɂ
        ꍇɐݒ肵܂Bȉ̓ݒ肵Ȃ΂Ȃ܂B

        1) set-syntax-option  *syntax-option-comment-column-char* w肷B
        2) set-syntax-start-column-comment ł̃LN^w肷B

gpF
  ;;; fortran.l̒`
  ;;; 0ڂ'C''c'ꂽ炻̍s̓RgƌȂB
  (set-syntax-comment-column fortran-mode-syntax-table 0)
  (set-syntax-option fortran-mode-syntax-table
                     *syntax-option-column-comment-char*)
  (set-syntax-start-column-comment fortran-mode-syntax-table #\C)
  (set-syntax-start-column-comment fortran-mode-syntax-table #\c)

QlF
  [xyzzy:07988]QƂ̂


set-syntax-punctuation
[       type]: Function
[  arguments]: set-syntax-punctuation SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-punctuation-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARǓ_ƂċK肵܂B
قƂǎgƂ͂Ȃł傤B


set-syntax-quote
[       type]: Function
[  arguments]: set-syntax-quote SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-quote-p , skip-syntax-spec-forward
[       file]: builtin.l
[    section]: V^bNX
[description]: 
SYNTAX-TABLECHARquoteƂċK肵܂B
lispŃXgŎg`''(quote)A}NŎg``'(backquote) `,'(comma)A
xN^Ŏg`#'܂BV^bNXł͈Ӗt邱Ƃł
܂Aǂ̂悤ȈႢo邩͕sB

gpF
  ; lisp/lispmode.l
  (set-syntax-quote *lisp-mode-syntax-table* #\#)
  (set-syntax-quote *lisp-mode-syntax-table* #\')
  (set-syntax-quote *lisp-mode-syntax-table* #\,)
  (set-syntax-quote *lisp-mode-syntax-table* #\`)


set-syntax-start-c++-comment
[       type]: Function
[  arguments]: set-syntax-start-c++-comment SYNTAX-TABLE CHAR &optional PARSE-SEXP-IGNORE-COMMENT-P
[    package]: editor
[    seealso]: syntax-c++-comment-p , set-syntax-end-c++-comment , set-syntax-start-comment , set-syntax-start-multi-comment , set-syntax-comment-column , parse-point-syntax
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARC++X^C̃Rg̊JnƂċK肵܂B
uC++X^C̃RgvƂ͓A˂`̂ƂwĂ܂B

gpF
  ;;; cc-mode.l
  (set-syntax-start-c++-comment *c++-mode-syntax-table* #\/)


set-syntax-start-column-comment
[       type]: Function
[  arguments]: set-syntax-start-column-comment SYNTAX-TABLE CHAR &optional PARSE-SEXP-IGNORE-COMMENT-P
[    package]: editor
[    seealso]: set-syntax-option , set-syntax-comment-column , syntax-start-column-comment-p , parse-point-syntax
[       file]: builtin.l
[    section]: V^bNX
[description]: 
set-syntax-comment-column ̕⏕IȐݒ܂B
set-syntax-option *syntax-option-comment-column-char* w肵ꍇ
̃RgJnp̃LN^ݒ肵܂B
ڍׂ set-syntax-option QƂĉB


set-syntax-start-comment
[       type]: Function
[  arguments]: set-syntax-start-comment SYNTAX-TABLE CHAR &optional PARSE-SEXP-IGNORE-COMMENT-P
[    package]: editor
[    seealso]: set-syntax-end-comment , syntax-start-comment-p , set-syntax-start-c++-comment , set-syntax-start-multi-comment , parse-point-syntax
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARRgJnƂċK肵܂B

gpF
  ;;; perl.l
  (set-syntax-start-comment *perl-mode-syntax-table* #\#)


set-syntax-start-multi-comment
[       type]: Function
[  arguments]: set-syntax-start-multi-comment SYNTAX-TABLE STRING
[    package]: editor
[    seealso]: set-syntax-end-multi-comment , syntax-start-multi-comment-1-p , syntax-start-multi-comment-2-p , parse-point-syntax
[   referred]: set-syntax-start-c++-comment , set-syntax-start-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
STRINGSYNTAX-TABLEɕs̃RgJn\ƂċK肵܂B

gpF
  ;;; c-mode.l̒`
  (set-syntax-start-multi-comment *c-mode-syntax-table* "/*")


set-syntax-string
[       type]: Function
[  arguments]: set-syntax-string SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-string-p , set-syntax-escape , skip-syntax-spec-forward , parse-point-syntax
[       file]: builtin.l
[    section]: V^bNX
[description]: 
SYNTAX-TABLECHAR𕶎̋؂蕶ƂċK肵܂BŎw肵
ň͂܂ꂽ̈̓e̕ƂĐFÂ܂B

gpF
  ; |  ̋؂蕶Ƃꍇ
  (set-syntax-string *user-mode-syntax-table* #\|)


set-syntax-symbol
[       type]: Function
[  arguments]: set-syntax-symbol SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-symbol-p , skip-syntax-spec-forward
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARSYNTAX-TABLEŃV{\镶iP\͏j
ċK肵܂B

gpF
  ;;; c-mode.l̒`
  (set-syntax-symbol *c-mode-syntax-table* #\_)
  (set-syntax-symbol *c-mode-syntax-table* #\#)


set-syntax-symbol-prefix
[       type]: Function
[  arguments]: set-syntax-symbol-prefix SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-symbol-prefix-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
V{̑OuqƂċK肵܂B

  SYNTAX-TABLE : V^NbXe[uw肵܂B
  CHAR         : w肵܂B  

HTML`&'(̎Q)APerl`$'(ϐ)A`@'(z)A`%'(Azz)
悤łBEmacs̍\e[uɂ͑̂悤Ɏv܂B

gpF
  ;;; perl.l
  (set-syntax-symbol-prefix *perl-mode-syntax-table* #\$)
  (set-syntax-symbol-prefix *perl-mode-syntax-table* #\@)
  (set-syntax-symbol-prefix *perl-mode-syntax-table* #\%)


set-syntax-tag
[       type]: Function
[  arguments]: set-syntax-tag SYNTAX-TABLE OPEN-CHAR CLOSE-CHAR
[    package]: editor
[    seealso]: html-highlight-mode , syntax-open-tag-p , syntax-close-tag-p , skip-syntax-spec-forward
[   referred]: parse-point-syntax
[       file]: builtin.l
[    section]: V^bNX
[description]: 
V^bNXe[uɃ^O̊JnLƏILݒ肵܂B
HTMLXMLñ[hɐݒ肷Ƃ݂łB
ۂɗpۂɂ͂ html-highlight-mode non-nilɂ
Kv܂B

gpF
  ;;; htmlmode.lł̒`
  (set-syntax-tag *html-mode-syntax-table* #\< #\>)


set-syntax-whitespace
[       type]: Function
[  arguments]: set-syntax-whitespace SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-whitespace-p , skip-white-forward , skip-white-backward , skip-syntax-spec-forward , skip-syntax-spec-backward
[       file]: builtin.l
[    section]: V^bNX
[description]: 
SYNTAX-TABLECHARwhitespaceƂċK肵܂BwhitespaceƂċK肳
 skip-white-forward / skip-white-backwardŃXLbv悤
Ȃ܂B

gpF
  ; lisp/lispmode.l
  (set-syntax-whitespace *lisp-mode-syntax-table* #\SPC)
  (set-syntax-whitespace *lisp-mode-syntax-table* #\TAB)
  (set-syntax-whitespace *lisp-mode-syntax-table* #\C-l)
  (set-syntax-whitespace *lisp-mode-syntax-table* #\RET)


set-syntax-word
[       type]: Function
[  arguments]: set-syntax-word SYNTAX-TABLE CHAR
[    package]: editor
[    seealso]: syntax-word-p , skip-syntax-spec-forward
[       file]: builtin.l
[    section]: V^bNX
[description]: 
P\镶ƂċK肵܂B
skip-syntax-spec-forward / skip-syntax-spec-backwardɉe܂B

  SYNTAX-TABLE : V^NbXe[uw肵܂B
  CHAR         : w肵܂B

ftHgł#\0 .. #\9, #\A .. #\Z, #\a .. #\z łB
]łȂVɐݒ肷Kv͖ł傤B


set-tab-columns
[       type]: Function
[  arguments]: set-tab-columns COLUMN &optional BUFFER
[    package]: editor
[    seealso]: tab-columns
[       file]: builtin.l
[    section]: eLXg
[description]: 
^uݒ肵܂B

  COLUMN : ^uw肵܂B1ȏ32ȉ̔Cӂ̐łB
           2ׂ̂łKv͂܂B
  BUFFER : ^uύXobt@w肵܂B
           w肪Ȃ΃Jgobt@ΏۂɂȂ܂B


set-text-attribute
[       type]: Function
[  arguments]: set-text-attribute FROM TO TAG &key :foreground :background :bold :underline :strike-out :prefix :extend
[    package]: editor
[    seealso]: modify-text-attributes , find-text-attribute , delete-text-attributes , clear-all-text-attributes , list-text-attributes , find-text-attribute-point
[   referred]: find-text-attribute-if , find-text-attribute-if-not , modify-text-attributes-if , set-text-color
[       file]: builtin.l
[    section]: eLXg
[description]: 
[WɐFȂǂ̑t܂B
t delete-text-attributes ŏ܂B
ꊇďꍇɂ́Aclear-all-text-attributes gp܂B

  FROM          tJnʒu
  TO            tIʒu
  TAG           X̑ʂ^O
  :bold         {[hŕ\邩ǂ
  :underline    tŕ\邩ǂ
  :strike-out   \邩ǂ
  :foreground   F𐮐Ŏw
  :background   wiF𐮐Ŏw
  :prefix       g͕s
  :extend       s̉sȍ~ς邩ǂ

F̐ɂāF
  [c[]-[ʐݒ]-[tHg]̂Ƃɂ\FɂȂ܂B

  :foreground 0     : F
              1`15 : 1`15
  :background 0     : wiF
              1`15 : wi1`wi15

  15 傫lw肷ƁC0`15 ̐FJԂ܂B

gpF
  ;;; obt@Ŝ𕶎1̐FɂB
  (set-text-attribute (point-min) (point-max) 'all :bold t :foreground 1)
  => t
  (delete-text-attributes 'all)
  => t


set-text-color
[       type]: Function
[  arguments]: set-text-color FROM TO &optional FOREGROUND BACKGROUND CHAR EXTEND-P
[    package]: editor
[    seealso]: set-text-attribute
[   referred]: clear-all-text-colors
[       file]: cmds.l
[    section]: eLXg
[description]: 
w肳ꂽ̈𑕏܂B

  FROM       : Jnʒuw肵܂B
  TO         : Iʒuw肵܂B
  FOREGROUND : ̐FԍŎw肵܂BȉQ
  BACKGROUND : ̐FԍŎw肵܂BȉQ
  CHAR       : iڍוsj
  EXTEND-P   : iڍוsj

QlF
  ;;; ԍƐF̑Ή
         R   G   B
       ------------
   0     0   0   0
   1   255   0   0
   2     0 255   0
   3   255 255   0
   4     0   0 255
   5   255   0 255
   6     0 255 255
   7   255 255 255
   8     0   0   0
   9   128   0   0
  10     0 128   0
  11   128 128   0
  12     0   0 128
  13   128   0 128
  14     0 128 128
  15   128 128 128

⑫:
  ̊֐ Version 0.0.0.92 ɂ obsolete ƂȂ܂B


set-variable
[       type]: Function
[  arguments]: set-variable VAR
[    package]: editor
[       file]: cmds.l
[    section]: ϐƒ萔
[description]: 
ϐ VAR vvg͂lɐݒ肵܂B[C-x a]
VAR ̒lȂ當ƂāAȊOȂ S Ƃē͂ǂݎ܂B

VAR  boundp łȂƃG[ɂȂ܂B


set-window
[       type]: Function
[  arguments]: set-window WINDOW
[    package]: editor
[    seealso]: selected-window , get-buffer-window , next-window , previous-window
[   referred]: delete-window , with-selected-window
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhEύX܂B
selected-window  get-buffer-window Ŏ擾EBhEɈړ܂B

  WINDOWFړ̃EBhE

gpF
  ;;; *scratch*\ĂΈړB
  (setq win (get-buffer-window (find-buffer "*scratch*")))
  => #<window 48436204>
  (if win (set-window win))
  => t
  (selected-buffer)
  => #<buffer: *scratch*>


set-window-configuration
[       type]: Function
[  arguments]: set-window-configuration CONF
[    package]: editor
[    seealso]: current-window-configuration
[       file]: builtin.l
[    section]: EBhE
[description]: 
擾ĂEBhȄԂɖ߂܂B

  CONFFcurrent-window-configurationŎ擾EBhȄ


set-window-flags
[       type]: Function
[  arguments]: set-window-flags FLAGS
[    package]: editor
[    seealso]: get-window-flags , set-local-window-flags
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhEŜ̓obt@Ŝ̊e\𐧌䂵܂B

 FLAGS : L̃tÕrbgaw肵܂B
        *window-flag-alternate-vscroll-bar* obt@S̕\łĂ
                                            ꍇ̐XN[o[
        *window-flag-cursor-line*           sJ[\
        *window-flag-eof*                   EOF
        *window-flag-fold-line*             ܂ԂC
        *window-flag-fold-mark*             ܂Ԃ
        *window-flag-full-width-space*      SpXy[X
        *window-flag-half-width-space*      pXy[X
        *window-flag-hscroll-bar*           XN[o[
        *window-flag-just-inverse*          iڍוsj
        *window-flag-line-number*           sԍ
        *window-flag-mode-line*             [hs
        *window-flag-newline*               s
        *window-flag-ruler*                 [
        *window-flag-scrolling*             `ʒǔvZŃWvXN[
        *window-flag-tab*                   ^u
        *window-flag-vscroll-bar*           XN[o[
        *window-flag-zenkaku-space*         SpXy[X
                                            (*window-flag-full-width-space*Ɠ)


setf
[       type]: Macro
[  arguments]: setf {PLACE NEW-VALUE}*
[    package]: lisp
[    seealso]: setq
[   referred]: aref , make-array , rotatef , svref , vector
[       file]: setf.l
[    section]: ϐƒ萔
[description]: 
̃}ŃAϐɃANZXA̒lύX邽߂Ɏg܂B]p
ĂsetqėpIłAsetqƑSuĎgp邱Ƃ
܂BPLACÉAANZX悤Ƃf[^IuWFNĝꏊwA
NEW-VALUE]l̏ꏊɏ܂܂B

setf́AłPLACENEW-VALUȆ΂ł󂯕t܂BāAɂ
͂ȂAԂɒl蓖Ă܂B܂Aŏ̈̑΂́AԖڂ̑΂]
Oɕ]APLACEɂĎꏊɒl܂Ă܂B
̂悤ɁAԖڂ̈̑΂́Aŏ̑΂̕]ɂĊ蓖Ăꂽl
gƂ\łBsetf́AŌɕ]ꂽ̑΂ɂĊ蓖Ă
lA邢́A܂^Ȃꍇ́AnilԂ܂B

PLACĚ`͈ȉ̂ǂ̂悤Ȃ̂\łF

(1)ϐ(LVJϐłXyVϐł悢)

  (setf hoge 1); ϐhoge1
  => 1
  hoge
  => 1

(2)ANZX֐
 * \(\̖{ϐ)

  (defstruct foo a b c); \foo錾
  => #<structure-definition: foo>
  (setf hoge (make-foo)); hogeɋfoo\̂(setfsetqł悢)
  => #S(foo a nil b nil c nil)
  (setf (foo-a hoge) 10); hogẽXbga10
  => 10
  hoge
  => #S(foo a 10 b nil c nil)

 * z(aref, svref, fill-pointer)

  (setf hoge (make-array 3)); hogeɋ̃xN^(setfsetqł悢)
  => #(nil nil nil)
  (setf (aref hoge 1) 5); hogexN^2Ԗڂ̐l5ɂ
  => 5
  hoge
  => #(nil 5 nil)

 * Xg(car, cdr, first, rest, etc...)

  (setf hoge '("a" "b" "c"))
  => ("a" "b" "c")
  (setf (car (cdr hoge)) "d")
  => "d"
  hoge
  =>("a" "d" "c")

 * Xg(get, getf, symbol-plist)

  (setf (get 'Japan 'language) "Japanese")
  => "Japanese"
  (setf (get 'Japan 'population) 120000000)
  => 120000000
  (symbol-plist 'Japan)
  => (population 120000000 language "Japanese")

 * ̑(symbol-value, gethash, symbol-function, documentation, macro-function)


setq
[       type]: Special Form
[  arguments]: setq {VAR FORM}*
[    package]: lisp
[    seealso]: setf , psetq
[   referred]: set
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
ϐɒlݒ肵܂B

  (setq ϐ1 l1 ϐ2 l2 ... ϐN lN)

L̗lɕϐƒl̑gCӂׂ̐邱Ƃł܂B

  (setq foo '(1 2 3)) = (set 'foo '(1 2 3))

gpF
  ;;; setsetqœƂĂ݂B
  (set 'foo '(2 3 4))   => (2 3 4)
  foo                   => (2 3 4)
  (setq foo '(1 2 3))   => (1 2 3)
  foo                   => (1 2 3)


setq-default
[       type]: Macro
[  arguments]: setq-default VAR VAL
[    package]: editor
[    seealso]: default-value , set-default , make-local-variable , defvar-local
[       file]: misc.l
[    section]: ϐƒ萔
[description]: 
V{[JłȂꍇ̃ftHg̒lݒ肵܂B

̊֐́Ae symbol ̃ftHglA(ɑΉ) value ɐݒ肵
܂B(symbol ͕]܂) value ͕]܂Bŏ value Ԃ
܂B 

ftHgĺAŗL̃obt@[JlȂobt@Ō܂B 

Jgobt@ symbol obt@[JłȂꍇA ()J
gobt@ setq sȂ̂ƓƂɂȂ܂B symbol Jg
obt@Ńobt@[JłꍇAJgobt@Ōlł͂ȂA
̃obt@܂obt@[JȒlȂꍇɂŌl
肵܂B

gpF
  (make-variable-buffer-local 'local)
  => local
  ;; obt@ foo :
  (setq local 'foo)
  => foo
  ;; obt@ bar :
  local
  => nil
  (setq-default local 'default)
  => default
  local
  => default
  (setq local 'bar)
  => bar
  ;; obt@ baz :
  local
  => default
  ;; obt@ foo :
  (setq local 'foo)
  => foo
  (default-value 'local)
  => default


setup-temp-buffer
[       type]: Function
[  arguments]: setup-temp-buffer BUFFER
[    package]: editor
[    seealso]: buffer-read-only , need-not-save , kept-undo-information , auto-save
[       file]: misc.l
[    section]: obt@
[description]: 
BUFFER ꎞobt@pɏ܂B
̓Iɂ͈ȉ̂悤Ƀobt@[Jϐݒ肵܂B

  buffer-read-only      -> nil
  need-not-save         -> t
  kept-undo-information -> nil
  auto-save             -> nil


seventh
[       type]: Function
[  arguments]: seventh X
[    package]: lisp
[    seealso]: nth
[       file]: list.l
[    section]: Xg
[description]: 
list  7 Ԗڂ̗vfԂ܂B

  (seventh X) = (nth 6 X)

gpF
  (seventh '(1 2 3 4 5 6 7 8 9 0))
  => 7


shell-execute
[       type]: Function
[  arguments]: shell-execute FILENAME &optional DIRECTORY PARAMS
[    package]: editor
[    seealso]: execute-shell-command , make-process
[       file]: builtin.l
[    section]: vZX
[description]: 
s܂BURLł΂JAst@CłΎsA
gqɉăAvP[Vs܂B

  FILENAME  : HURLOKH
  DIRECTORY : ǂłs邩w肵܂B
        t       (cwd)̕ԂfBNgŎs݂łB
        nil     Ɏw肪Ȃ̂FILENAMẼfBNgŎs܂B

F

  | http://java.sun.com/products/jdk/1.2/docs/api/index.html
  | ƂF3L[ꔭŊJĎvĂłB

  Ȃ񂶂łǂB

  (defun foo ()
    (interactive)
    (shell-execute "http://java.sun.com/products/jdk/1.2/docs/api/index.html" t))


shift-region
[       type]: Function
[  arguments]: shift-region START END &optional (COLUMN (TAB-COLUMNS (SELECTED-BUFFER)))
[    package]: editor
[    seealso]: unshift-region
[       file]: region.l
[    section]: [W
[description]: 
STARTENDs͈̔͂COLUMNCfg܂B


shiftf
[       type]: Macro
[  arguments]: shiftf {PLACE}+ NEWVALUE
[    package]: lisp
[    seealso]: rotatef
[       file]: setf.l
[    section]: ϐƒ萔
[description]: 
Ƃė^ꂽl̊i[ꏊ̓eVtg܂B
(shiftf a b c)Ƃƈȉ̂悤ɂȂ܂B

        a   b   c 
sOF 1   2   3
            
                
              
                      
        a   b   c 
sF 2   3   3
            


short-float-p
[       type]: Function
[  arguments]: short-float-p OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTshort-floatȂtAȊOȂnilԂ܂B


show-command-bar
[       type]: Function
[  arguments]: show-command-bar SYM
[    package]: editor
[    seealso]: hide-command-bar
[       file]: cmdbar.l
[    section]: j[
[description]: 
define-command-barŒ`R}ho[\܂B


show-html-help
[       type]: Function
[  arguments]: show-html-help
[    package]: editor
[       file]: winhelp.l
[    section]: ̑
[description]: 
J[\ʒu̕ HTML Help 猟܂B
*html-help-path* ɐݒ肳ꂽwvt@Cgp܂B

*html-help-path* ̒ĺAuʐݒv-ufBNgv-uHTML wvv-
uCOL/CHMt@Cvݒł݂łB


show-tool-bar
[       type]: Function
[  arguments]: show-tool-bar NAME &optional EDGE X Y W
[    package]: editor
[    seealso]: hide-tool-bar
[       file]: builtin.l
[    section]: j[
[description]: 
c[o[NAME\܂BEDGE X Y Ww肷邱ƂŔCӂ̈ʒuɕ\
邱Ƃ\łB

  EDGE  :top    㑤ɕ\
        :left   ɕ\
        :right  Eɕ\
        :bottom ɕ\
        nil     \
  X     ̈ʒu
  Y     c̈ʒu
  W     ^uo[̏ꍇɍEɕ\ꍇ̉^B
        c[o[̏ꍇnil^B

[\]-[c[o[]ɓo^̂Ȃ΁Ashow-tool-barł͂ȂA
define-command-bar/show-command-barg܂B


show-winhelp
[       type]: Function
[  arguments]: show-winhelp
[    package]: editor
[       file]: winhelp.l
[    section]: ̑
[description]: 
J[\ʒu̕ WinHelp 猟܂B[C-F1]
*winhelp-path* ɐݒ肳ꂽwvt@Cgp܂B


shrink-window
[       type]: Function
[  arguments]: shrink-window &optional (ARG 1)
[    package]: editor
[    seealso]: shrink-window-horizontally , enlarge-window
[       file]: window.l
[    section]: EBhE
[description]: 
J[\̂EBhE̍܂B  [C-x C-z]


shrink-window-horizontally
[       type]: Function
[  arguments]: shrink-window-horizontally &optional (ARG 1)
[    package]: editor
[    seealso]: enlarge-window-horizontally , shrink-window
[    section]: EBhE
[description]: 
J[\̂EBhE̕܂B[C-x {]

gpF
  ;;; lister̃}[WEBhE̕ꍇ
  (shrink-window-horizontally (- (window-width) *lister-margin*))


si:*activate-toplevel
[       type]: Function
[  arguments]: *activate-toplevel
[    package]: system
[       file]: builtin.l
[    section]: ̑
[description]: 
xyzzy𑼂̃EBhE̍őOʂɕ\܂B


si:*builtin-function-p
[       type]: Function
[  arguments]: *builtin-function-p OBJECT
[    package]: system
[       file]: builtin.l
[    section]: f[^^
[description]: 
IuWFNgrgC֐ǂ𒲂ׂ܂B

gpF
  ;;; car𒲂ׂĂ݂B
  (si:*builtin-function-p #'car)
  => t


si:*load-library
[       type]: Function
[  arguments]: *load-library FILENAME &key :no-suffix :if-does-not-exist :no-message
[    package]: system
[    seealso]: *load-path* , load-library
[       file]: builtin.l
[    section]: ]
[description]: 
Cu[h܂Bʂ load-library łƎv܂A
ǂȂƂsi:*load-libraryĝł傤H

  :no-suffix         : non-nil Ȃw肳ꂽt@Ĉ܂܃[hB
                       nil Ȃ *load-path* lB
  :if-does-not-exist : :no-suffix  nil Ńt@C݂ȂꍇA
                       :error ȂG[AȊOȂ nil ԂB
  :no-message        : non-nil Ȃ烍[h̃bZ[WoȂB


si:*paste-hook*
[       type]: Variable
[    package]: system
[    seealso]: paste-from-clipboard
[    section]: ϐƒ萔
[description]: 
Nbv{[h\tƂɎs܂B


si:*set-readtable-case
[       type]: Function
[  arguments]: *set-readtable-case READTABLE CASE
[    package]: system
[    seealso]: readtable-case , *readtable*
[       file]: builtin.l
[    section]: o
[description]: 
READTABLE  case sensitivity  CASE ɐݒ肵܂B


si:*stream-line-number
[       type]: Misc
[  arguments]: *stream-line-number &optional STREAM
[    package]: system
[       file]: builtin.l
[    section]: o
[description]: 
iڍוsj
(si:*stream-line-number *standard-input*)


si:base64-decode
[       type]: Function
[  arguments]: base64-decode INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM FOLD-WIDTH
[    package]: system
[    seealso]: si:base64-encode
[   referred]: base64-decode-region-to-file
[       file]: builtin.l
[    section]: ̑
[description]: 
Base64ŃfR[h܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B
  OUTPUT-STREAM          : o͂̃Xg[w肵܂B
        nil     fR[ȟʂbase64-decode̖߂lƂȂ܂B
        nilȊO fR[ȟʂOUTPUT-STREAMɏo͂܂B

gpF
  (si:base64-decode "gtmCsILZgrA=")
  => "قق"


si:base64-encode
[       type]: Function
[  arguments]: base64-encode INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM
[    package]: system
[    seealso]: si:base64-decode
[   referred]: base64-decode-region
[       file]: builtin.l
[    section]: ̑
[description]: 
Base64GR[h܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B
  OUTPUT-STREAM          : o͂̃Xg[w肵܂B
        nil     GR[ȟʂbase64-encode̖߂lƂȂ܂B
        nilȊO GR[ȟʂOUTPUT-STREAMɏo͂܂B

gpF  
  (si:base64-encode "قق")
  => "gtmCsILZgrA="


si:canonicalize-type
[       type]: Function
[  arguments]: canonicalize-type TYPE
[    package]: system
[    seealso]: deftype , typep
[       file]: typespec.l
[    section]: f[^^
[description]: 
deftype Ő錾ꂽf[^^ TYPE WJAW̌^ɒ܂B

Ƃ typep ͕W̌^Ȃ߁A
deftype Ő錾ꂽ^gꍇɂ͂̊֐ŏKv܂B

gp:
  (si:canonicalize-type '(mod 5))
  => (integer 0 4)


si:closure-variable
[       type]: Function
[  arguments]: si:closure-variable CLOSURE
[    package]: system
[   referred]: lambda
[       file]: builtin.l
[    section]: ̑
[description]: 
N[W̒g`߂̊֐łB

  CLOSURE : LVJN[W͊֐`
            LVJN[WV{w肵܂B

ȉ̊֐ŃN[WQƂ邱Ƃ\łB

  si:closure-variable closure
  si:closure-function closure
  si:closure-frame closure
  si:closure-body closure

gpF
  (setq foo (let ((x 3)) #'(lambda () (incf x) x)))
  => #<lexical-closure: (anonymous)>
  (funcall foo)
  => 4
  (funcall foo)
  => 5
  (si:closure-variable foo)
  => ((x . 5))


si:dump-image-path
[       type]: Function
[  arguments]: dump-image-path
[    package]: system
[    seealso]: dump-xyzzy
[       file]: builtin.l
[    section]: VXe
[description]: 
ǂݍ񂾃_vt@C̃pXԂ܂B

gpF
  (si:dump-image-path)
  => "C:/Program Files/xyzzy/xyzzy.w2k"


si:getenv
[       type]: Function
[  arguments]: getenv VARIABLE
[    package]: system
[    seealso]: user-name , machine-name
[   referred]: os-platform
[       file]: builtin.l
[    section]: VXe
[description]: 
ϐ̒lo܂B

  VARIABLEFϐ

gpF
  ;;; ϐPATHoāAXPATHɕB
  (split-string (si:getenv "PATH") #\;)
  => ("c:\\usr\\local\\bin" "C:\\WINNT\\system32" "C:\\WINNT" ...)


si:make-chunk
[       type]: Function
[  arguments]: make-chunk TYPE SIZE &optional SOURCE OFFSET
[    package]: system
[    seealso]: `N̊Tv , si:make-string-chunk , si:unpack-string
[       file]: builtin.l
[    section]: `N
[description]: 
`N쐬܂B`NƂ͊OƂ̂Ƃ邽߂̗̈ŁA
ODLĽĂяoꍇɎgp܂BCIɂchar[]ɑ
Ɏv܂B

  TYPE      : `Ň^łBł͎gpĂȂ悤łB
  SIZE      : `N̒łB
  SRC-CHUNK : 쐬`Ňl^ƂȂ`NłB
  OFFSET    : 쐬`Ňl^ƂȂ`N̊JnʒułB

SRC-CHUNKOFFSET̑gݍ킹Ń`NɊ֘At郁̎
ς悤łB̃`N̓egpꍇɂ͂t܂傤B

    
                    OFFSET                                              
                      
                    wL                  nil                       
    
  SRC-CHUNK wLSRC-CHUNK + OFFSETQƄSRC-CHUNKL           
              
            nil   OFFSET̃AhXQ  Vm        
    

SRC-CHUNK  nil  OFFSET w肳Ăꍇɂ́A OFFSET AhX
ƌȂ̂łB

⑫F
  si:make-chunkDLLĂяoƂACɓn郁蓖Ăs
  BႦΈȉC̃R[h
  
  char buf[300];                                                        
  DWORD rc = GetCurrentDirectory(300, buf);                             
  
  xyzzy lispŏƁAȉ̂悤ɂȂ܂B
  
  (let ((s (si:make-chunk nil 300))) ; C݊̊蓖        
     (GetCurrentDirectory 300 s)     ; define-dll-entryŒ`Ă 
     (si:unpack-string s 0))         ; lisp̕ɕϊ               
  


si:make-string-chunk
[       type]: Function
[  arguments]: make-string-chunk STRING
[    package]: system
[    seealso]: si:make-chunk
[       file]: builtin.l
[    section]: `N
[description]: 
Ɏw肳ꂽ̓eRs[ꂽ`N쐬܂B

gpF
  ;;; WIN32APIMessageBoxgĂ݂B
  (let ((s (si:make-string-chunk "hello"))
        (r (si:make-string-chunk "title")))
    (MessageBox 0 s r MB_OK))     ; define-dll-entryŒ`鎖


si:md5
[       type]: Function
[  arguments]: md5 INPUT-STRING-OR-STREAM
[    package]: system
[       file]: builtin.l
[    section]: ̑
[description]: 
MD5nbVl𓾂܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B

gpF  
  (si:md5 "قق")
  => "11e100e3eb6e6171d9681ba6641794e3"


si:quoted-printable-decode
[       type]: Function
[  arguments]: quoted-printable-decode INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM UNDERSCORE-TO-SPACE
[    package]: system
[   referred]: quoted-printable-decode-region , quoted-printable-decode-region-to-file
[       file]: builtin.l
[    section]: ̑
[description]: 
Quoted-PrintablefR[h܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B
  OUTPUT-STREAM          : o͂̃Xg[w肵܂B
        nil     fR[ȟʂquoted-printable-decode̖߂lƂȂ܂B
        nilȊO fR[ȟʂOUTPUT-STREAMɏo͂܂B


si:system-root
[       type]: Function
[  arguments]: system-root
[    package]: system
[    seealso]: user-homedir-pathname
[   referred]: user-config-path
[       file]: builtin.l
[    section]: VXe
[description]: 
xyzzyCXg[ĂpXԂ܂B

userpbP[WeditorpbP[Wsystemuse-packageĂȂ̂ŁA
  ĂяoƂsi:tāA(si:system-root)ƂȂ΂܂B

gpF
  (load (merge-pathnames "lisp/henmi/foo.l" (si:system-root)))


si:unpack-string
[       type]: Function
[  arguments]: unpack-string CHUNK OFFSET SIZE &optional ZERO-TERMINATING-P
[    package]: system
[    seealso]: si:make-chunk , `N̊Tv
[       file]: builtin.l
[    section]: `N
[description]: 
`Nlisp̕ɕϊ܂B

  CHUNK              : make-chunkōꂽ`N
  OFFSET             : 񉻂ʒuw肵܂B
  SIZE               : OFFSET̈ʒu當񉻂钷w肵܂B
  ZERO-TERMINATING-P : iڍוsj


si:uudecode
[       type]: Function
[  arguments]: uudecode INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM
[    package]: system
[    seealso]: si:uuencode
[   referred]: uudecode-region , uudecode-region-to-file
[       file]: builtin.l
[    section]: ̑
[description]: 
uudecode܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B
  OUTPUT-STREAM          : o͂̃Xg[w肵܂B
        nil     fR[ȟʂuudecode̖߂lƂȂ܂B
        nilȊO fR[ȟʂOUTPUT-STREAMɏo͂܂B


si:uuencode
[       type]: Function
[  arguments]: uuencode INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM
[    package]: system
[    seealso]: si:uudecode
[       file]: builtin.l
[    section]: ̑
[description]: 
uuencode܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B
  OUTPUT-STREAM          : o͂̃Xg[w肵܂B
        nil     GR[ȟʂuuencode̖߂lƂȂ܂B
        nilȊO GR[ȟʂOUTPUT-STREAMɏo͂܂B


si:www-url-decode
[       type]: Function
[  arguments]: www-url-decode INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM
[    package]: system
[    seealso]: si:www-url-encode
[       file]: builtin.l
[    section]: ̑
[description]: 
URL fR[hs܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B
  OUTPUT-STREAM          : o̓Xg[łB
                           t w肵ꍇ͕Wo͂֏o͂܂B
                           ȗ nil w肷Ɩ߂lɂȂ܂B

gp:
  (si:www-url-decode "%82%D9%82%B0%82%D9%82%B0" nil)
  =>"قق"

⑫:
  xyzzy 0.2.2.233 ł builtin.l ̈̋LqԈĂ܂B
  0.2.2.234 ŏC܂B


si:www-url-encode
[       type]: Function
[  arguments]: www-url-encode INPUT-STRING-OR-STREAM &optional OUTPUT-STREAM LITERAL-CHARS
[    package]: system
[    seealso]: si:www-url-decode
[       file]: builtin.l
[    section]: ̑
[description]: 
RFC1738 ɊÂ URL GR[hs܂B

  INPUT-STRING-OR-STREAM : ͂̕܂͓̓Xg[w肵܂B
  OUTPUT-STREAM          : o̓Xg[łB
                           t w肵ꍇ͕Wo͂֏o͂܂B
                           ȗ nil w肷Ɩ߂lɂȂ܂B
  LITERAL-CHARS          : GR[hȂQw肵܂B
     t                       ׂĂ̕GR[h
     nil                     "-A-Za-z0-9$_.+!*'(|),"Ɠl

gp:
  ; Wł Shift_JIS ƂăGR[h
  (si:www-url-encode "")
  =>"%82%A9%82%DF"
  
  ; EUC-JP ƂăGR[h
  (si:www-url-encode (map-internal-to-euc ""))
  =>"%A4%AB%A4%E1"
  
  ; ϊȂQ𖾎
  (si:www-url-encode "www-url-encode" nil "0-9A-Za-z")
  =>"www%2Durl%2Dencode"

⑫:
  RFC1738͌RFC3986ɂčXVĂ܂B
  RFC3986Œ`Ă unreserved ȕ̎ނ "0-9A-Za-z---._~" łB

  xyzzy 0.2.2.233 ł builtin.l ̈̋LqԈĂ܂B
  0.2.2.234 ŏC܂B


signal-process
[       type]: Function
[  arguments]: signal-process PROCESS
[    package]: editor
[    seealso]: kill-process , process-exit-code
[       file]: builtin.l
[    section]: vZX
[description]: 
w肳ꂽvZXPROCESSɃVOi𑗂܂B
SIGINT?


signum
[       type]: Function
[  arguments]: signum NUMBER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
l̕Ԃ܂B
f̏ꍇ͕ΊpΒl 1 ̕fԂ܂

gpF
  (signum 12)
  => 1
  (signum 0)
  => 0
  (signum -5.0)
  =>-1.0
  (signum (complex 1 1))
  =>#C(0.7071068 0.7071068)


simple-string
[       type]: Misc
[    package]: lisp
[    seealso]: simple-string-p , schar
[    section]: f[^^
[description]: 
simple-string Ƃ̓Vvȕ̂Ƃw܂B
L\łȂAtB|C^ATCYύXs\ȕ̂Ƃ
Bformatconcatgĕ𑀍삷ꍇɂsimple-strinĝ܂܂łB

gpF
  ;;; simple-string̏ꍇ
  (type-of "abc") 
  => simple-string


simple-string-p
[       type]: Function
[  arguments]: simple-string-p OBJECT
[    package]: lisp
[    seealso]: simple-string
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTsimple-stringȂtAȊOȂnilԂ܂B

gpF
  ;;; make-vectorgsimple-stringłȂstring܂B
  (setq var1 (make-vector 10 :element-type 'character)
        var2 (make-vector 10 :element-type 'character :fill-pointer 0))
  => ""
  (type-of var1)                => simple-string
  (type-of var2)                => string
  (simple-string-p var1)        => t
  (simple-string-p var2)        => nil


simple-vector-p
[       type]: Function
[  arguments]: simple-vector-p OBJECT
[    package]: lisp
[    seealso]: vectorp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTsimple-vectorȂtAȊOȂnilԂ܂B


sin
[       type]: Function
[  arguments]: sin RADIANS
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
֐̒lԂ܂B


single-float-p
[       type]: Function
[  arguments]: single-float-p OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTsingle-floatȂtAȊOȂnilԂ܂B


sinh
[       type]: Function
[  arguments]: sinh Z
[    package]: lisp
[       file]: number.l
[    section]: l
[description]: 
oȐ֐vZ܂B 


sit-for
[       type]: Function
[  arguments]: sit-for TIMEOUT &optional NO-REDRAW
[    package]: editor
[    seealso]: sleep-for , do-events , refresh-screen
[       file]: builtin.l
[    section]: tE
[description]: 
w肳ꂽb~܂BrŃL[͂ΒɍĊJ܂B

  TIMEOUT   : ~bw肵܂B
  NO-REDRAW : ĊJɉʂĕ`悷邩ǂw肵܂B


sixth
[       type]: Function
[  arguments]: sixth X
[    package]: lisp
[    seealso]: nth
[       file]: list.l
[    section]: Xg
[description]: 
list  6 Ԗڂ̗vfԂ܂B

  (sixth X) = (nth 5 X)

gpF
  (sixth '(1 2 3 4 5 6 7 8 9 0))
  => 6


skip-chars-backward
[       type]: Function
[  arguments]: skip-chars-backward CHARS
[    package]: editor
[    seealso]: skip-chars-forward , skip-syntax-spec-backward
[       file]: builtin.l
[    section]: EK\
[description]: 
skip-chars-forwarď̂̂łB


skip-chars-forward
[       type]: Function
[  arguments]: skip-chars-forward CHARS
[    package]: editor
[    seealso]: skip-chars-backward , skip-syntax-spec-forward
[   referred]: scan-buffer
[       file]: builtin.l
[    section]: EK\
[description]: 
w肳ꂽQOɃXLbv܂B

  CHARS : XLbv镶Qw肵܂B

skip-syntax-spec-forward܂A̓obt@̃V^bN
Xe[uăXLbv镶𔻒f܂BړI͂肵Ă΁A
skip-chars-forwardgp܂傤B

gpF
  ;;; p󔒂ƃ^uXLbv܂B
  (skip-chars-forward " \t")


skip-syntax-spec-backward
[       type]: Function
[  arguments]: skip-syntax-spec-backward SYNTAX-SPEC
[    package]: editor
[    seealso]: skip-syntax-spec-forward , skip-chars-backward , skip-white-backward
[   referred]: set-syntax-whitespace
[       file]: builtin.l
[    section]: EK\
[description]: 
skip-syntax-spec-forwarď̂̂łB


skip-syntax-spec-forward
[       type]: Function
[  arguments]: skip-syntax-spec-forward SYNTAX-SPEC
[    package]: editor
[    seealso]: skip-syntax-spec-backward , skip-chars-forward , skip-white-forward , skip-token
[   referred]: set-syntax-junk , set-syntax-match , set-syntax-math , set-syntax-quote , set-syntax-string , set-syntax-symbol , set-syntax-tag , set-syntax-whitespace , set-syntax-word
[       file]: builtin.l
[    section]: EK\
[description]: 
V^bNXe[ũJeSÂĕOɃXLbv܂B

skip-syntax-spec-(for|back)ward ́AV^bNXe[uŎw
镶̃JeSɊÂāAw肳ꂽJeSɑ镶
XLbv֐łBJeS\͈ȉ̒ʂł(7 
炢 Emacs ƌ݊)B

;  ' '(Xy[X)  󔒕
;  .              L
;  (              J
;  )              
;  $              TeX  $
;  "              ̋؂
;  <             1 Rg̊Jn
;  >             1 Rg̏I
;  /              C++  // Rg̏I
;  \              GXP[v
;  '              PƂŌꂽƂ͋LAV{ɗאڂĂꍇ̓V{
;  _              V{\镶
;  w              P\镶
;  k              锼pJi
;  j              
;  x              S~
;  {              ^O̊Jn
;  }              ^ȌI

ŏ '^' w肷ƁAw肵JeSȊOƂӖɂȂ
(K\[^...]Ɠ)BJgobt@̃V^bNXe[
uɊÂ̂ŁAobt@̃[hɂēςĂ܂B
Ȃ݂ɁAP\镶͈ʂɉpŁAV{\
镶͒P\镶ȊOŎʎqɎgȕƂ
łB

̕тɂ͈Ӗ͂܂B"w_" "_w" ͓̂Ӗ܂B

gpF
  ;;; [h̋؂ɈړEp
  (skip-syntax-spec-forward "w_")

  ;;; [h̋؂ɈړE
  (skip-syntax-spec-forward "jk_")


skip-token
[       type]: Function
[  arguments]: skip-token
[    package]: editor
[    seealso]: skip-syntax-spec-forward
[       file]: builtin.l
[    section]: |WV
[description]: 
V{\ƒP\XLbv܂B
iڍוsj


skip-white-backward
[       type]: Function
[  arguments]: skip-white-backward
[    package]: editor
[    seealso]: skip-white-forward , skip-syntax-spec-backward
[   referred]: set-syntax-whitespace
[       file]: builtin.l
[    section]: |WV
[description]: 
󔒕ɃXLbv܂B
V^bNXe[uwhitespaceƂċK肳Ă镶
XLbv܂Bɂevf悤łڍׂ͕sB


skip-white-forward
[       type]: Function
[  arguments]: skip-white-forward
[    package]: editor
[    seealso]: skip-white-backward , skip-syntax-spec-forward
[   referred]: set-syntax-whitespace
[       file]: builtin.l
[    section]: |WV
[description]: 
󔒕OɃXLbv܂
V^bNXe[uwhitespaceƂċK肳Ă镶O
XLbv܂Bɂevf悤łڍׂ͕sB


sleep-for
[       type]: Function
[  arguments]: sleep-for TIMEOUT
[    package]: editor
[    seealso]: sit-for , refresh-screen
[   referred]: do-events
[       file]: builtin.l
[    section]: tE
[description]: 
w肳ꂽb~܂BrŃL[͂Ăɂ͍ĊJ܂B

  TIMEOUT   : ~bw肵܂B


smart-indentation
[       type]: Function
[  arguments]: smart-indentation COLUMN
[    package]: editor
[    seealso]: *smart-indentation* , indent-to
[       file]: cmds.l
[    section]: eLXg
[description]: 
scolumnCfg܂B
*smart-indentation*t͓̎KxɃT{肷݂łB


software-type
[       type]: Function
[  arguments]: software-type
[    package]: lisp
[       file]: builtin.l
[    section]: VXe
[description]: 
\tgԂ܂B

gpF  
  (software-type)
  => "xyzzy"


software-version
[       type]: Function
[  arguments]: software-version
[    package]: lisp
[       file]: builtin.l
[    section]: VXe
[description]: 
xyzzỹo[WԂ܂B

gpF
  (software-version)
  => "0.2.2.228"


some
[       type]: Function
[  arguments]: some PREDICATE SEQUENCE &rest MORE-SEQUENCES
[    package]: lisp
[    seealso]: every , notany
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE̐擪̗vf珇ԂPREDICATEKpĂAPREDICATE
nilȒlԂƁA̒lSOME̖߂lƂĂɏI܂B
PREDICATE𖞂vfȂ nil Ԃ܂B

MORE-SEQUNCES^ꂽASEQUENCE̒ōłẐ̏I܂Ŏs܂B


sort
[       type]: Function
[  arguments]: sort SEQUENCE PREDICATE &key :key
[    package]: lisp
[    seealso]: stable-sort
[       link]: [xyzzy:06221]
[    section]: V[PX
[description]: 
SEQUENCE  PREDICATE ɏ]Ԃɕёւ̂Ԃ܂B SEQUENCE
͕ύX܂B sort ͈ł邱Ƃ͕ۏ؂܂Bȃ\[gKv
ȂƂ stable-sort g܂傤B

  SEQUENCE  : \[gV[PXw肵܂B
  PREDICATE : r֐w肵܂B
  :key      : rΏۂ擾֐w肵܂B

gpF
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (setq *test-seq* (sort *test-seq* #'string-lessp :key #'car))
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("bar") ("foo") ("hoge"))
 
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (sort *test-seq* #'string-lessp :key #'car)
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("foo") ("hoge"))

QlF
  [xyzzy:06221] ()o[WAbv̂m点
  Esort ̃ASY quick  merge ɕύX
  (r񐔂ȂAmerge ̕ۂ)B
  ʁAstable-sort ƓɂȂ(AˑȂ悤)B
  ] *܂* (eq list (sort list)) A
  ł͂ȂȂ̂Œӂ邱ƁB


spec-map
[       type]: Variable
[    package]: editor
[    seealso]: specific-command-prefix
[       file]: keymap.l
[    section]: L[}bv
[description]: 
C-c ɑL[V[PX̃oCfBOi[L[}bvłB


special
[       type]: Misc
[    package]: lisp
[    seealso]: declare
[    section]: ϐƒ萔
[description]: 
declare 񂭂B


special-file-p
[       type]: Function
[  arguments]: special-file-p PATHNAME
[    package]: lisp
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
PATHNAMEfoCXt@C(CON, AUX, NUL, PRN, LPT1/2/3/4, COM1/2/3/4)
ۂԂ܂B
  t    foCXt@CłB
  nil  foCXt@CłȂB


special-form-p
[       type]: Function
[  arguments]: special-form-p SYMBOL
[    package]: lisp
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
V{`ǂԂ܂B

  SYMBOL : 肷V{

߂l
  nil      V{͓`ł͂ȂB
  non-nil  V{͓`

  ; `oĂ݂
  (do-all-symbols (i "end")
    (and (special-form-p i)
         (format t "~A~%" i)))
  interactive
  save-restriction
  save-excursion
  save-window-excursion
  *byte-code
  macrolet
  setq
  throw
  return-from
  progn
  let*
  go
  labels
  if
  multiple-value-call
  unwind-protect
  multiple-value-setq
  catch
  tagbody
  eval-when
  let
  multiple-value-bind
  block
  function
  quote
  multiple-value-prog1
  flet
  =>"end"


specific-command-prefix
[       type]: Function
[  arguments]: specific-command-prefix
[    package]: editor
[    seealso]: spec-map
[       file]: keymap.l
[    section]: L[}bv
[description]: 
C-c vtBbNXłB [C-c]

specific-command-prefix ̊֐Z͕ʂ̃R}hł͂Ȃ spec-map 
L[}bvێĂ܂B


split-line
[       type]: Function
[  arguments]: split-line
[    package]: editor
[    seealso]: open-line
[       file]: cmds.l
[    section]: eLXg
[description]: 
J[\ʒus܂ł̃eLXgc 1 sA2 sɕ܂B[ESC C-o]


split-string
[       type]: Function
[  arguments]: split-string STRING SEPARATOR &optional IGNORE-EMPTY CHAR-BAG
[    package]: editor
[       file]: builtin.l
[    section]: 
[description]: 
w肳ꂽZp[^ŕXgɂ܂B
Zp[^͊܂܂܂B

  STRING       : 镶w肵܂B
  SEPARATOR    : Zp[^w肵܂B
  IGNORE-EMPTY : 0̕i܂AZp[^A悤ȏꍇj
                 ǂw肵܂B
  CHAR-BAG     : ̑̕Og邽߂̕Qw肵܂B
  
gpF
  (split-string "121,,12321" #\,)       => ("121" "12321")
  (split-string "121,,12321" #\, t)     => ("121" "" "12321")
  (split-string "121,,12321" #\, t "1") => ("2" "" "232")
  (split-string "121,,12321" #\, t "3") => ("121" "" "12321")


split-window
[       type]: Function
[  arguments]: split-window &optional ARG VERTICAL
[    package]: editor
[    seealso]: split-window-vertically , pop-to-buffer
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE𕪊܂BTCYƕw\łB[C-x 2]

  ARG      : TCYw肵܂B
  VERTICAL : w肵܂B
        t       Eɕ܂B
        nil     ㉺ɕ܂B

ɃJgɂȂEBhEɂ͒ӂKvłB

  (split-window 20 t)
  => +20-+---------+    
     |   |         |
     +-+---------+
      ɃJ[\
 
  (split-window -20 t)
  => +---------+20-+
     |         |   |
     +---------+-+
                ɃJ[\

  (split-window 20 nil)
  => +-------------+    
     |             ɃJ[\
     +-------------+    
     +-------------+    
      
  (split-window -20 nil)
  => +-------------+    
     +-------------+    
     |             ɃJ[\
     +-------------+          


split-window-vertically
[       type]: Function
[  arguments]: split-window-vertically &optional ARG
[    package]: editor
[    seealso]: split-window
[   referred]: pop-to-buffer
[       file]: window.l
[    section]: EBhE
[description]: 
EBhEEɕ܂B[C-x 5]


sqrt
[       type]: Function
[  arguments]: sqrt NUMBER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
̒lԂ܂B


stable-sort
[       type]: Function
[  arguments]: stable-sort SEQUENCE PREDICATE &key :key
[    package]: lisp
[    seealso]: sort
[   referred]: merge
[       link]: [xyzzy:06221]
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCE  PREDICATE ɏ]Ԃɕёւ̂Ԃ܂B SEQUENCE
͕ύX܂B stable-sort ͈ȃ\[gs܂B܂ PREDICATE ɂ
ēƌȂvfԂ̏́A\[gOƓł邱Ƃۏ؂܂B

  SEQUENCE  : \[gV[PXw肵܂B
  PREDICATE : r֐w肵܂B
  :key      : rΏۂ擾֐w肵܂B

gpF
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (setq *test-seq* (stable-sort *test-seq* #'string-lessp :key #'car))
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("bar") ("foo") ("hoge"))
 
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (stable-sort *test-seq* #'string-lessp :key #'car)
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("foo") ("hoge"))


standard-char-p
[       type]: Function
[  arguments]: standard-char-p CHAR
[    package]: lisp
[    seealso]: characterp
[       file]: builtin.l
[    section]: f[^^
[description]: 
As [ -~] ǂ𔻒肵܂B
\\ȕ SJIS R[h 10, 32-126 łB

  CHAR : 肷镶

߂lF
  t   standard-char ł
  nil standard-char łȂ

⑫F
  ;;; s(SJIS 10) ȊO standard-char ꗗo (SJIS 32-126)
  (do ((i (char-code #\SPC) (1+ i)))
      ((= i (char-code #\DEL)))
    (format t "~A" (code-char i)))


start-selection
[       type]: Function
[  arguments]: start-selection TYPE &optional TEMPORARY POINT
[    package]: editor
[    seealso]: stop-selection , get-selection-type , set-selection-type , fix-selection-point , pre-selection-p
[       file]: builtin.l
[    section]: [W
[description]: 
Ï͈͎̔wJn܂B

  TYPEFÏ͈͎̔w̕@w肵܂B 
        1̏ꍇ         ͈͑Isōs܂B
        2̏ꍇ         ͈͑I𕶎ōs܂B
        3̏ꍇ         ͈͑I`ōs܂B

  TEMPORARYFꎞIȂ̂ǂw肵܂B
        t̏ꍇ         L[͂Ɣ͈͎w܂B
        nil̏ꍇ       J[\ړɉĔ͈͂ύX܂B

gpF
  ;;; `Ŕ͈͎w肷B
  (start-selection 3 nil)
  => t


start-selection-as-line
[       type]: Function
[  arguments]: start-selection-as-line
[    package]: editor
[    seealso]: start-selection-as-region
[       file]: select.l
[    section]: [W
[description]: 
sI[hJn܂B[F6]
ZNV݂ꍇ́AZNV܂B


start-selection-as-region
[       type]: Function
[  arguments]: start-selection-as-region
[    package]: editor
[    seealso]: start-selection-as-line
[       file]: select.l
[    section]: [W
[description]: 
I[hJn܂B[S-F6]
I[hJnĂꍇ́A`I[hɐؑւ܂B
`I[hJnĂꍇ́AI[hɐؑւ܂B
sI[hJnĂꍇ́AI[h܂B


start-timer
[       type]: Function
[  arguments]: start-timer INTERVAL FN &optional ONE-SHOT-P
[    package]: editor
[    seealso]: stop-timer
[       file]: builtin.l
[    section]: tE
[description]: 
^C}[ݒ肵܂BINTERVALbɁAFNfuncall܂B

  INTERVAL   : bɊ֐s邩w肵܂B
  FN         : s֐w肵܂B
  ONE-SHOT-P : pč쓮邩ǂw肵܂B
        nil      pč쓮܂B
        non-nil  1 񂾂쓮܂B
  
gpF
  ;; p^[zQƂō
  (setq pat '(#\\ #\^ #\b #\_))
  => pat
  (setf (cdr (last pat)) pat)
  => #1=(#\\ #\^ #\b #\_ . #1#)
  (defun func () (setq pat (cdr pat)) (message "~A" (car pat)))
  => func
  ;; ́c
  (start-timer 0.2 'func)
  => t  
  ;; ~߂鎞́c
  (stop-timer 'func)
  => t


start-xyzzy-server
[       type]: Function
[  arguments]: start-xyzzy-server
[    package]: editor
[    seealso]: stop-xyzzy-server
[       file]: builtin.l
[    section]: VXe
[description]: 
stop-xyzzy-server̋tłBxyzzy-serverオĂԂ
xyzzycli.exe sꂽꍇAŌɃANeBuɂȂقI
悤łB


step
[       type]: Macro
[  arguments]: step FORM
[    package]: lisp
[       file]: misc.l
[    section]: \
[description]: 
Xebvss܂B


stop-selection
[       type]: Function
[  arguments]: stop-selection
[    package]: editor
[    seealso]: start-selection , fix-selection-point
[       file]: builtin.l
[    section]: |WV
[description]: 
ZNV܂B


stop-timer
[       type]: Function
[  arguments]: stop-timer FN
[    package]: editor
[    seealso]: start-timer
[       file]: builtin.l
[    section]: tE
[description]: 
ݒ肵^C}[~܂B


stop-xyzzy-server
[       type]: Function
[  arguments]: stop-xyzzy-server
[    package]: editor
[    seealso]: start-xyzzy-server
[       file]: builtin.l
[    section]: VXe
[description]: 
xyzzycli.exeɔȂ悤ɂ܂B


store-match-data
[       type]: Function
[  arguments]: store-match-data DATA
[    package]: editor
[    seealso]: scan-buffer , match-data
[   referred]: match-string , replace-match
[       file]: builtin.l
[    section]: EK\
[description]: 
match-data őޔĂ_̏Ԃ߂܂B


streamp
[       type]: Function
[  arguments]: streamp OBJECT
[    package]: lisp
[    seealso]: open-stream-p
[       file]: builtin.l
[    section]: o
[description]: 
OBJECTXg[ۂԂ܂B
  t    OBJECT̓Xg[łB
  nil  OBJECT̓Xg[łȂB


string
[       type]: Function
[  arguments]: string X
[    package]: lisp
[    seealso]: symbol-name , make-sequence , format , coerce
[       file]: builtin.l
[    section]: 
[description]: 
XȂ炻Ԃ܂BV{Ȃ炻̖OԂ܂B
╶̃xN^ȂA̕Ȃ镶Ԃ܂B

gpF
  (string "foo")
  => "foo"
  (string 'bar)
  => "bar"
  (string #\a)
  => "a"
  (string (make-vector 3 :initial-contents '(#\a #\b #\c)))
  => "abc"


string-capitalize
[       type]: Function
[  arguments]: string-capitalize STRING &key :start :end
[    package]: lisp
[    seealso]: nstring-capitalize
[       file]: builtin.l
[    section]: 
[description]: 
STRING ̓̒P̐擪啶ɁAȊOɂԂ܂B
 STRING ͕ۑ܂B

gpF
  (string-capitalize "xYZzY")
  => "Xyzzy"  
  (string-capitalize "tHis iS a pEn.")
  => "This Is A Pen."


string-downcase
[       type]: Function
[  arguments]: string-downcase STRING &key :start :end
[    package]: lisp
[    seealso]: nstring-downcase , char-downcase , downcase-word
[       file]: builtin.l
[    section]: 
[description]: 
STRING ɂԂ܂B STRING ͕ۑ܂B

gpF
  (string-downcase "XyZzY")
  => "xyzzy"
  (string-downcase "XYZZY" :start 2 :end 4)
  => "XYzzY"


string-equal
[       type]: Function
[  arguments]: string-equal STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: equalp , string= , string-not-equal
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2啶Ɋ֌WȂrētAłȂ
nilԂ܂B

gpF
  (string-equal "foo" "foo")
  => t
  (string-equal "foo" "Foo")
  => t


string-greaterp
[       type]: Function
[  arguments]: string-greaterp STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string< , string> , string<= , string>= , string-lessp , string-not-lessp , string-not-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2啶Ɋ֌WȂrāu>v̏𖞂
vȂ̃CfbNXAłȂnilԂ܂B

gpF
  (string-greaterp "ac" "ab")
  => 1
  (string-greaterp "ac" "ac")
  => nil
  (string-greaterp "AC" "ab")
  => 1


string-left-trim
[       type]: Function
[  arguments]: string-left-trim CHARACTER-BAG STRING
[    package]: lisp
[    seealso]: string-trim , string-right-trim
[       file]: builtin.l
[    section]: 
[description]: 
̐擪w肵Q폜܂B

  STRING         : 
  CHARACTGER-BAG : 폜镶QłB
  
gpF
  ;;;  擪"/""\"菜܂B
  (string-left-trim "/\\" "/foo/bar/zzz.txt/")
  => "foo/bar/zzz.txt/"


string-lessp
[       type]: Function
[  arguments]: string-lessp STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string< , string> , string<= , string>= , string-not-lessp , string-greaterp , string-not-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2啶Ɋ֌WȂrāu<v̏𖞂
vȂ̃CfbNXAłȂnilԂ܂B

gpF  
  (string-lessp "Aa" "ab")
  => 1
  (string-lessp "ac" "AB")
  => nil  


string-looking-at
[       type]: Function
[  arguments]: string-looking-at REGEXP STRING &key :start :end :case-fold
[    package]: editor
[    seealso]: string-match , string-matchp , looking-at , match-string , K\̕\L
[       file]: builtin.l
[    section]: 
[description]: 
STRING AREGEXP ƃ}b`邩𒲂ׂ܂B

string-match ́AREGEXP  STRING ̂ǂɃ}b`΁ÄʒuԂ
܂Astring-looking-at ͎w肳ꂽʒuŃ}b`邩Ԃ܂B

  :start       : `FbN镶̊Jnʒuw肵܂B
                 KȒlłȂƂA߂l nil ƂȂ܂B
  :end         : `FbN镶̏Iʒuw肵܂B
                 KȒlłȂƂA߂l nil ƂȂ܂B
  :case-fold   : ASCII ̑啶̋ʂ̕@w肵܂B
                 REGEXP [RpCςݐK\]̏ꍇ́A:case-fold
                 w͈Ӗ܂B
        nil     - 啶ʂČ܂B
        :smart  - REGEXP ɑ啶܂܂ĂȂꍇA啶
                  ʂɌ܂B
        LȊO- 啶ʂɌ܂B

:
  (string-looking-at "a+b" "aaab")
  => 0

  (string-looking-at "a+b" "baaab")
  => nil

  (string-looking-at "a+b" "aaab" :start 2)
  => 2

  (string-looking-at "a+b" "aaab" :start 3 :end 6)
  => nil

  (string-looking-at "a+b" "AaAAB" :case-fold :smart)
  => 0


string-match
[       type]: Function
[  arguments]: string-match REGEXP STRING &optional START END
[    package]: editor
[    seealso]: string-matchp , string-looking-at , looking-at , K\̕\L
[   referred]: string-replace-match
[       file]: builtin.l
[    section]: 
[description]: 
w肳ꂽ񂪐K\Ɉv邩ǂԂ܂B

  REGEXP : K\
  STRING : `FbN镶
  START  : ̊Jnʒu
  END    : ̏Iʒu

݊F
  muleB
  Common LispȂB


string-matchp
[       type]: Function
[  arguments]: string-matchp REGEXP STRING &optional START END
[    package]: editor
[    seealso]: string-match , string-looking-at
[       file]: builtin.l
[    section]: 
[description]: 
| string-match  string-matchp Ƃ͂ǂǂ
| Ⴄ̂ł傤H

p t͑̕啶ʂ܂B


string-not-equal
[       type]: Function
[  arguments]: string-not-equal STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string-equal
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2啶Ɋ֌WȂrēȂΈvȂ
̃CfbNXAłȂnilԂ܂B
string-equal̔΂̋@\łB


string-not-greaterp
[       type]: Function
[  arguments]: string-not-greaterp STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string< , string> , string<= , string>= , string-lessp , string-not-lessp , string-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2啶Ɋ֌WȂrāu<=v̏𖞂
ΈvȂ̃CfbNXAłȂnilԂ܂B


string-not-lessp
[       type]: Function
[  arguments]: string-not-lessp STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string< , string> , string<= , string>= , string-lessp , string-greaterp , string-not-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2啶Ɋ֌WȂrāu>=v̏𖞂
ΈvȂ̃CfbNXAłȂnilԂ܂B


string-rectangle
[       type]: Function
[  arguments]: string-rectangle P1 P2 STRING
[    package]: editor
[    seealso]: string-rectangle-selection , operate-on-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
P1  P2 Ŏw肳`̈̊es𕶎 STRING Œu܂B


string-rectangle-selection
[       type]: Function
[  arguments]: string-rectangle-selection STRING
[    package]: editor
[    seealso]: string-rectangle , operate-on-rectangle-selection
[       file]: select.l
[    section]: [W
[description]: 
`IꂽZNV̊es𕶎 STRING Œu܂B


string-replace-match
[       type]: Function
[  arguments]: string-replace-match STRING REPLACEMENT
[    package]: editor
[    seealso]: string-match
[       file]: builtin.l
[    section]: 
[description]: 
string-matchŌʂgĕ̒us܂B

  STRING      : string-matchŎw肵w肵܂B
  REPLACEMENT : u镶w肵܂B
                REPLACEɂ͐K\ɕ\1-\9܂߂邱Ƃ\łB

gpF
  ;;; uĂ݂B
  (setq str "01356:00001:error message")
  => "01356:00001:error message"
  (when (string-match "\\([0-9]+\\):\\([0-9]+\\):\\(.*\\)" str)
    (setq str (string-replace-match str "\\1,\\3")))
  => "01356,error message"


string-right-trim
[       type]: Function
[  arguments]: string-right-trim CHARACTER-BAG STRING
[    package]: lisp
[    seealso]: string-trim , string-left-trim
[       file]: builtin.l
[    section]: 
[description]: 
̖w肵Q폜܂B

  STRING         : 
  CHARACTGER-BAG : 폜镶QłB
  
gpF
  ;;;  "/""\"菜܂B
  (string-right-trim "/\\" "/foo/bar/zzz.txt/")
  => "/foo/bar/zzz.txt"


string-trim
[       type]: Function
[  arguments]: string-trim CHARACTER-BAG STRING
[    package]: lisp
[    seealso]: string-right-trim , string-left-trim
[       file]: builtin.l
[    section]: 
[description]: 
̑Oォw肵Q폜܂B

  STRING         : 
  CHARACTGER-BAG : 폜镶QłB
  
gpF
  ;;;  O"/""\"菜܂B
  (string-trim "/\\" "/foo/bar/zzz.txt/")
  => "foo/bar/zzz.txt"


string-upcase
[       type]: Function
[  arguments]: string-upcase STRING &key :start :end
[    package]: lisp
[    seealso]: nstring-upcase , char-upcase , upcase-word
[       file]: builtin.l
[    section]: 
[description]: 
STRING 啶ɂԂ܂B STRING ͕ۑ܂B

gpF
  (string-upcase "xyzzy")
  => "XYZZY"
  (string-upcase "xyzzy" :start 2 :end 4)
  => "xyZZy"


string/=
[       type]: Function
[  arguments]: string/= STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string=
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2rēȂΈvȂ̃CfbNXA
łȂnilԂ܂B
p̑啶Ə͋ʂ܂Bstring=̔΂̋@\łB


string<
[       type]: Function
[  arguments]: string< STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string= , string> , string<= , string>= , string-lessp , string-not-lessp , string-greaterp , string-not-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2rāu<v̏𖞂ΈvȂ̃Cf
bNXAłȂnilԂ܂B

gpF
  (string< "aa" "aa")
  => nil
  (string< "aa" "ab")
  => 1


string<=
[       type]: Function
[  arguments]: string<= STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string= , string< , string> , string>= , string-lessp , string-not-lessp , string-greaterp , string-not-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2rāu<=v̏𖞂ΈvȂ̃C
fbNXAłȂnilԂ܂B


string=
[       type]: Function
[  arguments]: string= STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: equal , string-equal , string/= , string> , string< , string<=
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2rētAłȂnilԂ܂B
p̑啶Ə͋ʂ܂B

gpF
  (string= "foo" "foo")
  => t
  (string= "foo" "Foo")
  => nil
  (string= "together" "frog" :start1 1 :end1 3 :start2 2)
  => t

QlF
  case-sensitive        case-insensitive
  ----                  ----
  string=               string-equal
  string/=              string-not-equal
  string<               string-lessp
  string>               string-greaterp
  string<=              string-not-greaterp
  string>=              string-not-lessp


string>
[       type]: Function
[  arguments]: string> STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string< , string<= , string>= , string-lessp , string-not-lessp , string-greaterp , string-not-greaterp
[   referred]: string=
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2rāu>v̏𖞂ΈvȂ̃Cf
bNXAłȂnilԂ܂B

gpF
  (string> "ac" "ab")
  => 1
  (string> "ac" "ac")
  => nil
  (string> "AC" "ab")
  => nil


string>=
[       type]: Function
[  arguments]: string>= STRING1 STRING2 &key :start1 :end1 :start2 :end2
[    package]: lisp
[    seealso]: string< , string> , string<= , string-lessp , string-not-lessp , string-greaterp , string-not-greaterp
[       file]: builtin.l
[    section]: 
[description]: 
STRING1STRING2rāu>=v̏𖞂ΈvȂ̃C
fbNXAłȂnilԂ܂B


stringp
[       type]: Function
[  arguments]: stringp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTstringȂtAȊOȂnilԂ܂B


sub-directory-p
[       type]: Function
[  arguments]: sub-directory-p DIRECTORY PARENT
[    package]: lisp
[    seealso]: path-equal
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
DIRECTORYPARENT̃TufBNgȂtAłȂnilԂ܂B

gpF 
  (sub-directory-p "c:/windows/system" "c:/windows")
  => t


sublis
[       type]: Function
[  arguments]: sublis ALIST TREE &key :test :test-not :key
[    package]: lisp
[    seealso]: subst , nsublis , nsubstitute
[   referred]: substitute
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE ̒ ALIST  :key Ƃ :test 𖞂̂ VALUE ɒuXgԂ܂B
 TREE ͕ۑ܂B

gpF
  ;;; a->1Ab->2ɕύX
  (sublis '((a . 1) (b . 2)) '(a b c))
  => (1 2 c)


subseq
[       type]: Function
[  arguments]: subseq SEQUENCE START &optional END
[    package]: lisp
[    seealso]: last , butlast , substring
[       file]: builtin.l
[    section]: V[PX
[description]: 
SEQUENCESTARTԖڂEND͍Ō܂ł̐VsequenceԂ܂B


subsetp
[       type]: Function
[  arguments]: subsetp LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: set-difference , intersection
[   referred]: set-exclusive-or , union
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 ̃TuZbgȂ tAłȂȂ nil Ԃ܂B

gp:
  (subsetp '(1 5 7) '(1 3 5 7 9))
  => t
  (subsetp '(1 5 8) '(1 3 5 7 9))
  => nil


subst
[       type]: Function
[  arguments]: subst NEW OLD TREE &key :test :test-not :key
[    package]: lisp
[    seealso]: sublis , nsubst , subst-if , subst-if-not , substitute
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE ̒ OLD  NEW ɒu TREE ̃Rs[Ԃ܂B
 TREE ͕ۑ܂B

gpF
  ;;; Kŵc[substĂ݂Ba͂̂܂
  (setq a '((1 2) ((1 3) (1 4))))       => ((1 2) ((1 3) (1 4)))
  (subst 5 1 a)                         => ((5 2) ((5 3) (5 4)))
  a                                     => ((1 2) ((1 3) (1 4)))


subst-if
[       type]: Function
[  arguments]: subst-if NEW TEST TREE &key :key
[    package]: lisp
[    seealso]: subst-if-not , subst , substitute-if
[   referred]: nsubst-if , nsubst-if-not
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE ̒ TEST 𖞂̂ NEW ɒûԂ܂B
 TREE ͕ۑ܂B

  NEW  : uvf
  TEST : u邩ǂ𔻒肷eXg
         non-nilԂu܂B
  TREE : Ώۂ̃c[

TESTɂTREE̕XgƗvfԂɈƂė^̂ŁAK[
̗vfȗΏۂƂ͂Ȃ܂BႦ΁AȊŌĂяo
܂B

  ;;; funcŔ肷ꍇ
  (subst-if 0 #'func '(1 2 3))

  ;;; funcɈƂė^l(1 2 3Ȃ)
  (1 2 3) 1 (2 3) 2 (3) 3 nil

̎gp̗lɎǑ^`FbNĉ܂B

gpF
  ;;; Kȃc[pӂāA̗vfȂ0ɒuB
  (setq a '((1 2) ((1 3) (1 (1 3)))))
  => ((1 2) ((1 3) (1 (1 3))))
  (subst-if 0 #'(lambda (x) (and (integerp x) (oddp x))) a)
  => ((0 2) ((0 0) (0 (0 0))))
  a
  => ((1 2) ((1 3) (1 (1 3))))


subst-if-not
[       type]: Function
[  arguments]: subst-if-not NEW TEST TREE &key :key
[    package]: lisp
[    seealso]: subst-if , subst , substitute-if-not
[       file]: builtin.l
[    section]: Xg
[description]: 
TREE̒TEST𖞂Ȃ̂NEWɒûԂ܂B
TREE͕ۑ܂B

  NEW  : uvf
  TEST : u邩ǂ𔻒肷eXg
         nilԂu܂B
  TREE : Ώۂ̃c[

TEST̈ɂĂsubst-ifQƂĉB

gpF
  ;;; Kȃc[pӂāAȊÔ̂0ɕϊB
  (setq a '((123 "abc") '(456 "123") (789 #\a)))
  => ((123 "abc") '(456 "123") (789 #\a))
  (subst-if-not 0 #'(lambda (x) (or (listp x) (integerp x))) a)
  => ((123 0) (0 (456 0)) (789 0))
  a
  => ((123 "abc") '(456 "123") (789 #\a))  


substitute
[       type]: Function
[  arguments]: substitute NEWITEM OLDITEM SEQUENCE &key :from-end :test :test-not :start :end :count :key
[    package]: lisp
[    seealso]: substitute-if , substitute-if-not , nsubstitute , subst , substitute-string , sublis
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCE ɑ΂ OLDITEM Ƃ :test 𖞑vf NEWITEM ɒu
V[PXԂ܂B SEQUENCE ͕ۑ܂A߂lƈꕔL
܂B

  :test     : eXgs2Zq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇSEQUENCE̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪Anon-nil ŖusB :count
              ^ꂽ݈̂ӖB


substitute-if
[       type]: Function
[  arguments]: substitute-if NEWITEM TEST SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: subst-if , substitute , substitute-if-not , nsubstitute-if
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCEɑ΂TEST𖞑vfNEWITEMɒuV[PXԂ܂B
 SEQUENCE ͕ۑ܂A߂lƈꕔL邩܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇSEQUENCE̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪Anon-nil ŖusB :count
              ^ꂽ݈̂ӖB


substitute-if-not
[       type]: Function
[  arguments]: substitute-if-not NEWITEM TEST SEQUENCE &key :from-end :start :end :count :key
[    package]: lisp
[    seealso]: subst-if-not , substitute , substitute-if , nsubstitute-if-not
[       file]: sequence.l
[    section]: V[PX
[description]: 
SEQUENCEɑ΂TEST𖞑ȂvfNEWITEMɒuV[PXԂ܂B
 SEQUENCE ͕ۑ܂A߂lƈꕔL邩܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇSEQUENCE̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪Anon-nil ŖusB :count
              ^ꂽ݈̂ӖB


substitute-key-definition
[       type]: Function
[  arguments]: substitute-key-definition OLDDEF NEWDEF &optional (KEYMAP *global-keymap*) (OKEYMAP KEYMAP)
[    package]: editor
[    seealso]: define-key
[       file]: keymap.l
[    section]: L[}bv
[description]: 
OKEYMAP ɂ OLDDEF 蓖ĂĂ邷ׂẴL[ɑ΂āA
KEYMAP ɂ NEWDEF 蓖Ă܂B

F
  ;;; text-mode ł̍s̈ړ𕨗sPʂɂ
  (substitute-key-definition 'next-virtual-line 'next-line
                             *text-mode-map* *global-keymap*)
  (substitute-key-definition 'previous-virtual-line 'previous-line
                             *text-mode-map* *global-keymap*)


substitute-string
[       type]: Function
[  arguments]: substitute-string STRING PATTERN REPLACEMENT &key :case-fold :start :end :skip :count
[    package]: editor
[    seealso]: replace-string , substitute , replace , quote-string
[   referred]: perform-replace , replace-buffer
[       file]: builtin.l
[    section]: 
[description]: 
񒆂̐K\p^[uĕԂ܂B

  :case-fold  : nil Ȃ啶ʂB
                :smart ȂAp^[ɑ啶ȂƂ̂݋ʂȂB
                ̑̏ꍇȂ啶ʂȂB                
  :start      : JnʒuBftHg 0 Ŕ񕉂̐
  :end        : IʒuBftHg nil ŁA nil ̏ꍇ͗̒
                w肵ꍇƓ
  :skip       : w肳ꂽ񐔃}b`܂ł͒usȂ
  :count      : uő̉

gpF
  ;;; uB
  (substitute-string "Hogehoge" "ho" "pa")
  => "Hogepage"

  ;;; 啶ʂuB
  (substitute-string "Hogehoge" "ho" "pa" :case-fold t)
  => "pagepage"

  ; K\E^̗p
  (substitute-string "abc123cdef" "[^0-9]*\\([0-9]+\\).*" "\\1 in \\&")
  =>"123 in abc123cdef"


substring
[       type]: Function
[  arguments]: substring STRING START &optional END
[    package]: lisp
[    seealso]: subseq
[   referred]: buffer-substring , copy-string
[       file]: builtin.l
[    section]: 
[description]: 
w肳ꂽ̕Ԃ܂B
START, END ɕ̐lw肷ƕ̍ŌォJEg܂B

݊F
  Common Lispɂ͂Ȃ(subseqقړ̋@\j
  muleB


subtypep
[       type]: Function
[  arguments]: subtypep TYPE1 TYPE2
[    package]: lisp
[    seealso]: deftype , typep , ^ꗗ
[       file]: typespec.l
[    section]: f[^^
[description]: 
^̌^̕^ǂׂđlŕԂ܂B
iڍוsj

  TYPE1 : ^w肵܂B
  TYPE2 : ^w肵܂B

  t   t         TYPE1͖mTYPE2̕^
  nil t         TYPE1͖mTYPE1̕^ł͂Ȃ
  nil nil       ֌W𔻒fłȂ

gpF
  ;;; Tu^Cvǂ𒲂ׂB
  (subtypep 'single-float 'number)
  => (single-float double-float long-float)
  (subtypep 'cons 'number)
  => nil


svref
[       type]: Accessor
[  arguments]: svref SIMPLE-VECTOR INDEX
[    package]: lisp
[    seealso]: aref , setf , vector
[   referred]: row-major-aref
[       file]: builtin.l
[    section]: z
[description]: 
aref ƓłA svref ̓xN^(ꎟz)݂̂ɃANZXł܂B
܂AxN^ hoge ƂA (svref hoge 2)  (aref hoge 2) ƓӖ
BA foo 2x2z̏ꍇ́A svref ŃANZX邱Ƃ͂ł܂B


switch-pseudo-frame
[       type]: Function
[  arguments]: switch-pseudo-frame NAME
[    package]: editor
[    seealso]: select-pseudo-frame , pseudo-frame-selector
[   referred]: next-pseudo-frame , other-pseudo-frame , previous-pseudo-frame
[       file]: pframe.l
[    section]: EBhE
[description]: 
ΘbIɃt[I܂B


switch-to-buffer
[       type]: Function
[  arguments]: switch-to-buffer BUFFER &optional NOWARN
[    package]: editor
[    seealso]: get-buffer-create , set-buffer , verify-visited-file-modtime , switch-to-buffer-other-window
[       file]: buffer.l
[    section]: obt@
[description]: 
w肳ꂽobt@ɈړAEBhEɈړ܂B [C-x b]
obt@݂Ȃ΃obt@쐬܂B̃obt@𑀍쒆̃E
BhEɕ\ƂȊÓAget-buffer-createinteractivełƌ
܂B

gpF
  ;;; *calc*낤ƂȂ낤*calc*ɈړB
  (switch-to-buffer "*calc*")
  => #<buffer: *calc*>


switch-to-buffer-other-window
[       type]: Function
[  arguments]: switch-to-buffer-other-window BUFFER &optional NOWARN
[    package]: editor
[    seealso]: switch-to-buffer
[       file]: buffer.l
[    section]: obt@
[description]: 
̃EBhEɈڂĂobt@؂ւ܂B[C-x 4 b]
EBhE1̎́AEBhE𕪊܂B

  BUFFER : ̃obt@ɃJgEBhE؂ւ܂B
  NOWARN : non-nilȂ΁Aw肵obt@̃AvP[VɂX
           VĂ邩̃`FbNs܂B


symbol-function
[       type]: Function
[  arguments]: symbol-function SYMBOL
[    package]: lisp
[    seealso]: symbol-value , function
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
V{ꂽ֐`Ԃ܂B
fletȂǂŒ`[J̊֐`͎QƂł܂B

  SYMBOL : ֐`擾V{

gpF
  ;;; ֐`̎擾
  (symbol-function 'foo)
  => ֐`Ă܂: foo
  (defun foo (x) (* x 2))
  => foo
  (symbol-function 'foo)
  => #<lexical-closure: foo>


symbol-name
[       type]: Function
[  arguments]: symbol-name SYMBOL
[    package]: lisp
[    seealso]: intern , string
[       file]: builtin.l
[    section]: V{
[description]: 
V{̖O󎚗p̕ƂĕԂ܂B

gpF
  ;;; V{xyzzy𕶎ɂĂ݂B
  (symbol-name 'xyzzy)
  => "xyzzy"


symbol-package
[       type]: Function
[  arguments]: symbol-package SYMBOL
[    package]: lisp
[    seealso]: make-symbol , gensym , intern
[       file]: builtin.l
[    section]: V{
[description]: 
V{pbP[WԂ܂B
make-symbol Ƃ gensym ŐꂽV{͂ǂ̃pbP[Wɂ܂B

gpF
  ;;; uninternedȃV{ƂłȂV{Ă݂B
  (setq foo 2)                          => foo
  (symbol-package 'foo)                 => #<package: user>
  
  (setq bar (make-symbol "bar"))        => #:bar
  (set bar 3)                           => 3
  (symbol-value bar)                    => 3
  (symbol-package bar)                  => nil


symbol-plist
[       type]: Function
[  arguments]: symbol-plist SYMBOL
[    package]: lisp
[    seealso]: get
[   referred]: getf
[       file]: builtin.l
[    section]: V{
[description]: 
V{̃vpeBXgԂB

gpF
  ;;; V{̃vpeBXgĂ݂B
  (symbol-plist 'xyzzy)         => nil
  (setf (get 'xyzzy 'foo) 1)    => 1
  (symbol-plist 'xyzzy)         => (foo 1)


symbol-value
[       type]: Function
[  arguments]: symbol-value SYMBOL
[    package]: lisp
[    seealso]: symbol-function , default-value , buffer-local-value
[   referred]: set
[       file]: builtin.l
[    section]: V{
[description]: 
V{ĂlԂ܂B
Ǐϐ̒l͎QƂł܂B

  SYMBOL : lԂV{

gpF
  ;;; foo ƂV{̒lԂĂ݂
  (set 'foo 3)          => 3
  (symbol-value 'foo)   => 3
  foo                   => 3
  ;;; Ǐϐ͎QƂłȂ
  (let ((foo 1))
    (symbol-value 'foo)) => 3


symbolp
[       type]: Function
[  arguments]: symbolp OBJECT
[    package]: lisp
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTsymbolȂtAȊOȂnilԂ܂B

  (symbolp x) == (typep x 'symbol)


syntax-c++-comment-p
[       type]: Function
[  arguments]: syntax-c++-comment-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-start-c++-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARC++X^C̃Rg̊JnƂċK肳Ă邩Ԃ܂B

  t     JnłB
  nil   JnłȂB


syntax-close-p
[       type]: Function
[  arguments]: syntax-close-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-match , syntax-open-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARʂȂǂ̏IƂċK肳Ă邩Ԃ܂B

  t     IłB
  nil   IłȂB


syntax-close-tag-p
[       type]: Function
[  arguments]: syntax-close-tag-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-close-tag
[   referred]: set-syntax-tag , syntax-open-tag-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHAR^ȌIƂċK肳Ă邩Ԃ܂B

  t     ^ȌIłB
  nil   ^ȌIłȂB


syntax-end-c++-comment-p
[       type]: Function
[  arguments]: syntax-end-c++-comment-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-end-c++-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARC++X^C̃Rg̏IƂċK肳Ă邩Ԃ܂B

  t     IłB
  nil   IłȂB


syntax-end-comment-p
[       type]: Function
[  arguments]: syntax-end-comment-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-end-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARRgIƂċK肳Ă邩Ԃ܂B

  t     RgIłB
  nil   RgIłȂB


syntax-end-multi-comment-1-p
[       type]: Function
[  arguments]: syntax-end-multi-comment-1-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-end-multi-comment , syntax-end-multi-comment-2-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARRgI̕1ڂƂċK肳Ă邩Ԃ܂B

  t     RgI1ڂłB
  nil   RgI1ڂłȂB


syntax-end-multi-comment-2-p
[       type]: Function
[  arguments]: syntax-end-multi-comment-2-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-end-multi-comment , syntax-end-multi-comment-1-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARRgI̕2ڂƂċK肳Ă邩Ԃ܂B

  t     RgI2ڂłB
  nil   RgI2ڂłȂB


syntax-escape-p
[       type]: Function
[  arguments]: syntax-escape-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-escape
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARGXP[vƂċK肳Ă邩Ԃ܂B

  t     GXP[vłB
  nil   GXP[vłȂB


syntax-junk-p
[       type]: Function
[  arguments]: syntax-junk-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-junk
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARS~ƂċK肳Ă邩Ԃ܂B

  t     S~łB
  nil   S~łȂB


syntax-math-p
[       type]: Function
[  arguments]: syntax-math-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-math
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHAR΂ɂȂ؂蕶ƂċK肳Ă邩Ԃ܂B

  t     ΂ɂȂ؂蕶łB
  nil   ΂ɂȂ؂蕶łȂB


syntax-open-p
[       type]: Function
[  arguments]: syntax-open-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-match , syntax-close-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARʂȂǂ̊JnƂċK肳Ă邩Ԃ܂B

  t     JnłB
  nil   JnłȂB


syntax-open-tag-p
[       type]: Function
[  arguments]: syntax-open-tag-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-tag , syntax-close-tag-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHAR^O̊JnƂċK肳Ă邩Ԃ܂B

  t     ^O̊JnłB
  nil   ^O̊JnłȂB


syntax-punctuation-p
[       type]: Function
[  arguments]: syntax-punctuation-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-punctuation
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARǓ_ƂċK肳Ă邩Ԃ܂B

  t     Ǔ_łB
  nil   Ǔ_łB


syntax-quote-p
[       type]: Function
[  arguments]: syntax-quote-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-quote
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARSYNTAX-TABLEquote(?)ƂċK肳Ă邩ۂԂ܂B

  t    CHARquotełB
  nil  CHARquotełȂB


syntax-start-column-comment-p
[       type]: Function
[  arguments]: syntax-start-column-comment-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-start-column-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
set-syntax-start-column-comment Ŏw肵ۂ𔻒肵܂B


syntax-start-comment-p
[       type]: Function
[  arguments]: syntax-start-comment-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-start-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARRgJnƂċK肳Ă邩Ԃ܂B

  t     RgJnłB
  nil   RgJnłȂB


syntax-start-multi-comment-1-p
[       type]: Function
[  arguments]: syntax-start-multi-comment-1-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-start-multi-comment , syntax-start-multi-comment-2-p
[   referred]: set-syntax-end-multi-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
RgJn̕1ڂƂċK肳Ă邩Ԃ܂B

  CHAR         : RgJn1ڂw肵܂B
  SYNTAX-TABLE : V^bNXe[uw肵܂Bw肵ȂƁAJ
                 gobt@ɂ悤ĂV^bNXe[ugp
                 ܂B

  t     RgJn1ڂłB
  nil   RgJn1ڂłȂB


syntax-start-multi-comment-2-p
[       type]: Function
[  arguments]: syntax-start-multi-comment-2-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-start-multi-comment , syntax-start-multi-comment-1-p
[   referred]: set-syntax-end-multi-comment
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARRgJn̕2ڂƂċK肳Ă邩Ԃ܂B

  t     RgJn2ڂłB
  nil   RgJn2ڂłȂB


syntax-string-p
[       type]: Function
[  arguments]: syntax-string-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-string
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARSYNTAX-TABLEŕ̋؂ƂċK肳Ă邩ۂԂ܂B

  t    CHAR͕̋؂蕶łB
  nil  CHAR͕̋؂蕶łȂB


syntax-symbol-p
[       type]: Function
[  arguments]: syntax-symbol-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-symbol
[       file]: builtin.l
[    section]: V^bNX
[description]: 
V{\镶ƂċK肳Ă邩Ԃ܂B
P\͏܂B

  CHAR : w肵܂B  

  t     V{\镶łB
  nil   V{\镶łȂB


syntax-symbol-prefix-p
[       type]: Function
[  arguments]: syntax-symbol-prefix-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-symbol-prefix
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARV{̑OuqƂċK肳Ă邩Ԃ܂B

  CHAR : w肵܂B  

  t     V{̑OuqłB
  nil   V{̑OuqłȂB


syntax-table
[       type]: Function
[  arguments]: syntax-table &optional BUFFER
[    package]: editor
[    seealso]: make-syntax-table , syntax-table-p , use-syntax-table , parse-point-syntax
[   referred]: set-syntax-comment-column
[       file]: builtin.l
[    section]: V^bNX
[description]: 
݂̃V^bNXe[uo܂B

gpF
  ;;; evalđ}
  (defun xmldoc-eval-and-insert ()
    (interactive "p")
    (let ((syntab (syntax-table)))  ;;݂xmldoc[hsyntax-tableo
      (let (from to col str start end)
        (cond ((selection-start-end (start end)
                 (setq from start to end)))
              (t
               ;;ꎞIlispɐ؂ւ
               (use-syntax-table ed::*lisp-mode-syntax-table*)
               (unwind-protect
                   (setq from (progn
                                (backward-sexp)
                                (point))
                         to (progn
                              (forward-sexp)
                              (point)))
                 ;; ܂ɖ߂
                 (use-syntax-table syntab))))


syntax-table-p
[       type]: Function
[  arguments]: syntax-table-p OBJECT
[    package]: editor
[    seealso]: make-syntax-table
[   referred]: syntax-table , use-syntax-table
[       file]: builtin.l
[    section]: V^bNX
[description]: 
w肳ăIuWFNgOBJECTV^bNXe[uۂԂ܂B

  t    V^bNXe[ułB
  nil  V^bNXe[ułȂB


syntax-whitespace-p
[       type]: Function
[  arguments]: syntax-whitespace-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-whitespace
[       file]: builtin.l
[    section]: V^bNX
[description]: 
CHARSYNTAX-TABLEwhitespaceƂċK肳Ă邩ۂԂ܂B

  t    CHARwhitespacełȂB
  nil  CHARwhitespacełB


syntax-word-p
[       type]: Function
[  arguments]: syntax-word-p CHAR &optional SYNTAX-TABLE
[    package]: editor
[    seealso]: set-syntax-word
[   referred]: word-char-p
[       file]: builtin.l
[    section]: V^bNX
[description]: 
P\镶ƂċK肳Ă邩Ԃ܂B

  CHAR : 肷镶w肵܂B

  t     P\镶łB
  nil   P\镶łȂB


t
[       type]: Variable
[    package]: lisp
[    seealso]: nil
[    section]: ϐƒ萔
[description]: 
^\萔łB


tab-bar-add-item
[       type]: Function
[  arguments]: tab-bar-add-item BAR ITEM STRING &optional TOOLTIP MENU &key :first :last :before :after
[    package]: editor
[    seealso]: tab-bar-delete-item , tab-bar-find-item , tab-bar-current-item , create-tab-bar
[   referred]: tab-bar-modify-item
[       file]: builtin.l
[    section]: j[
[description]: 
create-tab-barō쐬^uo[BARɃ^uǉ܂B^uʂ邽
߂ITEMƃ^u̕STRINGw肵܂Bʂ̃c[`bvTOOLTIPƁA
j[MENUw\łB


tab-bar-current-item
[       type]: Function
[  arguments]: tab-bar-current-item BAR
[    package]: editor
[    seealso]: tab-bar-delete-item , tab-bar-add-item
[   referred]: tab-bar-select-item
[       file]: builtin.l
[    section]: j[
[description]: 
I𒆂̃^ȕ񂪕Ԃ܂B^uЂƂꍇɂ́AnilԂ
܂BKA^uʂ邽߂̃V{A^u̕Ac[`bṽ
XgŕԂ܂Bc[`bvݒ肳ĂȂꍇɂ́AnilԂ
B

gpF
  (progn
    (defun a-func (a) (msgbox "~A ~A" a (type-of a)))
    (define-command-bar 'a-bar "a bar")
    (create-tab-bar 'a-bar 'a-func)
    (show-command-bar 'a-bar)
    (tab-bar-add-item 'a-bar '1st "- 1st -" "1st item")
    (tab-bar-add-item 'a-bar '2nd "- 2nd -" "2nd item"))
  => t
  (tab-bar-current-item 'a-bar)
  => (1st "- 1st -" "1st item")
  (progn
    (tab-bar-delete-item 'a-bar '1st)
    (tab-bar-delete-item 'a-bar '2nd)
    (delete-tool-bar 'a-bar)
    (delete-command-bar 'a-bar))
  => t


tab-bar-delete-item
[       type]: Function
[  arguments]: tab-bar-delete-item BAR ITEM
[    package]: editor
[    seealso]: tab-bar-add-item , create-tab-bar
[   referred]: tab-bar-current-item
[       file]: builtin.l
[    section]: j[
[description]: 
create-tab-barō쐬^uo[BAR^uITEM폜܂B폜^
uIԂł΁Ã^uIēCALLBACKs܂B


tab-bar-find-item
[       type]: Function
[  arguments]: tab-bar-find-item BAR ITEM
[    package]: editor
[    seealso]: create-tab-bar , tab-bar-list-items
[   referred]: tab-bar-add-item
[       file]: builtin.l
[    section]: j[
[description]: 
w肳ꂽ^uo[BAR^uITEM݂邩ۂԂ܂B

  t    ݂B
  nil  ݂ȂB

gpF
  (tab-bar-find-item 'a-bar '1st)
  => t
  (tab-bar-find-item 'a-bar '3rd)
  => nil


tab-bar-list-items
[       type]: Function
[  arguments]: tab-bar-list-items BAR
[    package]: editor
[    seealso]: tab-bar-find-item , create-tab-bar
[       file]: builtin.l
[    section]: j[
[description]: 
w肳ꂽ^uo[BAR̃^ũV{̃XgԂ܂B

gpF
  (tab-bar-list-items 'a-bar)
  => (1st 2nd)


tab-bar-modify-item
[       type]: Function
[  arguments]: tab-bar-modify-item BAR ITEM &optional STRING TOOLTIP MENU
[    package]: editor
[    seealso]: tab-bar-add-item
[   referred]: create-tab-bar
[       file]: builtin.l
[    section]: j[
[description]: 
w肳ꂽ^uo[BAR̃^uITEM̐ݒύX܂B

gpF
  (tab-bar-modify-item 'a-bar '1st "- first -")
  => t


tab-bar-select-item
[       type]: Function
[  arguments]: tab-bar-select-item BAR ITEM
[    package]: editor
[    seealso]: tab-bar-current-item
[   referred]: create-tab-bar
[       file]: builtin.l
[    section]: j[
[description]: 
w肳ꂽ^uo[BAR̃^uITEMIԂɂ܂BɃ^uo[ɐݒ
ꂽCALLBACKs܂B


tab-columns
[       type]: Function
[  arguments]: tab-columns &optional BUFFER
[    package]: editor
[    seealso]: set-tab-columns
[       file]: builtin.l
[    section]: eLXg
[description]: 
^uԂ܂B^uset-tab-columnsŐݒł܂B

  BUFFER : ^uԂobt@w肵܂B
           w肪Ȃ΃Jgobt@ΏۂƂȂ܂B


tabify
[       type]: Function
[  arguments]: tabify FROM TO
[    package]: editor
[    seealso]: untabify
[       file]: cmds.l
[    section]: eLXg
[description]: 
FROM  TO ̊Ԃɂ锼pXy[X\Ȍ^uŒu܂B


tagbody
[       type]: Special Form
[  arguments]: tagbody {TAG|STATEMENT}*
[    package]: lisp
[    seealso]: go
[   referred]: prog , prog*
[       file]: builtin.l
[    section]: \
[description]: 
labelWvłB
tagbody͔Cӂ̐tag(V{͐)statement(S)Ȃ
sɂtag͖statements܂B(go tag)]ꂽƂ
stag̏ꏊɈڂ܂Btagbody͏InilԂ܂B


tail-f
[       type]: Function
[  arguments]: tail-f FILENAME
[    package]: editor
[   referred]: *tail-f-mode-hook*
[       file]: tail-f.l
[    section]: t@CVXe
[description]: 
tail R}h -f IvV̂悤ɁAXVꑱ悤ȃt@CI
[܂œǂݍݑ悤Ƃ܂B


tailp
[       type]: Function
[  arguments]: tailp SUBLIST LIST
[    package]: lisp
[    seealso]: ldiff
[       file]: list.l
[    section]: Xg
[description]: 
SUBLISTLIST\Ăconsł邩ԂB

̓IɂLISTcdrĂʂSUBLIST
eqȂtłȂȂnilԂB


tan
[       type]: Function
[  arguments]: tan RADIANS
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
ڊ֐̒lԂ܂B


tanh
[       type]: Function
[  arguments]: tanh Z
[    package]: lisp
[       file]: number.l
[    section]: l
[description]: 
oȐڊ֐vZ܂B 


tenth
[       type]: Function
[  arguments]: tenth X
[    package]: lisp
[    seealso]: nth
[       file]: list.l
[    section]: Xg
[description]: 
list  10 Ԗڂ̗vfԂ܂B

  (tenth X) = (nth 9 X)

gpF
  (tenth '(1 2 3 4 5 6 7 8 9 0))
  => 0


terpri
[       type]: Function
[  arguments]: terpri &optional OUTPUT-STREAM
[    package]: lisp
[    seealso]: fresh-line
[       file]: builtin.l
[    section]: o
[description]: 
OUTPUT-STREAM ɉs (#\LFD) o͂ nil Ԃ܂B


third
[       type]: Function
[  arguments]: third X
[    package]: lisp
[    seealso]: caddr , nth
[       file]: list.l
[    section]: Xg
[description]: 
caddr ̕ʖłBS܂B


throw
[       type]: Special Form
[  arguments]: throw TAG RESULT
[    package]: lisp
[    seealso]: catch
[       file]: builtin.l
[    section]: \
[description]: 
catchŎw肳ꂽx܂ŁAǏEo܂B
OC++ƓłB

  C++  : try    throw
  Lisp : catch  throw

gpF
  ;;; test2ŗOotest1ŃLb`B
  (defun test1 (x)
    (catch 'label1
      (test2 x)))
  => test1
  (defun test2 (x)
    (if (zerop x)
        (throw 'label1 'division-by-zero)
        (/ 1 x)))
  => test2
  (test1 0)
  => division-by-zero

QlF
  G[֘A


title-bar-format
[       type]: Variable
[    package]: editor
[    seealso]: mode-line-format
[    section]: ϐƒ萔
[description]: 
^Cgo[̃tH[}bgݒ肵܂B
[hC̃tH[}bgƓlłB

gpF
  (setq title-bar-format "--%*- %b (%M) [%k:%l] %P %f")

p^F
  %*    ύX          : **
        ֎~          : %-
        ύXE֎~: %*
        ȊO          : --
  %#*   ύX: *
        ύXȂ: () 
  %r      : ()
        ֎~: % 
  %#r           : ()
        ֎~      : %
        sSobt@: # 
  %p    vO 
  %v    o[W 
  %h    zXg 
  %#h   @zXg 
  %b    obt@ 
  %f    File: t@C 
  %#f   t@C 
  %F    File: t@CBt@CȂ΃obt@ 
  %#F   t@CBt@CȂ΃obt@ 
  %M    [h(}Ci[[h܂) 
  %m    [h 
  %k    GR[fBO 
  %l    sR[h 
  %i    IMȄԁBmode-line-format̂݁B 
  %P    J[\ʒuBmode-line-format̂݁B


toggle-ime
[       type]: Function
[  arguments]: toggle-ime &optional ON-OR-OFF
[    package]: editor
[    seealso]: *ime-mode-hook* , get-ime-mode
[       file]: builtin.l
[    section]: L[}bv
[description]: 
IMEON/OFF𐧌䂵܂B
  non-nil  IMEONɂ
  nil      IMEOFFɂ
  ȗ   IMEgO


toggle-over
[       type]: Function
[  arguments]: toggle-over &optional (ARG () SV)
[    package]: editor
[    seealso]: overwrite-mode
[       file]: cmds.l
[    section]: [h
[description]: 
㏑p}Ci[[h𐧌䂵܂B [Insert]

  nilȊO  ㏑[hɂ
  nil      }[hɂ
  ȗ   [hgO


toggle-read-only
[       type]: Function
[  arguments]: toggle-read-only &optional (ARG () SV)
[    package]: editor
[    seealso]: buffer-read-only
[       file]: buffer.l
[    section]: obt@
[description]: 
obt@̏݋֎~gO܂B [C-x C-q]


toggle-session-auto-save
[       type]: Function
[  arguments]: toggle-session-auto-save &optional (ARG () SV)
[    package]: editor
[    seealso]: close-session , ed::*auto-save-session-file*
[       file]: session.l
[    section]: obt@
[description]: 
ZbV̎ۑtO (ed::*auto-save-session-file*) ؂ւ
܂B non-nil ̂Ƃ́AZbVIۂɎŃZbVt@
C㏑܂B

ARG ^ꂽƂ (SV  non-nil ̂Ƃ) 
  nil ܂͕̐ : nil ɂ
  ȊO           : t ɂ


toggle-trace-on-error
[       type]: Function
[  arguments]: toggle-trace-on-error &optional (ARG () SVAR)
[    package]: editor
[    seealso]: ed::toggle-mode
[       file]: misc.l
[    section]: G[
[description]: 
G[g[X邩ǂgO܂B
On ɂ鎞Ƀg[Xp̃obt@ *Trace Output* ΐV܂B

OuꍇAtoggle-mode Ɠ悤ȋ܂B


tool-bar-exist-p
[       type]: Function
[  arguments]: tool-bar-exist-p NAME
[    package]: editor
[       file]: builtin.l
[    section]: j[
[description]: 
w肳ꂽc[o[NAME݂邩ۂԂ܂B

  t    c[o[݂B
  nil  c[o[݂ȂB


tool-bar-info
[       type]: Function
[  arguments]: tool-bar-info NAME
[    package]: editor
[    seealso]: list-tool-bars
[       file]: builtin.l
[    section]: j[
[description]: 
w肵c[o[NAMȄ𑽒lŕԂ܂B

`F
  \ʒu  :top        㑤ɕ\
            :left       ɕ\
            :right      Eɕ\
            :bottom     ɕ\
            nil         \
  ʒu    ̈ʒuԂB
  cʒu    c̈ʒuԂB
        ^uo[̏ꍇɍEɕ\ꍇ̉ԂB
            c[o[̏ꍇnilԂB


track-popup-menu
[       type]: Function
[  arguments]: track-popup-menu MENU &optional ANY
[    package]: editor
[    seealso]: create-popup-menu , define-popup-menu , popup-string
[       file]: builtin.l
[    section]: j[
[description]: 
t[eBO|bvAbvj[\܂BIꂽR}
hs܂B}EX{^ĂȂꍇnilԂ܂B

  MENU : create-popup-menudefine-popup-menuō쐬ꂽ
         j[w肵܂B
  ANY  : ǂ̂悤Ƀ|bvAbv邩wł܂B
        :button1        }EẌʒuɃ|bvAbv
        :button2        }EẌʒuɃ|bvAbv
        LȊO        J[\̈ʒuɃ|bvAbv


transpose-chars
[       type]: Function
[  arguments]: transpose-chars &optional (ARG 1 F)
[    package]: editor
[    seealso]: transpose-region
[       file]: cmds.l
[    section]: eLXg
[description]: 
|CĝЂƂO̕A|Cg̈ʒu̕ƌ܂B [C-t]
|Cĝ͂ЂƂOɐi݂܂B


transpose-lines
[       type]: Function
[  arguments]: transpose-lines &optional (ARG 1)
[    package]: editor
[    seealso]: transpose-region
[       file]: cmds.l
[    section]: eLXg
[description]: 
J[\̂s̈O̍sƁA ARG s̍sƂꊷ܂B[C-x C-t]
 ARG  0 ̏ꍇɂ̓}[N̑O̍sƓꊷ܂B


transpose-paragraphs
[       type]: Function
[  arguments]: transpose-paragraphs &optional (ARG 1)
[    package]: editor
[    seealso]: transpose-region
[       file]: paragrph.l
[    section]: [W
[description]: 
i̒iƌ܂B


transpose-region
[       type]: Function
[  arguments]: transpose-region MOVER ARG
[    package]: editor
[    seealso]: transpose-chars , transpose-words , transpose-lines , transpose-sexps , transpose-paragraphs
[       file]: cmds.l
[    section]: eLXg
[description]: 
[Wꊷ܂Bꊷ郊[W MOVER  funcall 
肳܂B

gpF 
  (transpose-region 'forward-paragraph arg)


transpose-words
[       type]: Function
[  arguments]: transpose-words &optional (ARG 1)
[    package]: editor
[    seealso]: transpose-region
[       file]: cmds.l
[    section]: 
[description]: 
J[\ʒu̒P̒PƓꊷ܂B[ESC t]


trap-errors
[       type]: Macro
[  arguments]: trap-errors &body BODY
[    package]: editor
[    seealso]: handler-case , ignore-errors
[       file]: misc.l
[    section]: G[
[description]: 
BODY ŃG[Nꍇ͒fiquitjꂽꍇA
Lb` trap-errors ̊OɉełȂ悤ɂ܂B
handler-case ̊ȈՔłƂ܂B
ignore-errors ƈႢAG[\܂B

gp:
  ;; G[NƂ肠Lb`āǍ̏͑B
  (progn
    (trap-errors
      (/ 1 0))
    (msgbox "done."))


truename
[       type]: Function
[  arguments]: truename PATHNAME
[    package]: lisp
[    seealso]: get-short-path-name
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
΃pX΃pXɕς܂B

  PATHNAME : ϊpXw肵܂B

gpF
  ;;; ΃pXyѐ΃pXw肵ĕϊB
  (truename ".")
  => "C:/applications/xyzzy"
  (truename "C:/applications/xyzzy/")
  => "C:/applications/xyzzy"


truncate
[       type]: Function
[  arguments]: truncate NUMBER &optional DIVISOR
[    package]: lisp
[    seealso]: rem , floor , ceiling , round , ftruncate
[       file]: builtin.l
[    section]: l
[description]: 
NUMBER0̕Ɋۂ߂܂B

gpF
  (truncate 2.8)
  => 2
  (truncate -2.8)
  => -2
  (multiple-value-list (truncate 2.8))
  => (2 0.8)


two-way-stream-input-stream
[       type]: Function
[  arguments]: two-way-stream-input-stream TWO-WAY-STREAM
[    package]: lisp
[    seealso]: make-two-way-stream
[       file]: builtin.l
[    section]: o
[description]: 
make-two-way-stream ōꂽ TWO-WAY-STREAM ̓͌̃Xg[Ԃ܂B


two-way-stream-output-stream
[       type]: Function
[  arguments]: two-way-stream-output-stream TWO-WAY-STREAM
[    package]: lisp
[    seealso]: make-two-way-stream
[       file]: builtin.l
[    section]: o
[description]: 
make-two-way-stream ōꂽ TWO-WAY-STREAM ̏o͐̃Xg[Ԃ܂B


type-of
[       type]: Function
[  arguments]: type-of OBJECT
[    package]: lisp
[    seealso]: ^ꗗ
[   referred]: coerce , typep
[       file]: builtin.l
[    section]: f[^^
[description]: 
^ꂽIuWFNǧ^Ԃ܂B
(typep OBJECT (type-of OBJECT))͕KtɂȂ܂B

gpF
  ;;; ꂼ̌^𒲂ׂĂ݂B
  (type-of 1)
  => integer
  (type-of 2.2)
  => single-float
  (type-of #'car)
  => compiled-function


typep
[       type]: Function
[  arguments]: typep OBJECT TYPE
[    package]: lisp
[    seealso]: si:canonicalize-type , type-of , subtypep , deftype , ^ꗗ
[       file]: typespec.l
[    section]: f[^^
[description]: 
OBJECT  TYPE ̌^ł΁Anon-nil ȒlԂ܂B

TYPE ɗ^邱Ƃ̂łɂ͈ȉ̂悤Ȃ̂܂B

1. ʂ̌^ 
  builtin ֐icharacterpAlistp ȂǁjŔ肵܂B

  'atom                'null           'ed:buffer
  'base-character      'number         'ed:marker
  'bignum              'package        'ed:process
  'character           'random-state   'ed:regexp
  'compiled-function   'ratio          'ed:syntax-table
  'cons                'real           'ed:menu
  'fixnum              'readtable      'ed:dde-handle
  'function            'sequence       'ed:window
  'hash-table          'stream         'ed:oledata
  'keyword             'symbol
  'list

2. E^
  𖞂ꍇ non-nil ȒlԂ܂B

  '(satisfies FUNC)      OBJECT  FUNC  funcall ʂԂ
  '(member ELEMENTS)     OBJECT  ELEMENTS Ɋ܂܂
  '(eql OBJ)             OBJECT  OBJ ɓ
  '(not TYPE1)           OBJECT  TYPE2 ̌^łȂ
  '(and TYPE1 TYPE2 ...) OBJECT  TYPE1, TYPE2, ... ׂĂ̌^ł
  '(or TYPE1 TYPE2 ...)  OBJECT  TYPE1, TYPE2, ... ꂩ̌^ł
  't                     ɐ^
  'nil                   ɋU

3. 
  'standard-char         ̂ standard-char-p Ȃ
  'extended-char (*)      nil Ԃiextended-char ݂͑ȂHj

4. l
  ͈͂wł܂Bȗ邱Ƃ\B
  MIN  MAX ɁAl̑ * ^ƁA
  ijw肵ȂƂ݂Ȃ܂B

  '(integer MIN MAX)
  '(float MIN MAX)
  '(rational MIN MAX)
  '(short-float MIN MAX)
  '(single-float MIN MAX)
  '(double-float MIN MAX)
  '(long-float MIN MAX)

  '(complex TYPE1)      integer ^Afloat ^Ȃǂŋʉ\B͈͎w͂łȂB

5. ꎟz
  wł܂B
  ɂ͐l * w肵܂Bȗ\B

  '(simple-vector LENGTH)
  '(simple-string LENGTH)
  '(string LENGTH)
  
  '(vector TYPE1 LENGTH)       TYPE1  tiʂ̃xN^j܂ characterij
  
6. ꎟȏ̔z
  '(simple-array TYPE1 DIM)    TYPE1  tiʂ̃xN^j܂ characterij
  '(array TYPE1 DIM)           DIM ͎

  '(simple-array TYPE1 (DIMS)) TYPE1  tiʂ̃xN^j܂ characterij
  '(array TYPE1 (DIMS))        DIMS ͊ẽTCYiƂ 2x3 Ȃ (2 3) j

7. defstruct Œ`ꂽ\

gp:
  ;; ʂ̌^
  (typep #\a 'character)
  => t
  (typep (selected-buffer) 'buffer)
  => t

  ;; ^
  (typep 3 '(satisfies oddp))       ; i֐ oddp ɂ锻j
  => t
  (typep 'b '(member a b c))        ; a b c XgƂĂ܂Ƃ߂
  => (b c)
  (typep 3 '(and atom number))      ; atom  number
  => t
  (typep 3 '(and atom number list)) ; atom  number  list
  => nil
  (typep 3 '(or atom number list))  ; atom ܂ number ܂ list
  => t

  ;; l
  (typep 3 'integer)                ; ͈͎w肵ȂȂ烊XgɂKvȂ
  => t
  (typep 3 '(integer 1 5))
  => t
  (typep x '(integer * 5))
  => t
  (typep x '(integer 5 *))
  => nil
  
  (typep #C(1 2) 'complex)
  => t
  (typep #C(1 2) '(complex float))
  => nil

  ;; ꎟz
  (typep #(1 2 3) '(simple-vector 3))
  => t
  (typep #(1 2 3) '(vector t 3))
  => t
  (typep "abc" '(vector character 3))
  => t

  ;; ꎟȏ̔z
  (setf a (make-array '(3 4)))
  => #2A((nil nil nil nil) (nil nil nil nil) (nil nil nil nil))
  (typep a '(array t *))     ; w肵Ȃ
  => t
  (typep a '(array t 2))     ; 2 z
  => t
  (typep a '(array t (3 4))) ; TCYv
  => t
  (typep a '(array t (* 4))) ; TCŸꕔw肷邱Ƃ\
  => t

  ;; \
  (typep (selected-pseudo-frame) 'ed::pseudo-frame)
  => t


undefine-key
[       type]: Function
[  arguments]: undefine-key KEYMAP KEY
[    package]: editor
[    seealso]: define-key
[       file]: keymap.l
[    section]: L[}bv
[description]: 
L[}bṽL[̊蓖Ă܂B

  KEYMAP : L[}bv
  KEY    : 폜L[

gpF
  ;;; C-lfiler-reloadɊ蓖ĂāAĂ݂
  (define-key filer-keymap #\C-l 'filer-reload)
  => t
  (undefine-key filer-keymap #\C-l)
  => t


undefined
[       type]: Function
[  arguments]: undefined
[    package]: editor
[    seealso]: ding
[   referred]: global-set-key
[       file]: cmds.l
[    section]: ̑
[description]: 
x炵܂B ding  interactive łłB

L[ɃR}h蓖ĂĂȂƂ\̂Ɏg邱Ƃ悤łB


undo
[       type]: Function
[  arguments]: undo
[    package]: editor
[    seealso]: buffer-can-undo-p , undo-boundary , clear-undo-boundary , kept-undo-information , redo , last-modified-point , *move-forward-after-undo-deletion*
[   referred]: *dabbrevs-no-undo*
[       file]: builtin.l
[    section]: obt@
[description]: 
Ȏ܂B[End], [C-\] 
UNDO̒߂̋E܂Ŗ߂܂B


undo-boundary
[       type]: Function
[  arguments]: undo-boundary
[    package]: editor
[    seealso]: clear-undo-boundary , undo
[   referred]: kept-undo-information
[       file]: builtin.l
[    section]: obt@
[description]: 
UNDOɋEݒ肵܂B
ȌundosƁA̋E܂Ŗ߂܂B


unexport
[       type]: Function
[  arguments]: unexport SYMBOLS &optional PACKAGE
[    package]: lisp
[    seealso]: export , pbP[W
[       file]: builtin.l
[    section]: pbP[W
[description]: 
V{̃Xgw肵āȂSẴV{pbP[W̊OQ
łȂ悤ɂ܂B

  ;; find-file  editor pbP[W̊OV{
  (find-symbol "find-file" "editor")
  =>find-file
    :external

  ;;  editor pbP[W use Ă user pbP[WQƂł
  (find-symbol "find-file" "user")
  =>find-file
    :inherited

  ;; OQƂłȂ
  (unepxport 'find-file "editor")
  =>t

  ;; V{ɂȂ
  (find-symbol "find-file" "editor")
  =>editor::find-file
    :internal

  ;; user pbP[WQƂłȂȂ
  (find-symbol "find-file" "user")
  =>nil
    nil

  ;; ɖ߂
  (export 'ed::find-file "editor")
  =>t


unicode-char
[       type]: Function
[  arguments]: unicode-char CODE
[    package]: editor
[    seealso]: char-unicode , code-char , *unicode-to-half-width*
[   referred]: char-code
[       file]: builtin.l
[    section]: 
[description]: 
UNICODẼR[hlɑΉԂ܂B

gpF
  ;;; UNICODE當oĂ݂B
  (unicode-char 28450)
  => #\


unintern
[       type]: Function
[  arguments]: unintern SYMBOL &optional PACKAGE
[    package]: lisp
[    seealso]: intern
[   referred]: gensym
[       file]: builtin.l
[    section]: pbP[W
[description]: 
pbP[WɃV{΍폜tAȂnilԂ܂B


uninterned
[       type]: Misc
[    seealso]: make-symbol , gensym
[   referred]: copy-symbol
[    section]: pbP[W
[description]: 
uninterned Ƃ intern ĂȂԂ\܂B
Ȃ킿ǂ̃pbP[WɂĂȂԂłB

gpF
  ;;; make-symbolŃpbP[WɑȂV{Ă݂B
  (setq a (make-symbol "foo"))  => #:foo
  (symbol-package a)            => nil


union
[       type]: Function
[  arguments]: union LIST1 LIST2 &rest REST &key :test :test-not :key
[    package]: lisp
[    seealso]: merge , nunion , intersection , set-difference , set-exclusive-or , ldiff , subsetp
[       file]: list.l
[    section]: Xg
[description]: 
LIST1  LIST2 𕹂XgĕԂ܂B
nunion ƈႢ LIST1 ͕ۑ܂B

gp:
  (union '(1 3 5 7 9) '(2 3 5 7 11))
  => (1 9 2 3 5 7 11)


universal-argument
[       type]: Function
[  arguments]: universal-argument RAW &optional ARG
[    package]: editor
[    seealso]: digit-argument , negative-argument , *prefix-args* , *prefix-value*
[       file]: cmds.l
[    section]: ֐
[description]: 
ɑR}hɑOuƂ 'universal-argument n܂B[C-u]

'universal-agument 𐔒lƂďꍇ 4 Ɖ߂܂B


unless
[       type]: Macro
[  arguments]: unless TEST &body BODY
[    package]: lisp
[    seealso]: when
[       file]: evalmacs.l
[    section]: \
[description]: 
ȂꍇɎs܂Bwhen̋tłB

  (unless   { ....)


unread-char
[       type]: Function
[  arguments]: unread-char CHARACTER &optional INPUT-STREAM
[    package]: lisp
[       file]: builtin.l
[    section]: o
[description]: 
̓Xg[Ɉꕶ߂܂B

  CHARACTER    : ̓Xg[ɖ߂
  INPUT-STREAM : ̓Xg[


unregister-history-variable
[       type]: Function
[  arguments]: unregister-history-variable VAR
[    package]: editor
[    seealso]: define-history-variable , register-history-variable
[       file]: history.l
[    section]: ϐƒ萔
[description]: 
ϐqXgϐ̓o^폜܂B


unset-marker
[       type]: Function
[  arguments]: unset-marker MARKER
[    package]: editor
[    seealso]: set-marker , delete-marker
[       file]: builtin.l
[    section]: |WV
[description]: 
}[J[̃|WV܂B
IuWFNg̓}[J[ƂĎc܂B

gpF
  (unset-marker m)
  => t
  m
  => #<marker: *scratch*: ->


unset-minor-mode-map
[       type]: Function
[  arguments]: unset-minor-mode-map KEYMAP &optional BUFFER
[    package]: editor
[    seealso]: set-minor-mode-map
[       file]: builtin.l
[    section]: [h
[description]: 
}Ci[[hp̃L[}bv܂B


unshift-region
[       type]: Function
[  arguments]: unshift-region START END &optional (COLUMN (TAB-COLUMNS (SELECTED-BUFFER)))
[    package]: editor
[    seealso]: shift-region
[       file]: region.l
[    section]: [W
[description]: 
STARTENDs͈̔͂COLUMNCfg߂܂B


untabify
[       type]: Function
[  arguments]: untabify FROM TO
[    package]: editor
[    seealso]: tabify
[   referred]: backward-delete-char-untabify
[       file]: cmds.l
[    section]: eLXg
[description]: 
FROM  TO ̊Ԃɂ^uKȐ̔pXy[XŒu܂B


unuse-package
[       type]: Function
[  arguments]: unuse-package PACKAGES-TO-UNUSE &optional PACKAGE
[    package]: lisp
[    seealso]: use-package
[       file]: builtin.l
[    section]: pbP[W
[description]: 
pbP[Wʂ̃pbP[WgpȂ悤ɂ܂B

gpF
  ;;; gpcalc.lQ
  (unuse-package "lisp" *calc-package*)
  => t


unwind-protect
[       type]: Special Form
[  arguments]: unwind-protect PROTECTED-FORM {CLEANUP-FORM}*
[    package]: lisp
[    seealso]: handler-case , ignore-errors
[   referred]: error
[       file]: builtin.l
[    section]: \
[description]: 
PROTECTED-FORM ɏI͗OĂiAُ킸j
CLEANUP-FORM s܂B

gpF
  ;;; [ZNĂ CLEANUP-FORM sB
  (progn
    (msgbox "vZO")
    (unwind-protect (/ 1 0)
      (msgbox "vZ")))
  => 0ŏZ܂: /: (1 0)


up-list
[       type]: Function
[  arguments]: up-list &optional ARG NO-ERRORS
[    package]: editor
[    seealso]: forward-sexp , forward-list , down-list
[       file]: builtin.l
[    section]: |WV
[description]: 
J[\ ARG O̊ʂ̌Ɉڂ܂B

  (setq lst '(a b c)) ; 
               ^
  (setq lst '(a b c)) ; 
                    ^

ARG ̏ꍇɂ́AO̊̕ʂֈړ܂B

  (setq lst '(a b c)) ; 
               ^
  (setq lst '(a b c)) ; 
             ^

OɊʂȂꍇA
NO-ERRORS  nil ̏ꍇɂ̓G[A t ̏ꍇɂ nil Ԃ܂B


upcase-region
[       type]: Function
[  arguments]: upcase-region FROM TO
[    package]: editor
[    seealso]: upcase-word , capitalize-region , downcase-region
[       file]: builtin.l
[    section]: [W
[description]: 
[W̒P啶ɂ܂B[C-x C-u]


upcase-word
[       type]: Function
[  arguments]: upcase-word &optional (ARG 1)
[    package]: editor
[    seealso]: downcase-word , capitalize-word , upcase-region , upcase-selection , string-upcase
[       file]: cmds.l
[    section]: 
[description]: 
J[\ʒuP̖܂ł啶ɕϊ܂B[ESC u]


update-mode-line
[       type]: Function
[  arguments]: update-mode-line &optional BUFFER
[    package]: editor
[    seealso]: mode-line-format
[       file]: builtin.l
[    section]: ̑
[description]: 
[hsXV܂Bmode-line-format̕ύXȂǂsꍇɁA₩
[hsɔfꍇɎs܂B


upper-case-p
[       type]: Function
[  arguments]: upper-case-p CHAR
[    package]: lisp
[    seealso]: lower-case-p , both-case-p , char-upcase
[       file]: builtin.l
[    section]: 
[description]: 
CHAR 啶Ȃ t AłȂ nil Ԃ܂B

gpF  
  (upper-case-p #\A)
  => t
  (upper-case-p #\a)
  => nil
  (upper-case-p #\RET)
  => nil


use-keymap
[       type]: Function
[  arguments]: use-keymap KEYMAP &optional BUFFER
[    package]: editor
[    seealso]: make-keymap , define-key
[       file]: builtin.l
[    section]: L[}bv
[description]: 
obt@gpL[}bvݒ肵܂B

  KEYMAP : gpL[}bvw肵܂B
  BUFFER : obt@w肵܂Bȗ̓Jgobt@ɓKp܂B

gpF
  ;;; lispmode.l
  (defun lisp-mode ()
    (interactive)
    (kill-all-local-variables)
    (setq buffer-mode 'lisp-mode)
    (setq mode-name "Lisp")
    (use-keymap *lisp-mode-map*)
    ...
    (run-hooks '*lisp-mode-hook*))


use-local-menu
[       type]: Function
[  arguments]: use-local-menu MENU
[    package]: editor
[    seealso]: set-menu , current-menu , define-menu
[   referred]: create-menu
[       file]: builtin.l
[    section]: j[
[description]: 
Jgobt@Ƀ[Jȃj[ݒ肵܂B

  MENU : obt@Ƀ[Jȃj[w肵܂Bnilݒ肷ƃ[J
         ȃj[͉AftHg̃j[gp܂B


use-package
[       type]: Function
[  arguments]: use-package PACKAGES-TO-USE &optional PACKAGE
[    package]: lisp
[    seealso]: export , defpackage , pbP[W
[   referred]: in-package , package-use-list , package-used-by-list , unuse-package
[       file]: builtin.l
[    section]: pbP[W
[description]: 
w肳ꂽpbP[Wiȗꂽꍇ̓Jg̃pbP[Wjg
p鑼̃pbP[Wݒ肵܂B


use-syntax-table
[       type]: Function
[  arguments]: use-syntax-table SYNTAX-TABLE &optional BUFFER (INVALIDATE-P T)
[    package]: editor
[    seealso]: syntax-table-p , syntax-table
[   referred]: make-syntax-table
[       file]: builtin.l
[    section]: V^bNX
[description]: 
obt@ŎgpV^bNXe[uݒ肵܂B

gpF
  ;;; lispmode.l̗
  (use-syntax-table *lisp-mode-syntax-table*)
  => t


user-config-path
[       type]: Function
[  arguments]: user-config-path
[    package]: editor
[    seealso]: user-homedir-pathname , si:system-root
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
[Uݒi[ĂfBNgԂ܂B
_CAOł̋Kli[fBNgłB

NIvV -config Ŏw肵CXYZZYCONFIGPATH
Ŏw\łBw肳ꂽꍇCNIvV
D悳܂B

gpF
  (user-config-path)
  =>"H:/xyzzy/usr/Administrator/w2k/"


user-homedir-pathname
[       type]: Function
[  arguments]: user-homedir-pathname
[    package]: lisp
[    seealso]: si:system-root , user-config-path
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
[U[̃z[fBNgԂ܂B

find-fileƂ"~/"ŎQƉ\ȃfBNgłB
NɁÃfBNgɊi[Ă.xyzzyǂݍ݂܂B
PC𕡐lŎgpĂAlbg[NLꂽtH_
xyzzyi[ꍇɂ́A[UɃz[fBNg̐ݒ肵
.xyzzy؂ւ邱Ƃł܂B

[Ũz[fBNǵAȉ̏ԂŌ肳܂B

  1)init@C[init]homeDir
  2)ϐ XYZZYHOME
  3)ϐ HOME
  4)ϐ HOMEDRIVE + HOMEPATH
  5)init@C[init]logDir
  6)xyzzy.exepath

gpF
  (user-homedir-pathname)
  => "C:/HOME/"


user-name
[       type]: Function
[  arguments]: user-name
[    package]: editor
[    seealso]: machine-name , si:getenv
[       file]: builtin.l
[    section]: VXe
[description]: 
Windows̃OI[U[Ԃ܂B


uudecode-region
[       type]: Function
[  arguments]: uudecode-region FROM TO
[    package]: editor
[    seealso]: si:uudecode , uudecode-region-to-file
[       file]: encdec.l
[    section]: [W
[description]: 
[Wuudecode܂B


uudecode-region-to-file
[       type]: Function
[  arguments]: uudecode-region-to-file FILENAME FROM TO
[    package]: editor
[    seealso]: si:uudecode , uudecode-region
[       file]: encdec.l
[    section]: [W
[description]: 
[Wuudecodeăt@Cɕۑ܂B


valid-path-p
[       type]: Function
[  arguments]: valid-path-p PATHNAME
[    package]: lisp
[    seealso]: check-valid-pathname , file-exist-p
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
pXLǂ`FbN܂B

  PATHNAME : Lǂ`FbNpX

ŁuLȃpXvƂ̂́AŏIIȃt@CfBNg݂
Ƃŵł͂ȂAřoH݂邱Ƃw܂Bt@Cw
Ăꍇɂ́Ãt@Ĉ̗L͊֌W܂B̃t@C
ɎfBNgSđ݂Ă邱ƂLۂɊւ܂B

gpF
  (valid-path-p "foo/bar/zzz.txt")
  =>nil
  (valid-path-p "/autoexec.bat")
  =>t


values
[       type]: Function
[  arguments]: values &rest ARGS
[    package]: lisp
[    seealso]: values-list , multiple-value-bind , multiple-value-list , multiple-value-setq
[   referred]: multiple-value-call , multiple-value-prog1
[       file]: evalmacs.l
[    section]: ϐƒ萔
[description]: 
lŒlԂ܂B

Cł͊֐1̒lԂƂł܂񂪁ACommon Lispł͕
lԂł܂iXgƂ͈Ⴂ܂jB𑽒li֐jƌĂт܂B
̒lԂ́A (values l1 l2 ..)Ƃ\g܂B

l֐Ăяoꍇɂ́A̖߂l󂯎悤 
multiple-value-bind ܂ multiple-value-listgĎ󂯎܂B

݊F
  Common Lispxyzzyɂ͂B
  muleɂ͂ȂB


values-list
[       type]: Function
[  arguments]: values-list LIST
[    package]: lisp
[    seealso]: values
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
w肳ꂽXg𑽒lƂĕԂ܂B

  (values-list '(a b c)) == (values a b c)
  (values-list list) == (apply #'values list)


vconcat
[       type]: Function
[  arguments]: vconcat &rest SEQ
[    package]: editor
[    seealso]: concatenate
[       file]: misc.l
[    section]: z
[description]: 
xN^A܂B

gp:
  (vconcat #(1 3) #(2 5 7))
  => #(1 3 2 5 7)


vector
[       type]: Function
[  arguments]: vector &rest LIST
[    package]: lisp
[    seealso]: svref , aref , setf , length , vector-pop , vector-push , vector-push-extend , vectorp , fill-pointer , make-vector , make-array
[       file]: array.l
[    section]: z
[description]: 
vf LIST ȂxN^܂B

  (setf v (vector 1 2 "oop"))
  =>#(1 2 "oop")

xN^̊evfɃANZX邽߂ɂ́Asvref(邢aref)g܂B


vector-pop
[       type]: Function
[  arguments]: vector-pop VECTOR
[    package]: lisp
[    seealso]: fill-pointer , vector-push
[   referred]: vector
[       file]: builtin.l
[    section]: z
[description]: 
xN^iꎟzj VECTOR ̃tB|C^̈ʒu̗vf菜A
̗vfԂ܂B

VECTOR ̓tB|C^ĂxN^łKv܂B

gp:
  ;; tB|C^Ȃ
  (setf x (make-array 5 :initial-contents '(a b c d e)))
  => #(a b c d e)
  (vector-pop x)
  => G[

  ;; tB|C^
  (setf x (make-array 5 :initial-contents '(a b c d e) :fill-pointer t))
  => #(a b c d e)
  (vector-pop x)
  => e
  x
  => #(a b c d)


vector-push
[       type]: Function
[  arguments]: vector-push NEW-ELEMENT VECTOR
[    package]: lisp
[    seealso]: fill-pointer , vector-pop , vector-push-extend
[   referred]: vector
[       file]: builtin.l
[    section]: z
[description]: 
xN^iꎟzj VECTOR ̃tB|C^̎̈ʒu
Vvf NEW-ELEMENT ǉ܂B

VECTOR ̓tB|C^ĂxN^łKv܂B
tB|C^ VECTOR ̍ŌɒBĂꍇɂ͉ nil Ԃ܂B

gp:
  ;; tB|C^xN^̒Ɉv
  (setf x (make-vector 5 :initial-contents '(a b c d e) :fill-pointer t))
  => #(a b c d e)
  (fill-pointer x)
  => 5
  (vector-push 'xyz x)
  => nil
  x
  =>#(a b c d e)

  ;; tB|C^xN^̒菬
  (setf x (make-vector 5 :initial-contents '(a b c d e) :fill-pointer 3))
  => #(a b c)
  (fill-pointer x)
  => 3
  (vector-push 'xyz x)
  => 3
  x
  => #(a b c xyz)


vector-push-extend
[       type]: Function
[  arguments]: vector-push-extend NEW-ELEMENT VECTOR &optional EXTENSION
[    package]: lisp
[    seealso]: vector-push , adjustable-array-p , fill-pointer , vector
[       file]: builtin.l
[    section]: z
[description]: 
xN^ VECTOR ɐVvfǉ܂BȂΊg܂B
VECTOR ̓tB|C^AAWX^uȃxN^łKv܂B

  NEW-ELEMENTFVvf 
  VECTOR     FǉxN^
  EXTENSION  Fg鎞̃TCYʁB
               ftHgł 64 ܂B

gpF
  ;;; vfƂ钷10̃xN^쐬l߂B
  (setq vec (make-vector 10 :element-type 'character
                            :fill-pointer 0 :adjustable t))
  => ""
  (vector-push-extend #\a vec)  => 0
  vec                           => "a"
  (vector-push-extend #\b vec)  => 1
  vec                           => "ab"

  ;;; vfƂ钷10̃xN^쐬l߂B
  (setq s (make-vector 10 :element-type 'character
                          :fill-pointer 0 :adjustable t))
  => ""
  (dotimes (i 20 s)
    (vector-push-extend (code-char (+ 64 i)) s)
    (vector-push-extend (code-char (+ 64 i)) s)
    (vector-push-extend (code-char (+ 64 i)) s))
  => "@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSS"


vectorp
[       type]: Function
[  arguments]: vectorp OBJECT
[    package]: lisp
[    seealso]: simple-vector-p , vector
[       file]: builtin.l
[    section]: f[^^
[description]: 
OBJECTvectorȂtAȊOȂnilԂ܂B


verify-visited-file-modtime
[       type]: Function
[  arguments]: verify-visited-file-modtime &optional BUFFER
[    package]: editor
[    seealso]: verify-buffers-file-modtime , switch-to-buffer , find-file-verify , clear-visited-file-modtime , update-visited-file-modtime
[       file]: builtin.l
[    section]: obt@
[description]: 
obt@t@CɊ֘AtĂȂA̓obt@ƂɊ֘At
ꂽt@CƂ̍XVԂvĂ t Ԃ܂Bobt@Ƃ
Ɋ֘Atꂽt@CƂ̍XVԂvĂȂA܂葼̃v
ZXɂăt@CύXꂽȂǂ nil Ԃ܂B

[       type]: BufferLocal
[    package]: editor
[    seealso]: verify-buffers-file-modtime , switch-to-buffer
[       file]: buffer.l
[    section]: obt@
[description]: 
activate ̃obt@̍ŏIXV`FbN𐧌䂵܂B
  :auto    XVĂΎIɓǂݒ
  non-nil  `FbN
  nil      `FbNȂ


version-up-xyzzy
[       type]: Function
[  arguments]: version-up-xyzzy &rest ARGS
[    package]: editor
[    seealso]: dump-xyzzy
[       file]: verup.l
[    section]: VXe
[description]: 
T䂳񂪔zzĂxyzzỹA[JCut@CxyzzyCXg[Ă
fBNgɓWJ܂B
ʓrA_vt@C̍č쐬Kv܂B


view-register
[       type]: Function
[  arguments]: view-register R
[    package]: editor
[   referred]: ed::get-register , ed::set-register
[       file]: register.l
[    section]: ̑
[description]: 
WX^ R ̒gobt@ *output* ɕ\܂B


virtual-bolp
[       type]: Function
[  arguments]: virtual-bolp
[    package]: editor
[    seealso]: virtual-eolp
[       file]: builtin.l
[    section]: |WV
[description]: 
zs̍sɂ邩Ԃ܂B
obt@s܂Ԃĕ\ĂꍇɗLłB

  t     zs̍sɂ
  nil   zs̍sɂȂ


virtual-eolp
[       type]: Function
[  arguments]: virtual-eolp
[    package]: editor
[    seealso]: virtual-bolp
[       file]: builtin.l
[    section]: |WV
[description]: 
zs̍sɂ邩Ԃ܂B
obt@s܂Ԃĕ\ĂꍇɗLłB

  t     zs̍sɂ
  nil   zs̍sɂȂ


what-cursor-position
[       type]: Function
[  arguments]: what-cursor-position
[    package]: editor
[    seealso]: iso-char-code , point , current-column , *status-bar-format*
[   referred]: goto-char
[       file]: cmds.l
[    section]: |WV
[description]: 
J[\ʒȕXe[^Xo[ɕ\܂B[C-x =]
J[\ʒu̓̕R[hlAUNICODElA
J[\ʒũobt@ɂʒuA
Ȃǂ\܂B

gp:
  "w"̈ʒuŏ
  Char: w (0x77 / U+0077 / 0x77[us-ascii])  point=46 of 518(8%)  column 7

  "J"̈ʒuŏ
  Char: J (0x834a / U+30ab / 0x252b[jisx0208])  point=152 of 395(38%)  column 0


when
[       type]: Macro
[  arguments]: when TEST &body BODY
[    package]: lisp
[   referred]: unless
[       file]: evalmacs.l
[    section]: \
[description]: 
nilłȂ΃tH[AĎs܂B

  TEST : 
  BODY : nilłȂꍇɎstH[

when̓}NłBȉ̗lɓWJ܂B

 (when exp1 exp2 exp3 ...)
 = (if exp1
      (progn exp2
             exp3
             ...))


while
[       type]: Macro
[  arguments]: while TEST &body BODY
[    package]: lisp
[       file]: evalmacs.l
[    section]: \
[description]: 
߂ԁABODYJԂĎs܂B
BODY̎s̓rwhile𔲂ɂ́Areturng܂B

  (while  {)

gpF
  ;;; mFsꍇ
  (while (yes-or-no-p "sɈړ܂H")
    (forward-line)
    (reverse-region (progn (goto-bol) (point))
                    (progn (goto-eol) (point)) t)
    (refresh-screen))
  => nil


widen
[       type]: Function
[  arguments]: widen
[    package]: editor
[    seealso]: narrow-to-region
[       file]: builtin.l
[    section]: |WV
[description]: 
narrow-to-regionŐꂽ̈ɖ߂܂B[C-x w]


wild-pathname-p
[       type]: Function
[  arguments]: wild-pathname-p PATHNAME
[    package]: lisp
[    seealso]: *brackets-is-wildcard-character* , pathname-match-p
[       file]: builtin.l
[    section]: ϐƒ萔
[description]: 
ChJ[hw肳ꂽpXǂԂ܂B

  t     ChJ[hw肳ꂽpXłB
  nil   ChJ[hw肳Ă܂B

gpF
  ;;; ChJ[hǂ𒲂ׂĂ݂B
  (wild-pathname-p "site-lisp/*.l")
  => t


window-buffer
[       type]: Function
[  arguments]: window-buffer WINDOW
[    package]: editor
[    seealso]: get-buffer-window
[       file]: builtin.l
[    section]: obt@
[description]: 
EBhE\Ăobt@Ԃ܂B
  
gpF
  (window-buffer (selected-window))


window-columns
[       type]: Function
[  arguments]: window-columns &optional WINDOW
[    package]: editor
[    seealso]: window-width , window-lines , window-height
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE̕\\ȗ̈̕LN^PʂŕԂ܂B
window-width ΏۂƂ镝AKvɉāusԍv\̈Au܂
Ԃv}[N\̈vZΏۂƂ܂B
LN^ɖȂɂĂ͐؂̂Ă܂AԂŏl 1 łB

⑫F
  ̓Iɂ́Awindow-width ̕ԂlAusԍv\́Asԍ\
   (xyzzy 0.2.2.233 ł 6) {E (1) ܂B
  ɁAu܂Ԃv\AeLXg̐܂ԂuEBhEv̏
  ɂ́Au܂Ԃv}[N (1) ܂B


window-coordinate
[       type]: Function
[  arguments]: window-coordinate &optional WINDOW
[    package]: editor
[    seealso]: window-width , window-height
[       file]: builtin.l
[    section]: EBhE
[description]: 
w肳ꂽEBhE̍WXgŕԂ܂B
([xW [yW E[xW E[yW)

W͍オ (0 0) ŉEɂقǒl傫ȂA
Pʂ̓sNZłB

gp:
  (window-coordinate)
  => (0 0 693 636)


window-height
[       type]: Function
[  arguments]: window-height &optional WINDOW
[    package]: editor
[    seealso]: window-lines , window-width , window-columns , screen-height
[   referred]: window-coordinate
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE̍sPʂŕԂ܂B
IłȂSɕ\\ȍs̐Ԃ܂AԂŏl 1 łB
xyzzy 0.2.2.232 ł͓Iɂ window-lines ƊSɓ`łB

gpF
  ;;; ݂̃EBhEcɔɂB
  (split-window (- (floor (window-height) 2) 2))
  => t

⑫F
  xyzzy 0.2.2.232 ł͓Iɂ window-lines ƊSɓ`łA
  window-height  window-lines ͓IuWFNgł͂܂B
  (eq #'window-height #'window-lines) => nil


window-lines
[       type]: Function
[  arguments]: window-lines &optional WINDOW
[    package]: editor
[    seealso]: window-height , window-width , window-columns , get-window-line
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE̕\\sԂ܂B
IłȂSɕ\\ȍs̐Ԃ܂AԂŏl 1 łB
xyzzy 0.2.2.232 ł͓Iɂ window-height ƊSɓ`łB

gpF
  (window-lines)
  => 18

⑫F
  xyzzy 0.2.2.232 ł͓Iɂ window-height ƊSɓ`łA
  window-lines  window-height ͓IuWFNgł͂܂B
  (eq #'window-lines #'window-height) => nil


window-width
[       type]: Function
[  arguments]: window-width &optional WINDOW
[    package]: editor
[    seealso]: window-columns , window-height , window-lines , screen-width
[   referred]: window-coordinate
[       file]: builtin.l
[    section]: EBhE
[description]: 
EBhE̕LN^PʂŕԂ܂B
\\ȗ̈̕ł͂ȂAusԍv\̈Au܂Ԃ}[Nv
\̈܂񂾗̈ɂĂ̕Ԃ܂B
LN^ɖȂɂĂ͐؂̂Ă܂AԂŏl 1 łB


windowp
[       type]: Function
[  arguments]: windowp OBJECT
[    package]: editor
[       file]: builtin.l
[    section]: f[^^
[description]: 
w肳ꂽOBJECTEBhEԂ܂B

  t     OBJECTEBhE
  nil   OBJECT̓EBhEł͂Ȃ


with-hash-table-iterator
[       type]: Macro
[  arguments]: with-hash-table-iterator (MNAME HASH-TABLE) &body BODY
[    package]: lisp
[    seealso]: maphash
[       file]: hash.l
[    section]: nbV
[description]: 
nbVe[u̗vfԂɕԂ֐ԂĂ炢܂B

  MNAME      : vfԂɕԂ֐w肵܂B
               ̊֐͗vf񋓂InilԂ܂B
  HASH-TABLE : nbVe[uw肵܂B
  BODY       : tH[Lq܂B

֐ԂɗvfԂ̂ŁAloopgnilԂ܂ŌJԂ܂B

gpF
(with-hash-table-iterator (foo hsh)
  (loop
    (multiple-value-bind (f x y)
        (foo)
      (unless f (return))
      (format t "~S ~S~%" x y))))


with-input-from-buffer
[       type]: Macro
[  arguments]: with-input-from-buffer (BUFFER &optional POINT EOB) &rest BODY
[    package]: editor
[    seealso]: with-output-to-buffer
[       file]: misc.l
[    section]: o
[description]: 
obt@̓Xg[ƂĈ悤ɂȂA
*standard-input*ǂݍ܂悤ɂȂ܂B

gpF
  ;;; *scratch*̓e*Output*ɓfoB
  (with-output-to-buffer ((switch-to-buffer "*Output*"))
    (with-input-from-buffer ((switch-to-buffer "*scratch*"))
      (while (setq line (read-line *standard-input* nil))
        (princ line)
        (princ "\n"))))


with-input-from-selected-buffer
[       type]: Macro
[  arguments]: with-input-from-selected-buffer &rest BODY
[    package]: editor
[       file]: misc.l
[    section]: o
[description]: 
݂̃obt@W͂ɂēǂݍ݂܂B

gpF
  ;;; ݂̃obt@ǂݍŕϐɓB
  (with-input-from-selected-buffer
    (setq name (read) count (read) exp (read)))


with-input-from-string
[       type]: Macro
[  arguments]: with-input-from-string (VAR STRING &key :index :start :end) &body BODY
[    package]: lisp
[    seealso]: make-string-input-stream , with-output-to-string
[       file]: stream.l
[    section]: o
[description]: 
W͂ɂēǂݍ݂܂B


with-interval-message
[       type]: Macro
[  arguments]: with-interval-message (INTERVAL) &body BODY
[    package]: editor
[    seealso]: message
[       file]: misc.l
[    section]: o
[description]: 
BODY  message R}hɂ\̍XVԊu𐧌܂B

  INTERVAL : \̍ŒXVԊui~bjB
             O message sƂ INTERVAL ~bȏo߂ĂȂꍇA
             VȃbZ[W\܂B

gp:
  ;; XVԊu 100 ~bɂĂ݂B
  (with-interval-message (100)
    (dotimes (i 100000)
      (message "~D" i)))


with-open-file
[       type]: Macro
[  arguments]: with-open-file (STREAM FILENAME &rest OPTIONS) &body BODY
[    package]: lisp
[    seealso]: with-open-stream , open
[       file]: stream.l
[    section]: o
[description]: 
w肳ꂽt@CXg[쐬A{̂]܂B

  STREAM    : Xg[ɑϐ
  FILENAME  : Xg[쐬t@C
  OPTIONS   : L[[hBopen ֓n̂Ɠ
  BODY      : s{

gpF
  (with-open-file (fp (merge-pathnames "lisp/henmi/c++-kwd.txt" (si:system-root)))
    (let ((line nil))
      (while (setq line (read-line fp nil nil nil))
        (push line *kekka*))))


with-open-stream
[       type]: Macro
[  arguments]: with-open-stream (VAR STREAM) &body BODY
[    package]: lisp
[    seealso]: with-open-file , connect
[   referred]: open
[       file]: stream.l
[    section]: o
[description]: 
ǏϐXg[ɑĖ{̂]AXg[܂B

QlF
  connect ̗QƂ̂


with-output-to-buffer
[       type]: Macro
[  arguments]: with-output-to-buffer (BUFFER &optional POINT) &rest BODY
[    package]: editor
[    seealso]: with-output-to-selected-buffer , with-output-to-temp-buffer
[   referred]: with-input-from-buffer
[       file]: misc.l
[    section]: o
[description]: 
Wo͂w肳ꂽobt@Ƀ_CNg܂B

  BUFFER : o͂obt@
  POINT  : o͂|Cgw肵܂B
           w肵Ȃꍇɂ́Aobt@̐擪o͂܂B
  BODY   : stH[

gpF
  ;;; *scratch*ɏoĂ݂B
  (with-output-to-buffer ((find-buffer "*scratch*"))
     (format t "foo~%")
     (format t "bar~%"))


with-output-to-selected-buffer
[       type]: Function
[  arguments]: with-output-to-selected-buffer &rest BODY
[    package]: editor
[    seealso]: with-output-to-buffer
[       file]: misc.l
[    section]: o
[description]: 
Wo͂Jgobt@Ƀ_CNg܂B
|Cgʒuo͂܂B
  
gpF
  ;;; Jgobt@ɏoĂ݂B
  (with-output-to-selected-buffer
     (format t "foo~%")
     (format t "bar~%"))


with-output-to-string
[       type]: Macro
[  arguments]: with-output-to-string (VAR &optional STRING) &body BODY
[    package]: lisp
[    seealso]: make-string-output-stream , with-input-from-string
[       file]: stream.l
[    section]: o
[description]: 
o͂Xg[쐬܂B

gpF
  ;;; Xg[gĕo͂Ă݂B
  (setq var
        (with-output-to-string (out)
          (prin1 "test" out)))
  => "test"


with-output-to-temp-buffer
[       type]: Macro
[  arguments]: with-output-to-temp-buffer (BUFNAME &optional (POPUP t)) &rest BODY
[    package]: editor
[    seealso]: with-output-to-buffer
[       file]: misc.l
[    section]: o
[description]: 
w肳ꂽobt@쐬AWo͂̃obt@Ƀ_CNg܂B
Õobt@ꍇɂ́Ãobt@̓e͔j܂B
Pɏʂނ悤ȏꍇɕ֗łB

  BUFNAME : obt@̖Ow肵܂B
  POPUP   : obt@𕪊\ۂ̍s^񐔂w肵܂B
        t       j܂B
            ws^񐔂ŕ܂B
        nil     obt@𕪊\܂B
  VERT-P  : obt@̕@w肵܂B
            POPUP  nil ̏ꍇ͈Ӗ܂B
        non-nil EɃobt@𕪊܂B
        nil     ㉺Ƀobt@𕪊܂B

gpF
  ;;; *Help*ĂɏoĂ݂B
  (with-output-to-temp-buffer ("*Help*")
     (format t "foo~%")
     (format t "bar~%"))

݊F
   muleɂCommon Lispɂ܂B


with-package-iterator
[       type]: Macro
[  arguments]: with-package-iterator (MNAME PACKAGE-LIST &rest SYMBOL-TYPE) &body BODY
[    package]: lisp
[    seealso]: do-all-symbols
[       file]: package.l
[    section]: pbP[W
[description]: 
w肳ꂽpbP[W̃V{񋓂֐Ă炢܂B
ꂽ֐ĂяoтɃV{񋓂܂B

  MNAME        : V{Ԃ֐w肵܂B
  PACKAGE-LIST : pbP[W̃Xgw肵܂B
  SYMBOL-TYPE  : ǂȃV{Ԃw肷悤łB

gpF
  ;;; SV{񋓂܂B
  ;;; ĂԂтɎ̃V{ԂfooƂ֐`Ă炤B
  (with-package-iterator (foo (list-all-packages) :internal :external)
    (loop
      (multiple-value-bind (f sym type package)
          (foo)             ; ĂԂƎ̃V{ԂĂB
        (unless f           ; ȂΏIB
          (return))
        (and (or (boundp sym)
                 (fboundp sym))
             (format t "~:[ ~;V~]~:[ ~;F~]~:[ ~;M~] ~A ~S ~S~%"
                     (boundp sym)
                     (fboundp sym)
                     (macro-function sym)
                     (package-name package)
                     sym
                     type)))))


with-selected-window
[       type]: Macro
[  arguments]: with-selected-window &body BODY
[    package]: editor
[    seealso]: set-window , save-window-excursion
[       file]: misc.l
[    section]: EBhE
[description]: 
BODY ̑OŃJgEBhEۑ܂B
Ȃ킿ABODY sɃEBhEړĂAsɌ̃EBhEɖ߂܂B


with-set-buffer
[       type]: Macro
[  arguments]: with-set-buffer &body BODY
[    package]: editor
[    seealso]: set-buffer
[       file]: misc.l
[    section]: obt@
[description]: 
BODY sۂɁA|Cg~jobt@ȊOɂ邱Ƃۏ؂܂B
|Cg~jobt@ɂꍇABODY s|Cg̓~jobt@ɖ߂܂B

~jobt@ set-buffer ƃG[N̂ŁA邽߂ɂ悤łB

gp:
  ;; lisp/misc.l 
  (defun setup-temp-buffer (buffer)
    (with-set-buffer
      (save-excursion
        (set-buffer buffer)
        (setq buffer-read-only nil)
        (setq need-not-save t)
        (setq kept-undo-information nil)
        (setq auto-save nil))))


word-char-p
[       type]: Function
[  arguments]: word-char-p CHAR
[    package]: editor
[    seealso]: syntax-word-p , characterp
[       file]: builtin.l
[    section]: f[^^
[description]: 
CHAR P\ǂ𔻒肵܂B


write
[       type]: Function
[  arguments]: write OBJECT &key :stream :escape :pretty :base :radix :circle :level :length :readably
[    package]: lisp
[    seealso]: read
[       file]: builtin.l
[    section]: o
[description]: 
OBJECT󎚕\ŃXg[ɏo͂܂B

  OBJECT       : o͂IuWFNgw肵܂B

  :stream      : o͂Xg[w肵܂B
                 ȗ*standard-output*ɏo͂܂B

  :escape      : GXP[v邩ǂw肵܂B
                 ftHg̒l*print-escape*łB
        non-nil  prin1formatwq~SƓ悤ɏo͂܂B
        nil      princformatwq~AƓ悤ɏo͂܂B

  :pretty      : ̕\₷邩ǂw肵܂B
                 ftHg̒l*print-pretty*łB
        non-nil  ₷܂B
        nil      ₷܂B

  :base        : w肵܂B
                 2`36܂łwłAȊO10iɂȂ܂B
                 ftHg̒l*print-base*łB

  :radix       : ͂邩ǂw肵܂B
                 ftHg̒l*print-radix*łB
        non-nil  #()r()̌`ŏo͂܂B
                 10i̎͂̌`ł͂ȂAŌ . t܂B
                 2i,8i,16i̊͂ꂼAb,o,xƕ\A
                 ȊO̎͊̂10iŕ\܂B
        nil      ̂ݏo͂܂B

  :circle      : zXgl邩ǂw肵܂B
                 ftHg̒l*print-circle*łB
        non-nil  lA#1=(a . #1#) ̂悤Ȍ`ŕ\܂B
        nil      l܂Bɕ\̂C-gŎ~߂Kv܂B

  :level       : Xgo͂̐[̐w肵܂B
                 [ʒuɂ郊XǵA#ŕ\܂B
                 ftHg̒l*print-level*łB

  :length      : Xgo͂̒̐w肵܂B
                 Xg͓rőł؂A
                 ... ŕ\܂B
                 ftHg̒l*print-length*łB

  :readably    : ǂ߂悤ɏo͂܂B
                 ftHg̒l*print-readably*łB
        non-nil  :length:levelnon-nilw𖳌ɂA
                 :escapenilłnon-nilw肵悤ɏo͂܂B


write-char
[       type]: Function
[  arguments]: write-char CHARACTER &optional OUTPUT-STREAM
[    package]: lisp
[    seealso]: read-char
[       file]: builtin.l
[    section]: o
[description]: 
OUTPUT-STREAM  CHARACTER o͂A CHARACTER Ԃ܂B


write-file
[       type]: Function
[  arguments]: write-file FILENAME &optional NOMSG APPEND CHAR-ENCODING EOL-CODE
[    package]: editor
[    seealso]: append-file , save-buffer , emacs-write-file , *default-write-file-directory*
[       file]: files.l
[    section]: t@CVXe
[description]: 
obt@̓e FILENAME ɏ݂܂B[C-x C-w]
obt@уobt@Ɋ֘Atꂽt@C͕ύX܂B

  NOMSG         : non-nil ȂXe[^Xo[Ɍo߃bZ[W\܂B
  APPEND        : non-nil Ȃt@Cɒǉ܂B
  CHAR-ENCODING : GR[fBOw肵܂B
  EOL-CODE      : sR[hw肵܂B


write-region
[       type]: Function
[  arguments]: write-region FROM TO FILENAME &optional APPEND CHAR-ENCODING EOL-CODE
[    package]: editor
[       file]: builtin.l
[    section]: t@CVXe
[description]: 
[Wt@Cɏ݂܂B
APPEND  non nil Ȃǉ݂܂B


write-registry
[       type]: Function
[  arguments]: write-registry SECTION KEY VALUE
[    package]: editor
[    seealso]: read-registry
[       file]: builtin.l
[    section]: VXe
[description]: 
WXgɏ݂܂B

  SECTION : ZNVw肵܂B
  KEY     : L[w肵܂B
  VALUE   : lw肵܂B

gpF
  ;;; HKEY_CURRENT_USER\Software\Free Software\Xyzzy ̉Ƀf[^
  (write-registry "software\\chombo\\altime" "aaa" 64)

  ȉ̂悤ɏ܂܂B
-----
REGEDIT4

[HKEY_CURRENT_USER\Software\Free Software\Xyzzy\software\chombo\altime]
"aaa"=dword:00000040
-----


wrong-disk
[       type]: Misc
[    package]: lisp
[    seealso]: wrong-disk-pathname
[    section]: t@CVXe
[description]: 
jǂɂ݂ȂH


wrong-disk-pathname
[       type]: Function
[  arguments]: wrong-disk-pathname X
[    package]: lisp
[   referred]: wrong-disk
[    section]: t@CVXe
[description]: 
jǂɂ݂ȂH


xyzzy-dumped-p
[       type]: Function
[  arguments]: xyzzy-dumped-p
[    package]: editor
[    seealso]: dump-xyzzy
[       file]: builtin.l
[    section]: VXe
[description]: 
Nxyzzy_vς݂ǂԂ܂B

  t     _vς
  nil   _vς݂ł͂Ȃ

_vƂĂċN܂ł͖߂ltɂȂ܂B


xyzzyŒ񋟂ĂXg[̎
[       type]: Tips
[    seealso]: open , make-string-input-stream , make-string-output-stream , make-synonym-stream , make-broadcast-stream , make-concatenated-stream , make-echo-stream , make-two-way-stream , make-buffer-stream , connect , stream-encoding , set-stream-encoding
[   referred]: buffer-stream-buffer , buffer-stream-p , buffer-stream-point , buffer-stream-set-point
[    section]: o
[description]: 
irj
ȉxyzzyŒ񋟂ĂXg[̎ނłB

  CommonƓ
  ---------------------------------------------
  file-input-stream       open
  file-output-stream      open
  file-io-stream          open
  string-input-stream     make-string-input-stream
  string-output-stream    make-string-output-stream
  synonym-stream          make-synonym-stream
  broadcast-stream        make-broadcast-stream
  concatenated-stream     make-concatenated-stream
  echo-stream             make-echo-stream
  two-way-stream          make-two-way-stream
  ---------------------------------------------

synonym-streamȍ~͎gƂȂ(^^;AǂȂł
ł傤(^^)B

  Ǝ
  ---------------------------------------------
  buffer-stream           make-buffer-stream
  status-window-stream    Ȃ
  keyboard-stream         Ȃ
  wstreams-stream         Ȃ
  ---------------------------------------------

ƎXg[̊TvF
  buffer-stream
    obt@Xg[Ƃ݂Ȃēo͂ǂłł܂B  
  status-window-stream
    Xe[^XEBhEXg[Ƃ݂Ȃďo͂ł܂B
    O[oϐ*status-window*̒lłB
  keyboard-stream
    L[{[hXg[Ƃ݂Ȃē͂ł܂B
    O[oϐ*keyboard*̒lłB
  wstreams-stream
    formatR[obNĂ΂ꂽƂstream̎́B


y-or-n-p
[       type]: Function
[  arguments]: y-or-n-p FMT &rest ARGS
[    package]: lisp
[    seealso]: yes-or-no-p , no-or-yes-p , yes-no-or-cancel-p
[       file]: misc.l
[    section]: ~jobt@
[description]: 
~jobt@ɃbZ[W\ă[U['y''n'͂̂҂܂B

  t     'y'
  nil   'n'

gpF
  ;;; "Foo: (y or n) "ƕ\đIB
  (y-or-n-p "Foo: ")
  => t          ; 'y'


yank
[       type]: Function
[  arguments]: yank &optional PREFIX (ARG 0)
[    package]: editor
[    seealso]: *kill-ring* , yank-pop , yank-rectangle
[       file]: region.l
[    section]: [W
[description]: 
*kill-ring*̐擪̗vf}܂B[C-y]


yank-and-pop
[       type]: Function
[  arguments]: yank-and-pop &optional PREFIX (ARG 0)
[    package]: editor
[    seealso]: yank-pop
[       file]: region.l
[    section]: [W
[description]: 
*kill-ring*̐擪̗vfyankɁA擪̗vf*kill-ring*pop܂B
*kill-ring*͈vfZȂ܂B


yank-pop
[       type]: Function
[  arguments]: yank-pop &optional (ARG 1)
[    package]: editor
[    seealso]: yank
[   referred]: yank-and-pop
[       file]: region.l
[    section]: [W
[description]: 
̗vfyank܂B [ESC y]
ÕR}hyankȂ*kill-ring*̃|C^[炵āA̗vf
yank܂B


yank-rectangle
[       type]: Function
[  arguments]: yank-rectangle
[    package]: editor
[    seealso]: kill-rectangle , yank-rectangle-selection , yank-rectangle-as-region
[   referred]: *rectangle-kill-buffer* , yank
[       file]: rectangl.l
[    section]: [W
[description]: 
copy-rectanglekill-rectangleɂđIꂽ̈`}܂B
yank-rectangle-selectionInsert̋@\̂悤łB


yank-rectangle-as-region
[       type]: Function
[  arguments]: yank-rectangle-as-region
[    package]: editor
[    seealso]: yank-rectangle
[       file]: rectangl.l
[    section]: [W
[description]: 
copy-rectangleŐ؂`̈A
AA̕Ƃđ}܂B

  ABCDEFG ;
  HIJKLMN ; JKL
  OPQRSTU ; QRS
  VWXYZ   ; XYZ̗̈copy-rectangle

  (yank-rectangle)
  =>JKL
    QRS
    XYZ

  (yank-rectangle-as-region)
  =>JKLQRSXYZ


yank-rectangle-selection
[       type]: Function
[  arguments]: yank-rectangle-selection &optional ARG
[    package]: editor
[    seealso]: yank-rectangle , kill-rectangle-selection
[       file]: select.l
[    section]: [W
[description]: 
}EXŋ`IꂽZNV̗̈yank܂B[S-F9]
sɂǂ̂悤yank邩₳܂B
  F6    Cancel                  yank~
  F7    Append                  sɒǉ
  F8    Overwrite               ㏑
  F9    Insert                  }
  F10   Insert as region        ɂđ}


yank-selection
[       type]: Function
[  arguments]: yank-selection &optional (ARG 0)
[    package]: editor
[    seealso]: kill-selection , copy-selection
[   referred]: *selection-ring* , yank-selection-and-pop
[       file]: select.l
[    section]: [W
[description]: 
*selection-ring*̐擪̗vf\t܂B[F9]
*selection-ring*ւcopy-selectionkill-selectionŒǉ܂B


yank-selection-and-pop
[       type]: Function
[  arguments]: yank-selection-and-pop &optional (ARG 0)
[    package]: editor
[    seealso]: yank-selection
[       file]: select.l
[    section]: [W
[description]: 
*selection-ring*̐擪̗vfyank-selectionɁA
擪̗vf*selection-ring*pop܂B
*selection-ring*͈vfZȂ܂B


yank-to-clipboard
[       type]: Function
[  arguments]: yank-to-clipboard &optional (ARG 1)
[    package]: editor
[    seealso]: copy-to-clipboard
[       file]: region.l
[    section]: [W
[description]: 
*kill-ring*̓eNbv{[hɕʂ܂B


yes-no-or-cancel-p
[       type]: Function
[  arguments]: yes-no-or-cancel-p FMT &rest ARGS
[    package]: lisp
[    seealso]: yes-or-no-p , no-or-yes-p , y-or-n-p
[       file]: misc.l
[    section]: _CAO
[description]: 
u͂vuvuLZṽ{^tbZ[W{bNX\܂B
ftHǵu͂vłBuLZvIꍇɂ́Aquits܂B

  t     u͂vI
  nil   uvI

gpF
  ;;; _CAO\đIB
  (yes-no-or-cancel-p "foo")
  => t          ; u͂vI
  (yes-no-or-cancel-p "foo")
  => nil        ; uvI


yes-or-no-p
[       type]: Function
[  arguments]: yes-or-no-p FMT &rest ARGS
[    package]: lisp
[    seealso]: no-or-yes-p , y-or-n-p , yes-no-or-cancel-p , message-box
[       file]: misc.l
[    section]: _CAO
[description]: 
u͂vuṽ{^tbZ[W{bNX\܂BftHg
u͂vłB

  FMT  : formatl̏wł܂B
  ARGS : o͏ւ̃p^ƂȂ܂B

߂l͈ȉ̂ƂłB

  t     u͂vI
  nil   uvI

gpF
  ;;; _CAO\đIB
  (yes-or-no-p "foo")
  => t          ; u͂vI
  (yes-or-no-p "~A" "hogehoge")  
  => nil        ; uvI


zap-to-char
[       type]: Function
[  arguments]: zap-to-char C &optional (N 1)
[    package]: editor
[    seealso]: kill-region
[       file]: cmds.l
[    section]: 
[description]: 
|Cgw肳ꂽLN^܂łkill܂B[ESC z]


zerop
[       type]: Function
[  arguments]: zerop NUMBER
[    package]: lisp
[       file]: builtin.l
[    section]: l
[description]: 
NUMBER[ȂtAłȂnilԂ܂B

gpF  
  (zerop 0)
  => t
  (zerop 1)
  => nil
  (zerop 0.0)
  => t
  (zerop -0.00)
  => t


ǂ̊֐̓ɉ̂ł傤H
[       type]: Tips
[    seealso]: pbP[W̊Tv
[   referred]: export , pbP[W
[    section]: pbP[W
[description]: 
| pbP[WƂTOɊ֌W񂾂Ǝv܂Aǂ̊֐̓ɉ
| Ƃ̂͂ǂ΂킩ł傤B

  M-x apropos make-chunk RET

ƂƂɁA

  system:make-chunk

̂悤ɕ\̂̓pbP[WKvȂ̂łBȂ݂ɁA
si  system pbP[ẂAc  foreign pbP[W̃jbNl[
łB
----------------------------------

  editor::xyzzy-mode  `:'2\ꍇexportĂȂ
        ^^
  editor:xyzzy-mode   `:'1\ꍇexportĂ
        ^
  xyzzy-mode          pbP[W\Ȃꍇ݂͌̃pbP[W
                      ڃANZXł


G[֌W
[       type]: Tips
[   referred]: define-condition , error , handler-case , ignore-errors , make-condition
[    section]: G[
[description]: 
G[̎ނ̃c[iKwjłB

condition
simple-condition
serious-condition
error
simple-error
plain-error
arithmetic-error
division-by-zero
floating-point-overflow
floating-point-underflow
domain-error
bignum-overflow
power-number-too-large
cell-error
unbound-variable
modify-constant
undefined-function
control-error
target-missing
file-error
file-not-found
path-not-found
access-denied
invalid-drive
current-directory
not-same-device
write-protected
bad-unit
device-not-ready
sharing-violation
lock-violation
wrong-disk
file-exists
not-empty
archiver-error
network-error
file-lost-error
package-error
simple-package-error
program-error
no-target
bad-macro-form
invalid-function
invalid-variable-list
invalid-lambda-list
invalid-keyword-list
type-error
range-error
stream-error
end-of-file
reader-error
too-few-arguments
too-many-arguments
bad-type-specifier
read-only-buffer
dde-error
  dde-timeout
  dde-busy
  dde-low-memory
  dde-no-conv
  dde-not-processed
  dde-server-died
  dde-terminated-transaction
storage-condition
stack-overflow
invalid-byte-code
quit
silent-quit
warning
  simple-warning


| xyzzy͂AEmacs LispłȂ Common Lispɍ킹ĂłˁB

łBRfBV^Cvɂ͓Ǝ̂܂ǁBStallman搶́A
ڂł͂ȂłCommoñRfBVVXeɉe^Ă炵
̂ŁAdgݓIɂ͎Ă܂B

| RfBVĉłH

Commonł́AG[ƌ킸ɃRfBVƌ炵ł(G[ȊO
邩?)BȒPɌC++try-catchƓł(AC++pN
񂾂낤)B

  class condition {};
  class serious_condition: public condition {};
  class error: public serious_condition {};
  class arithmetic_error: public error {};
  class division_by_zero: public arithmetic_error {};

Ă̂ꍇA

  throw division_by_zero;

ƂƁA

  try {...} catch (division_by_zero &) {...}

łA

  try {...} catch (error &) {...}

łA

  try {...} catch (condition &) {...}

ł߂܂܂?
Ɠl

  (error 'division-by-zero)

́A

  (handler-case ... (division-by-zero (c) ...))
  (handler-case ... (error (c) ...))
  (handler-case ... (condition (c) ...))

ǂłł߂܂邱Ƃł܂B܁AOႤEmacs
condition-caseƓł()Bcatch&throw̃^OɌp֌Wt
̂ƂB

܂AEmacsłł邩ǂ͒m܂񂪁AȊŎ̃Lb`ɃR
fBVnƂł܂B

  (handler-case
      (any-expression)
    (error (c)
      (some-expression)
      (error c)))

C++ł
  try
    {
      any-expression;
    }
  catch (error &)
    {
      some-expression;
      throw;
    }
ƓłǁB


L[[ht@C̏
[       type]: Tips
[   referred]: *keyword-load-path* , load-keyword-file
[    section]: ̑
[description]: 
L[[ht@C*keyword-load-path*etc-path猟
܂B$XYZZY/etcz̃t@CQƂĉB

`F
  w肷ꍇɂ͈ȉ̓̌`ŋLq܂B

  ;*n[attrib]
  ;**fg[bg[attrib]]

      n       L[[hԍ(0-5) 3-50-2ƓF̔]
      fg      F 0-f (0ȂΕʂ̐F)
      bg      wiF 0-f (0ȂΕʂ̐Fj
      attrib  ݂Ȃ́Bȉ̂̂̑gݍ킹
              b bold
              u underline
              s strike-out
              l sۂ
F
  xyzzy 0.2.207load-keyword-fileconditionw肷
  Ƃ\ɂȂ܂BconditionitemƔrs܂B
  $XYZZY/lisp/html-kwd.lQ

  ;*+         conditionɊւ炸ȍ~Lɂ
  ;*-         conditionɊւ炸ȍ~𖳌ɂ
  ;*+item     itemconditionɈvꍇɈȍ~Lɂ
  ;*-item     itemconditionɈvꍇɈȍ~𖳌ɂ
  ;*&         ȍ~HTML̃^OȊOłLȃL[[hƂ
  ;*<         ȍ~HTML̃^Oł̂ݗLȃL[[hƂ


L[\gp\
[       type]: Tips
[    seealso]: global-set-key , define-key , *kbd-translate-table*
[    section]: L[}bv
[description]: 
#\a#\C-b̂悤ɕƂĕ\܂BA\"'(),;`| 9́A
lisp̍\̓ʂȈӖ̂ŁA}邽߂'\'Ou܂B

  #\a           ; a
  #\;           ; ;
  #\C-b         ; Ctrl+b
  #\C-\;        ; Ctrl+;
  #\M-\;        ; Alt+;
  #\C-M-\;      ; Ctrl+Alt+;

CtrlAAltAShift̓\ł܂BC-AM-AS-̏Ԃ͉łǂłB

  #\C-          ; Ctrl
  #\S-          ; Shift
  #\C-S-        ; Ctrl+Shift
  #\M-          ; Alt
  #\M-C-        ; Alt+Ctrl
  #\M-S-        ; Alt+Shift
  #\M-C-S-      ; Alt+Ctrl+Shift


L[ɂĂ͓łL[ɐ܂B
ႦS-TAB͕ʂ̂ł͂ł܂BǂĂ肽΁A
set-extended-key-translate-table QƂĉB

  
  L[                      łL[        
                            
                            M C M S C M M 
                                C   S S C 
                                        S 
  
   !"#$%&'()*+,-./          wwww
  0123456789:;<=>?                        
  @ABCDEFGHIJKLMNO                        
  PQRSTUVWXYZ[\]^_                        
  `abcdefghijklmno                        
  pqrstuvwxyz{|}~                         
  
  SPC       Xy[XL[    wwwww
  
  TAB       TabL[         wwwwww
  LFD                                     
  RET       EnterL[                     
  ESC       EscL[                       
  DEL                                     
  NUL                                     
  
  PageUp    Page UpL[     
  PageDown  Page DownL[                 
  End       EndL[                       
  Home      HomeL[                      
  Left      L[                        
  Up        L[                        
  Right     L[                        
  Down      L[                        
  Pause     PauseL[                     
  Scroll    ScrollLockL[                
  Apps      ApplicationL[               
  Insert    InsertL[                    
  Delete    DeleteL[                    
  Help      ǂ̃L[?                     
  F1`F24   F1`F24L[                   
  LBtnDown  {^                  
  LBtnUp    {^                  
  LBtnMove  {^hbO              
  RBtnDown  E{^                  
  RBtnUp    E{^                  
  RBtnMove  E{^hbO              
  MBtnDown  {^                  
  MBtnUp    {^                  
  MBtnMove  {^hbO              
  XBtn1Down                               
  XBtn1Up                                 
  XBtn1Move                               
  XBtn2Down                               
  XBtn2Up                                 
  XBtn2Move                               
  MouseMove                               
  

Ⴆ΁A#\RET#\C-m͓Iɂ͓ƌȂ܂B̂悤ȕ͈ȉ
̂ƂłB

  (eq #\TAB #\C-i) => t
  (eq #\LFD #\C-j) => t
  (eq #\RET #\C-m) => t
  (eq #\ESC #\C-[) => t
  (eq #\DEL #\C-?) => t
  (eq #\NUL #\C-@) => t


R}hɂqXgύXɂ́H
[       type]: Tips
[    section]: ̑
[description]: 
R}hʂɃ~jobt@̃qXgǗ@łB

  ;;; qXg̃Xg
  (setq foo-history '("qux" "quux" "quuux"))
  
  ;;; ǗR}h
  (defun foo ()
    (interactive)
    (list
     (let ((*minibuffer-default-history* foo-history)) ; qXgݒ肷
       (prog1
         (completing-read
          "foo: "               ; vvg
          '("foo" "bar" "baz")  ; ⊮
          :must-match nil       ; K⊮Ƀ}b`ȂʖځH
          :case-fold t)         ; 啶ʂH
         ; ύXꂽȂ߂Ă
         (setq foo-history *minibuffer-default-history*)))))


`N̊Tv
[       type]: Tips
[    seealso]: si:make-chunk
[   referred]: si:unpack-string
[    section]: `N
[description]: 
xyzzẙOƓo͂邽߂̃f[^i[IuWFNgłB
`Ng͈ȉ̗vf\܂B

         16byte 
        
        f[^f[^^i[  |      
        
  f[^ : `NǗf[^̒łB
             make-chunkŎw肵܂B
  f[^^ : `NǗf[^̌^łB
  i[   : `N̂ɂ͊Ǘf[^܂B
             i[̃AhXǗ܂B

ȉ͊ǗC[WłB

  ;;; gp
  (setq chunk (si:make-chunk 'string 8)) => #<chunk 0x00081010>
  (si:chunk-data chunk)                  => 0x00A73DC8
  (si:pack-string chunk 0 "HELLO")       => "HELLO"

      AhX  f[^
      
      0x000810100x00000008string    0x00A73DC8
      
      0x00081018...                               
      
                                                
      
      0x00A73DC8H E L L O \0      
      
      0x00A73DD0...                               
      
                                                
      

`N擾֐͈ȉ̂ƂłB

  si:address-of  : `Ng̃AhXԂ܂B
  si:chunk-size  : `NǗf[^̒Ԃ܂B
  si:chunk-type  : `NǗf[^̌^Ԃ܂B
  si:chunk-data  : `NǗf[^̊i[̃AhXԂ܂B
  si:chunk-owner : f[^̊i[悪`Ngmۂ̂ǂԂ܂B

`N𑀍삷֐͈ȉ̂ƂłB

  si:fill-chunk  : `NfillH
  si:clear-chunk : `NNAH
  si:copy-chunk  : `NǗf[^Rs[܂B

`N̓o͂֐͈ȉ̂ƂłB

  si:pack-int8          si:unpack-int8   :  8rbgtp
  si:pack-uint8         si:unpack-uint8  :  8rbgp
  si:pack-int16         si:unpack-int16  : 16rbgtp
  si:pack-uint16        si:unpack-uint16 : 16rbgp
  si:pack-int32         si:unpack-int32  : 32rbgtp
  si:pack-uint32        si:unpack-uint32 : 32rbgp
  si:pack-float         si:unpack-float  : floatp
  si:pack-double        si:unpack-double : doublep
  si:pack-string        si:unpack-string : p


obt@̓\
[       type]: Tips
[   referred]: create-new-buffer , get-buffer-create
[    section]: obt@

pbP[W
[       type]: Tips
[    seealso]: ǂ̊֐̓ɉ̂ł傤H , export , use-package , pbP[W̊Tv
[   referred]: *package* , defpackage , delete-package , find-package , find-symbol , import , in-package , intern , list-all-packages , make-package , unexport
[    section]: pbP[W
[description]: 
pbP[W͊ȒPɌƁA oblist Ƃ obarray Ƃ̂
ςāA[_V{ǂ񂾂Ƃɂǂ obarray g
find-symbol  intern 邩w肷̂łB

ɁA̃pbP[W pƊOp̓ obarray Aʏ
͓p intern ܂B֐ export ŁApOpɈړ邱
Ƃł܂B

pƊOp̈Ⴂ́ApbP[WƂ(ƂȂĂ
)̃pbP[Wgp(use)Ɛ錾ƁA閼O find-symbol
ƂɁÃV{w肳ꂽpbP[Wɑ݂ȂꍇÃpb
P[WgpĂpbP[W̊Opɂ邩ɂ悤ɂȂĂ܂B

export̎dg݁F
  exportĂS̃pbP[W猩킯ȂāÃpb
  P[WuseĂpbP[W猩悤ɂȂ邾łB

  (package-use-list "user")
  => (#<package: lisp> #<package: editor>)

  (package-use-list "editor")
  => (#<package: lisp>)

  Ȃ̂ŁAeditorpbP[W猩̂́Aeditor̃V{lispexport
  ꂽV{łB
  uvƂ̂̓pbP[W̏CqȂŎQƂłƂӖłB


pbP[W̊Tv
[       type]: Tips
[    seealso]: pbP[W
[   referred]: ǂ̊֐̓ɉ̂ł傤H
[    section]: pbP[W
[description]: 
pbP[Wɂ͊OQƂV{p̋ԂƁÃV{p̋
Ԃ܂BV{͍ŏ͓ɓo^܂BexportƊOɈړ
܂B
     system        lisp        editor        user
            
   s-exp    l-exp    e-exp    u-exp  <- O
            
   s-int    l-int    e-int    u-int  <- 
            


ʏ user ōƂĂ܂B user  lisp, editor 𗘗pƐ錾
Ă܂B̂߁Al-exp, e-exp, u-exp, u-int ɓo^ꂽV{p
bP[W̏CqŎQƂł悤ɂȂĂ܂ig̕łjB
     system        lisp        editor        user
            
   s-exp    l-exp    e-exp    u-exp  <- O
            
   s-int    l-int    e-int    u-int  <- 
            


vOĐVV{oĂƁAu-int ɓo^܂B
(in-package "editor") sɃV{ e-int ɓo^܂B
     system        lisp        editor        user
            
                                     <- O
    ...      ...      ...      ...  
            
                      bar      foo   
    ...      ...      ...      ...   <- 
            
̂܂ł͕₷Ǝv̂łA̂́u(editor)
useĂpbP[W(user)ɊɂV{(foo)export悤ƂăG
[łvƂgułB


u-inte-int̂ꂼfooƂV{`ĂԂl܂B
̏Ԏ͖̂肠܂񂪁ȀԂeditor::fooexport悤Ƃ
ƃG[܂B
     system        lisp        editor        user
            
                       w            <- O
    ...      ...      .      ...  
            
                      foo      foo   
    ...      ...      ...      ...   <- 
            
user QƉ\Ȕ͈͂炷ƁAu-intɊɂV{ƓÕV
{e-expɓ悤Ƃ邽߁AuOՓ˂邽exportł܂
: editor::foovƓ{܂B

  (setq foo "user")
  => "user"
  (setq ed::foo "editor")
  => "editor"
  (export '(ed::foo) "ed")
  => OՓ˂邽exportł܂: editor::foo

ȊOɂȌ`łN܂Blisp::fooeditor::foo̊Ԃ̖̂悤
łAuserlispeditoruseĂ邱ƂłB
     system        lisp        editor        user
            
             foo       w            <- O
    ...      ...      .      ...  
            
                      foo            
    ...      ...      ...      ...   <- 
            


t@C̗
[       type]: Tips
[    section]: ̑
[description]: 
(defun find-modify-save-test (file)
  (interactive "f")
  (let (temp-buffer)
    (unwind-protect
        (progn
          ;; e|̃obt@
          (setq temp-buffer (create-new-buffer "*foo*"))
          ;; Jgobt@ɂ
          (set-buffer temp-buffer)
          ;; t@Cǂݍ
          (insert-file-contents (merge-pathnames file *src-dir*))
          (goto-char (point-min))
          ;; ł낢

          ;; t@Cɏ
          (write-file (merge-pathnames file *dst-dir*)))
      ;; obt@Ă(kill-buffer͂邳̂delete-buffer)
      (when temp-buffer
        (delete-buffer temp-buffer)))))


̃wb_tb^Ɋւ\L
[       type]: Tips
[    section]: ̑
[description]: 
̃wb_tb^Ɋւ\L@łBȉ 
  Toy's xyzzy memo - Data Library -
  http://www.carabiner-systems.com/xyzzy/data.html)
̈płB

--- p ---
̃wb_tb^Ɋւ\L 
header and footer 1999/12/25@Written by Tetsuya Kamei [xyzzy:03752] 

  %f   t@C
  %F   t@C (fBNgt)
  %b   obt@
  %p   y[Wԍ
  %P   y[W

  %Y    (YYYY)
  %y    (YY)
  %m      (1`12)
  %0m     (01`12)
  %*m     (January`December)
  %:m     (Jan`Dec)
  %d      (1`31)
  %0d     (01`31)
  %*w  j (Sunday`Saturday)
  %:w  j (Sun`Sat)
  %w   j (`y)
  %h      (0`23)
  %0h     (00`23)
  %H      (0`11)
  %0H     (00`11)
  %:H     (1`12)
  %0:H    (01`12)
  %*H       (AM/PM)
  %*:H      (am/pm)
  %M      (0`59)
  %0M     (00`59)
  %s   b   (0`59)
  %0s  b   (00`59)

  %-   

  %l   ȑOl
  %r   ȍ~El
       w肳Ȃ͒

  ȊO͂̂̕܂
  --------------------------------------------------------------------------------
  (ftHg)
    [wb_] %F%l%r%:w, %0d %:m %Y %0h:%0M:%0s
    [tb^] - %p - 


e탍[h֌W̊֐̈Ⴂ
[       type]: Tips
[    seealso]: load , load-library , autoload , require , *modules*
[    section]: ̑
[description]: 
load         C^v^load܂B

load-library *.lc΂[h܂B
             *.lcȂ*.l[h܂B

autoload     ֐1PʂŁAĂ΂ꂽƂload悤ɂł܂B
             ֐Ă΂܂łload܂B

require      郉Cu[h܂BA
             [hς݂Ȃ烍[h܂B

*modules*    ̕ϐƍǂ̃W[[hς܂B
             Ƀ[hςƂ[h܂B


e팾L[}bv
[       type]: Tips
[    seealso]: define-key
[    section]: L[}bv
[description]: 
vOꖈiƂA[hjɃL[}bvύX邱Ƃł܂B

  ;;; pL[}bvꗗ
  *basic-mode-map*              ; BASICp
  *csharp-mode-map*             ; C#p
  *c-mode-map*                  ; Cp
  *c++-mode-map*                ; C++p
  *css-mode-map*                ; CSSp
  *html-mode-map*               ; HTMLp
  *idl-mode-map*                ; IDLp
  *java-mode-map*               ; javap
  *LaTeX-mode-map*              ; LaTeXp
  *lisp-mode-map*               ; lispp
  *pascal-mode-map*             ; PASCALp
  *perl-mode-map*               ; Perlp
  *sql-mode-map*                ; SQLp

  ;;; ̑L[}bvꗗ
  *box-drawings-mode-map*       ; r`惂[hp
  *buffer-menu-mode-map*        ; buffer-menup
  *calc-mode-map*               ; calcp
  *calendar-mode-map*           ; calendarp
  *den8-view-mode-map*          ; dM̃[\p
  *den8-summary-mode-map*       ; dM̃[ꗗ\p
  *den8-draft-mode-map*         ; dM̉p
  *diff-mode-map*               ; diffp
  *async-grep-mode-map*         ; 񓯊grepp
  *lisp-interaction-mode-map*   ; *scratch*Ƃlisp-interaction-modep
  *fundamental-mode-map*        ; [hƂp
  *log-summary-mode-map*        ; niftỹOꗗp
  *log-article-mode-map*        ; niftỹOp
  *command-output-mode-map*     ; OR}hsp
  *shell-mode-map*              ; shell[hp
  *tail-f-mode-map*             ; tail-fp
  *text-mode-map*               ; eLXgp
  *view-mode-map*               ; eLXg\p

gpF
  ;;; c++-modeł̃L[蓖Ăς
  (define-key ed::*c++-mode-map* #\C-s 'foo)

  ;;; lisp-modeł̃L[蓖Ăς
  (define-key ed::*lisp-mode-map*  #\TAB 'lisp-complete-symbol)

  ;;; LispC^NV[hł̃L[蓖Ăς
  (define-key ed::*lisp-interaction-mode-map* #\TAB 'lisp-complete-symbol)


Nt[
[       type]: Tips
[    seealso]: *command-line-mailto-hook* , *init-app-menus-hook* , *load-history-hook* , *post-startup-hook* , *pre-startup-hook* , *process-command-line-hook*
[    section]: VXe
[description]: 
  N̏t[łB $XYZZY/xyzzy.exe NƁAŏ init.cc
   $XYZZY/lisp/startup.l Ăяo܂Bȍ~̎ȃt[͈ȉ
  ̂ƂłB
  
  init.cc: 
    1. startupload-library 
       startup.l: 
        1. loadupload-library 
           loadup.l: 
            1. estartup  load-library 
             iestartup.l ŁAe:startup `j 
            2. historyload-library 
             ihistory.l ŁA load-history-file `j 
            3. app-menuload-library 
             iapp-menu.l ŁA init-app-menus `j 
            4. siteinit  load-library 
    2. _vȂ_v 
    3. e:startup s 
       estartup.l  e:startup: 
        1. t[ 
        2. *pre-startup-hook* s 
        3. .xyzzys 
        4. qXg 
         ihistory.lload-history-fileŁA *load-history-hook* sj 
        5. j[ 
         iapp-menu.linit-app-menusŁA *init-app-menus-hook* sj 
        6. *scratch*쐬
        7.
          (process-command-line A *command-line-mailto-hook* Ƃ
           *process-command-line-hook*sj
        8. *post-startup-hook*s 
  
܂Ƃ߂ƁANɃ[UύX\ȕ́Aȉ̏ԂŎs
܂B

  1. $XYZZY/site-lisp/siteinit.l
  2. *pre-startup-hook*
  3. ~/.xyzzy
  4. *load-history-hook*
  5. *init-app-menus-hook*
  6. *command-line-mailto-hook* i-mailtoꍇj
  7. *process-command-line-hook* isȃIvVꍇj
  8. *post-startup-hook*


^ꗗ
[       type]: Misc
[    seealso]: deftype , subtypep , type-of , typep
[    section]: V{
[description]: 
^YɊKw\𐬂ł͂Ȃ̂łAsubtypepŃWbNɑgݍ
ĂƂ납ARɂȂȂxɊKŵłB[]t͓̕
dɏoĂ܂B

  list                                  Xg
  null                                k
  cons                                RX
  atom                                  Ag
  number                              l
  real                              
  rational                        L
  ratio                         
  integer                       
    bignum                      |
  float                           _
    short-float                   x_
    single-float                  Px_
    double-float                  {x_
    long-float                    x_
  complex                           f
  symbol                              V{
  [null]                            |
  keyword                           L[[h
  character                           
  base-character                    |
  standard-char                   W
  extended-character                |
  stream                              Xg[
  two-way-stream                    oXg[
  echo-stream                       |
  broadcast-stream                  |
  file-stream                       t@CXg[
  synonym-stream                    Xg[
  string-stream                     |
  concatenated-stream               |
  sequence                            V[PX
  [list]                            |
  [vector]                          |
  array                               z
    simple-array                      Pz
    simple-string                   P
    vector                            xN^
      simple-vector                   PxN^
      string                          
        [simple-string]               |

gpF
  ;;; listsequenceŁAsequenceatomǁAlistatomł͂ȂB
  (subtypep 'list 'sequence)    => t
  (subtypep 'sequence 'atom)    => t
  (subtypep 'list 'atom)        => nil

QlF
  typespec.l


sԍON/OFF
[       type]: Tips
[    section]: ̑
[description]: 
ȂɊȒPɃ|bvAbvj[sł܂B

gpF
  ;;; C-RBtnUpœƎ̃|bvAbvj[ɂ܂B
  (global-set-key #\C-RBtnUp 'my-apps-popup)
  (defun my-apps-popup ()
    (interactive)
    (track-popup-menu  
     (define-popup-menu
              (:item nil "sԍ(&L)"
               'toggle-line-number)
              (:item nil "XN[o[(&B)"
               'toggle-vscroll-bar)
              (:item nil "[hC(&M)"
               'toggle-mode-line)
              (:item nil "t@NVL[(&F)"
               'toggle-function-bar)
              (:item nil "܂Ԃ(&T)"
               'toggle-fold-line)
              (:item nil "[hI[(&R)"
               'toggle-read-only))))


K\̕\L
[       type]: Tips
[    seealso]: Emacs ݊ł͂ȂK\͌\̂ł傤H
[   referred]: looking-at , match-string , regexp-keyword-list , replace-buffer , scan-buffer , string-looking-at , string-match
[    section]: EK\
[description]: 
K\̕\L@łBȉ 
  Toy's xyzzy memo - Data Library -
  http://www.carabiner-systems.com/xyzzy/data.html)
̈płB

--- p ---
K\
regular expression 1999/12/29@Written by Tetsuya Kamei [xyzzy:03768] 

  ^         sɃ}b`
  $         sɃ}b`
  .         sCӂ 1 Ƀ}b`
  [...]     NX̂ǂꂩ 1 Ƀ}b`
  [^...]    NX̕Ŵǂꂩ 1 Ƀ}b`
  *         O̐K\ 0 ȏ̌JԂɃ}b` (={0,})
  +         O̐K\ 1 ȏ̌JԂɃ}b` (={1,})
  ?         O̐K\ 0  1 ̌JԂɃ}b` (={0,1})
  \{M,N\}   O̐K\ M ȏ N ȉ̌JԂɃ}b`
  \{M,\}    O̐K\ M ȏ̌JԂɃ}b`
  \{,N\}    O̐K\ N ȉ̌JԂɃ}b`
  \{N\}     O̐K\ N ̌JԂɃ}b`
  \( \)     O[sO
  \|        I
  \1 ` \9  Q
  \<        P̊JnɃ}b`
  \>        P̏IɃ}b`
  \b        P̋EɃ}b`
  \B        P̋EȊOɃ}b`
  \w        pɃ}b`
  \W        pȊOɃ}b`
  \sc       V^bNX c  1 Ƀ}b`
  \Sc       V^bNX c ȊO 1 Ƀ}b`
  \`        obt@̐擪Ƀ}b`
  \'        obt@̍ŌɃ}b`
  \         ^LN^̃GXP[v

  [Ԃ xyzzy 0.2.1.186 ]
  *?        O̐K\ 0 ȏ̍ŒŽJԂɃ}b`
  +?        O̐K\ 1 ȏ̍ŒŽJԂɃ}b`
  ??        O̐K\ 0  1 ̍ŒŽJԂɃ}b`

            (let ((str "aAaaa"))
              (string-match "Aa?" str)
              (format t "[Aa? ] ... ~S: ~D-~D~%"
                      (match-string 0) (match-beginning 0) (match-end 0))
              (string-match "Aa??" str)
              (format t "[Aa??] ... ~S: ~D-~D~%"
                      (match-string 0) (match-beginning 0) (match-end 0)))
            ->[Aa? ] ... "Aa": 1-3
              [Aa??] ... "A": 1-2

  \{M,N\}?  O̐K\ M ȏ N ȉ̍ŒŽJԂɃ}b`
  \{M,\}?   O̐K\ M ȏ̍ŒŽJԂɃ}b`
  \{,N\}?   O̐K\ N ȉ̍ŒŽJԂɃ}b`
  \(?:regexp\)
            K\̃O[sOsCQƂsȂ
            (Ȃ킿\1C\2ƂgĎQƂłȂC)

  [ xyzzy 0.2.2.202 ]
  \_<       V{̊JnʒuɃ}b` 
  \_>       V{̏IʒuɃ}b` 
  \_b       V{̋EɃ}b` 
  \_B       V{̋EȊOɃ}b` 
  \_s       V{Ƀ}b` 
  \_S       V{ȊOɃ}b` 


ړIʍ
  - VXe
  - obt@
  - `N
  - G[
  - pbP[W
  - o
  - EK\
  - ̑
  - L[}bv
  - ֐ꗗ

VXe
  - Nt[

obt@
  - obt@̓\

`N
  - `N̊Tv

G[
  - G[֌W

pbP[W
  - ǂ̊֐̓ɉ̂ł傤H
  - pbP[W
  - pbP[W̊Tv

o
  - xyzzyŒ񋟂ĂXg[̎

EK\
  - Emacs ݊ł͂ȂK\͌\̂ł傤H
  - compile-regexp ƈꉞł傤H
  - K\̕\L

̑
  - C-z ŃACRɂ́H
  - DOS̃R}hLbNČʂ𕶎ɂɂ́H
  - OLEI[g[V̎gp
  - L[[ht@C̏
  - R}hɂqXgύXɂ́H
  - t@C̗
  - ̃wb_tb^Ɋւ\L
  - e탍[h֌W̊֐̈Ⴂ
  - sԍON/OFF

L[}bv
  - BS  C-h ɕʁX̋@\蓖Ăɂ́H
  - L[\gp\
  - e팾L[}bv

CfbNXꗗ
f[^^
ϐƒ萔
\
pbP[W
֐
}N
V{
l


V[PX
Xg
nbV
z
`N
]
o
t@CVXe
G[
EBhE
obt@
~jobt@
[W
[h
V^bNX
L[}bv
eLXg
EK\
_CAO
tE
j[
t@C
|WV
vZX
VXe
̑

֐ꗗ
  - *
  - *activate-hook*
  - *after-save-buffer-hook*
  - *apropos-no-regexp*
  - *auto-encoding-alist*
  - *auto-fill-hook
  - *auto-mode-alist*
  - *auto-mode-parameter-alist*
  - *auto-update-per-device-directory*
  - *before-delete-buffer-hook*
  - *before-find-file-hook*
  - *before-save-buffer-hook*
  - *brackets-is-wildcard-character*
  - *buffer-bar-context-menu*
  - *buffer-bar-context-menu-buffer*
  - *buffer-bar-context-menu-handler*
  - *buffer-bar-selected-buffer-to-first*
  - *buffer-info-variable-list*
  - *buffer-menu-mode-hook*
  - *buffer-package*
  - *change-buffer-colors-hook*
  - *char-encoding-list*
  - *command-line-mailto-hook*
  - *command-output-mode-hook*
  - *create-buffer-hook*
  - *dabbrev-search-this-buffer-only*
  - *dabbrevs-no-undo*
  - *deactivate-hook*
  - *default-buffer-mode*
  - *default-eol-code*
  - *default-fileio-encoding*
  - *default-load-path*
  - *default-session-directory*
  - *default-write-file-directory*
  - *delete-buffer-hook*
  - *diff-mode-hook*
  - *do-completion
  - *drag-and-drop-hook*
  - *enter-minibuffer-hook*
  - *eol-cr*
  - *eol-crlf*
  - *eol-lf*
  - *error-regexp-list*
  - *etc-path*
  - *executing-macro*
  - *exit-minibuffer-hook*
  - *features*
  - *filer-chdir-hook*
  - *filer-chdir-primary-p*
  - *filer-click-toggle-marks-always*
  - *filer-directories*
  - *filer-drag-and-drop-helper
  - *filer-dual-window*
  - *filer-eat-esc*
  - *filer-echo-filename*
  - *filer-format-comma*
  - *filer-guide-text*
  - *filer-last-command-char*
  - *filer-last-file-mask*
  - *filer-left-window-p*
  - *filer-mark-file-size-unit*
  - *filer-modal*
  - *filer-path-masks*
  - *filer-primary-directory*
  - *filer-primary-file-mask*
  - *filer-retrieve-icon*
  - *filer-secondary-directory*
  - *filer-secondary-file-mask*
  - *filer-use-recycle-bin*
  - *find-file-auto-mode-function*
  - *find-file-file-not-found-hook*
  - *find-file-hooks*
  - *find-file-no-auto-encoding*
  - *find-file-read-only-hook*
  - *find-other-file-requires-file-name*
  - *full-keymap-length*
  - *gensym-counter*
  - *global-abbrev-table*
  - *global-keymap*
  - *gmark-keep-column*
  - *grep-directory-name-hook*
  - *grep-hook*
  - *grepd-hook*
  - *gresreg-directory-name-hook*
  - *history-file-name*
  - *ime-mode-hook*
  - *inhibit-quit*
  - *init-app-menus-hook*
  - *isearch-scanner-hook*
  - *kbd-translate-table*
  - *keyboard*
  - *keyword-load-path*
  - *kill-buffer-kills-scratch*
  - *kill-ring*
  - *kill-ring-max*
  - *kill-xyzzy-hook*
  - *last-command*
  - *lisp-popup-completion-list*
  - *load-history-hook*
  - *load-path*
  - *load-pathname*
  - *local-abbrev-table*
  - *make-backup-filename-hook*
  - *menu-display-length*
  - *minibuffer-buffer-name-history*
  - *minibuffer-directory-name-history*
  - *minibuffer-execute-history*
  - *minibuffer-file-name-history*
  - *minibuffer-lisp-sexp-history*
  - *minibuffer-popup-completion-list*
  - *minibuffer-save-ime-status*
  - *minibuffer-search-string-history*
  - *minibuffer-symbol-name-history*
  - *minor-mode-alist*
  - *modal-filer-save-position*
  - *modal-filer-save-size*
  - *modules*
  - *move-forward-after-undo-deletion*
  - *next-buffer-in-tab-order*
  - *next-screen-context-lines*
  - *package*
  - *page-scroll-half-window*
  - *page-scroll-keep-window-position*
  - *popup-completion-list-default*
  - *post-command-hook*
  - *post-startup-hook*
  - *pre-abbrev-expand-hook*
  - *pre-command-hook*
  - *pre-startup-hook*
  - *prefix-args*
  - *prefix-value*
  - *print-circle*
  - *print-completion-list-hook*
  - *print-length*
  - *print-option-show-dialog*
  - *print-pretty*
  - *process-command-line-hook*
  - *query-kill-buffer-hook*
  - *query-kill-xyzzy-hook*
  - *quotation-prefix*
  - *random-state*
  - *readtable*
  - *rectangle-kill-buffer*
  - *save-buffer-no-filenames-hook*
  - *save-history*
  - *save-history-hook*
  - *save-resume-info*
  - *scroll-bar-step*
  - *select-pseudo-frame-hook*
  - *selection-ring*
  - *show-cursor-line-always*
  - *show-match-hook*
  - *show-matched-parenthesis*
  - *smart-indentation*
  - *standard-input*
  - *standard-output*
  - *status-bar-format*
  - *std-control-default-char*
  - *std-control-down-char*
  - *std-control-next-char*
  - *std-control-prior-char*
  - *std-control-up-char*
  - *tail-f-mode-hook*
  - *this-command*
  - *unicode-to-half-width*
  - *wrap-search*
  - +
  - -
  - /
  - /=
  - 1+
  - 1-
  - :case-fold
  - :key
  - :no-dup
  - :regexp
  - :reverse
  - :right-bound
  - :tail
  - :test
  - :test-not
  - <
  - <=
  - =
  - >
  - >=
  - BS  C-h ɕʁX̋@\蓖Ăɂ́H
  - C-z ŃACRɂ́H
  - DOS̃R}hLbNČʂ𕶎ɂɂ́H
  - Emacs ݊ł͂ȂK\͌\̂ł傤H
  - OLEI[g[V̎gp
  - ``'(backquote)
  - abbrev-mode
  - abbreviate-display-string
  - abs
  - acons
  - acos
  - acosh
  - activate-xyzzy-window
  - add-file-history-to-menu
  - add-history
  - add-hook
  - add-menu-item
  - add-menu-separator
  - add-popup-menu
  - adjoin
  - adjustable-array-p
  - alpha-char-p
  - alphanumericp
  - and
  - append
  - append-file
  - append-rectangle
  - append-to-register
  - append-trail-slash
  - apply
  - apps-popup
  - apropos
  - archiver-dll-config-dialog
  - archiver-dll-version
  - aref
  - array-dimension
  - array-dimensions
  - array-element-type
  - array-has-fill-pointer-p
  - array-rank
  - array-row-major-index
  - array-total-size
  - arrayp
  - ash
  - asin
  - asinh
  - assoc
  - assoc-if
  - assoc-if-not
  - atan
  - atanh
  - atom
  - auto-fill-hook
  - auto-fill-mode
  - auto-save
  - autoload
  - autoload-function-p
  - back-to-indentation
  - backward-char
  - backward-delete-char-untabify
  - backward-delete-char-untabify-or-selection
  - backward-kill-paragraph
  - backward-kill-word
  - backward-line
  - backward-page
  - backward-paragraph
  - backward-sexp
  - backward-virtual-line
  - backward-word
  - base64-decode-region
  - base64-decode-region-to-file
  - beginning-of-buffer
  - beginning-of-defun
  - beginning-of-line
  - beginning-of-virtual-line
  - block
  - bobp
  - bolp
  - both-case-p
  - boundp
  - broadcast-stream-streams
  - buffer-can-redo-p
  - buffer-can-undo-p
  - buffer-eol-code
  - buffer-fileio-encoding
  - buffer-fold-width
  - buffer-lines
  - buffer-list
  - buffer-local-value
  - buffer-menu
  - buffer-mode
  - buffer-modified-count
  - buffer-modified-p
  - buffer-name
  - buffer-process
  - buffer-read-only
  - buffer-selector
  - buffer-size
  - buffer-stream-buffer
  - buffer-stream-p
  - buffer-stream-point
  - buffer-stream-set-point
  - buffer-substring
  - bufferp
  - bury-buffer
  - butlast
  - byte
  - byte-position
  - byte-size
  - caaaar
  - caaadr
  - caaar
  - caadar
  - caaddr
  - caadr
  - caar
  - cadaar
  - cadadr
  - cadar
  - caddar
  - cadddr
  - caddr
  - cadr
  - calendar
  - call-arguments-limit
  - call-interactively
  - call-last-kbd-macro
  - call-menu
  - call-process
  - capitalize-region
  - capitalize-word
  - car
  - case
  - catch
  - cd
  - cdaaar
  - cdaadr
  - cdaar
  - cdadar
  - cdaddr
  - cdadr
  - cdar
  - cddaar
  - cddadr
  - cddar
  - cdddar
  - cddddr
  - cdddr
  - cddr
  - cdr
  - ceiling
  - char
  - char-after
  - char-before
  - char-code
  - char-code-limit
  - char-columns
  - char-downcase
  - char-equal
  - char-greaterp
  - char-lessp
  - char-name
  - char-not-equal
  - char-not-greaterp
  - char-not-lessp
  - char-unicode
  - char-upcase
  - char/=
  - char<
  - char<=
  - char=
  - char>
  - char>=
  - character
  - characterp
  - check-type
  - check-valid-pathname
  - cis
  - clear-all-text-attributes
  - clear-all-text-colors
  - clear-input
  - clear-message
  - clear-minibuffer-message
  - clear-rectangle
  - clear-rectangle-selection
  - clear-reverse-region
  - clear-undo-boundary
  - close
  - close-session
  - close-session-dialog
  - clrhash
  - code-char
  - coerce
  - command-apropos
  - command-execute
  - command-keys
  - command-output-alternate-send-input
  - command-output-mode
  - command-output-send-input
  - commandp
  - compare-buffer-substrings
  - compile-file-pathname
  - compile-regexp
  - compile-regexp ƈꉞł傤H
  - compile-regexp-keyword-list
  - compiled-function-p
  - compiled-regexp-case-fold-p
  - compiled-regexp-source
  - complement
  - completing-read
  - complex
  - complexp
  - concat
  - concatenate
  - concatenated-stream-streams
  - cond
  - conjugate
  - connect
  - cons
  - consp
  - constantp
  - continue-popup
  - convert-encoding-from-internal
  - convert-encoding-to-internal
  - copy-alist
  - copy-file
  - copy-keymap
  - copy-list
  - copy-menu-items
  - copy-readtable
  - copy-rectangle
  - copy-rectangle-selection
  - copy-rectangle-selection-to-clipboard
  - copy-rectangle-to-register
  - copy-region-as-kill
  - copy-region-to-clipboard
  - copy-selection
  - copy-selection-to-clipboard
  - copy-seq
  - copy-string
  - copy-symbol
  - copy-syntax-table
  - copy-to-clipboard
  - copy-to-register
  - cos
  - cosh
  - count
  - count-buffers
  - count-column
  - count-if
  - count-if-not
  - count-windows
  - count-xyzzy-instance
  - create-archive
  - create-directory
  - create-file-buffer
  - create-menu
  - create-new-buffer
  - create-popup-menu
  - create-shortcut
  - create-shortcut-to-desktop
  - create-tab-bar
  - create-tool-bar
  - ctl-x-4-map
  - ctl-x-4-prefix
  - ctl-x-6-map
  - ctl-x-6-prefix
  - ctl-x-map
  - ctl-x-prefix
  - current-column
  - current-line-columns
  - current-line-number
  - current-menu
  - current-virtual-column
  - current-virtual-line-number
  - current-window-configuration
  - cwd
  - dabbrev-expand
  - dabbrev-popup
  - dde-execute
  - dde-initiate
  - dde-poke
  - dde-request
  - dde-terminate
  - decf
  - declaim
  - declare
  - decode-escape-sequence
  - decode-mime-header
  - decode-universal-time
  - default-directory
  - default-value
  - defconstant
  - define-abbrev-table
  - define-command-bar
  - define-condition
  - define-history-variable
  - define-key
  - define-menu
  - define-popup-menu
  - defmacro
  - defpackage
  - defparameter
  - defstruct
  - deftype
  - defun
  - defvar
  - defvar-local
  - delete
  - delete-all-pseudo-frames
  - delete-backward-char
  - delete-backward-char-or-selection
  - delete-blank-lines
  - delete-buffer
  - delete-char
  - delete-char-or-selection
  - delete-command-bar
  - delete-directory
  - delete-duplicates
  - delete-file
  - delete-file-in-archive
  - delete-hook
  - delete-horizontal-spaces
  - delete-if
  - delete-if-not
  - delete-indentation
  - delete-last-ime-composition
  - delete-marker
  - delete-menu
  - delete-other-windows
  - delete-package
  - delete-pseudo-frame
  - delete-rectangle
  - delete-rectangle-selection
  - delete-region
  - delete-text-attribute-point
  - delete-text-attributes
  - delete-text-attributes-if
  - delete-text-attributes-if-not
  - delete-tool-bar
  - delete-trailing-spaces
  - delete-window
  - deleted-buffer-p
  - denominator
  - deposit-field
  - describe-bindings
  - describe-function
  - describe-key
  - describe-key-briefly
  - describe-variable
  - detect-char-encoding
  - dialog
  - dialog-box
  - digit-argument
  - digit-char
  - digit-char-p
  - ding
  - directory
  - directory-name-dialog
  - directory-namestring
  - display-first-tab-char
  - display-newline-char
  - display-rest-tab-char
  - do
  - do*
  - do-all-symbols
  - do-completion
  - do-events
  - do-external-symbols
  - do-symbols
  - dolist
  - dotimes
  - double-float-p
  - down-list
  - downcase-region
  - downcase-word
  - dpb
  - drive-dialog
  - dump-xyzzy
  - echo-stream-input-stream
  - echo-stream-output-stream
  - ed::*auto-save-session-file*
  - ed::*last-search-regexp*
  - ed::*last-search-string*
  - ed::*register-alist*
  - ed::build-summary-function
  - ed::find-file-internal
  - ed::get-register
  - ed::get-selection-start-end
  - ed::map-selection
  - ed::pseudo-frame
  - ed::set-register
  - ed::toggle-mode
  - eighth
  - eject-media
  - elt
  - emacs-write-file
  - enable-post-buffer-modified-hook
  - encode-universal-time
  - end-of-buffer
  - end-of-defun
  - end-of-line
  - end-of-virtual-line
  - endp
  - enlarge-window
  - enlarge-window-horizontally
  - enum-buffers
  - eobp
  - eolp
  - eq
  - eql
  - equal
  - equalp
  - erase-buffer
  - error
  - esc-map
  - etc-path
  - eval
  - eval-buffer
  - eval-expression
  - eval-region
  - eval-when
  - evenp
  - every
  - exchange-point-and-mark
  - execute-extended-command
  - execute-region
  - execute-shell-command
  - execute-subprocess
  - exp
  - expand-abbrev
  - export
  - expt
  - extended-alphabet-char-p
  - extract-archive
  - fast-scroll-down
  - fast-scroll-up
  - fboundp
  - fceiling
  - featurep
  - ffloor
  - fifth
  - file-directory-p
  - file-executable-p
  - file-exist-p
  - file-length
  - file-name-dialog
  - file-namestring
  - file-newer-than-file-p
  - file-position
  - file-property
  - file-readable-p
  - file-visited-p
  - file-writable-p
  - file-write-time
  - filer
  - filer-calc-directory-byte-size
  - filer-calc-directory-size
  - filer-cancel
  - filer-clear-all-marks
  - filer-close
  - filer-context-menu
  - filer-count-marks
  - filer-current-file-directory-p
  - filer-current-file-dot-dot-p
  - filer-demand-reload
  - filer-dual-window-p
  - filer-forward-line
  - filer-forward-page
  - filer-get-current-file
  - filer-get-directory
  - filer-get-drive
  - filer-get-mark-files
  - filer-get-sort-order
  - filer-get-text
  - filer-goto-bof
  - filer-goto-eof
  - filer-goto-file
  - filer-isearch
  - filer-left-window
  - filer-left-window-p
  - filer-mark
  - filer-mark-all
  - filer-mark-match-files
  - filer-modal-p
  - filer-modify-column-width
  - filer-read-char
  - filer-reload
  - filer-right-window
  - filer-scroll-left
  - filer-scroll-right
  - filer-set-directory
  - filer-set-file-mask
  - filer-set-text
  - filer-sort
  - filer-subscribe-to-reload
  - filer-swap-windows
  - filer-toggle-all-marks
  - filer-toggle-mark
  - filer-viewer
  - fill
  - fill-column
  - fill-paragraph
  - fill-pointer
  - fill-region
  - fill-region-as-paragraph
  - fill-region-hook
  - filter-buffer
  - filter-region
  - find
  - find-all-symbols
  - find-buffer
  - find-file
  - find-file-in-archive
  - find-file-other-window
  - find-file-read-only
  - find-if
  - find-if-not
  - find-load-path
  - find-name-buffer
  - find-other-file
  - find-package
  - find-pseudo-frame
  - find-symbol
  - find-text-attribute
  - find-text-attribute-if
  - find-text-attribute-if-not
  - find-text-attribute-point
  - first
  - first-error
  - flet
  - float
  - floatp
  - floor
  - fmakunbound
  - focus-tool-bar
  - following-char
  - format
  - format-date
  - format-date-string
  - format-drive
  - forward-char
  - forward-line
  - forward-list
  - forward-page
  - forward-paragraph
  - forward-sexp
  - forward-virtual-line
  - forward-word
  - fourth
  - fresh-line
  - fround
  - ftruncate
  - funcall
  - function
  - functionp
  - gc
  - gcd
  - gensym
  - gentemp
  - get
  - get-alternate-file-buffer
  - get-buffer-alternate-file-name
  - get-buffer-create
  - get-buffer-file-name
  - get-buffer-window
  - get-clipboard-data
  - get-decoded-time
  - get-disk-usage
  - get-dispatch-macro-character
  - get-file-attributes
  - get-file-buffer
  - get-file-info
  - get-image-size
  - get-ime-mode
  - get-internal-real-time
  - get-local-window-flags
  - get-macro-character
  - get-menu
  - get-menu-position
  - get-next-buffer
  - get-properties
  - get-selection-type
  - get-short-path-name
  - get-special-folder-location
  - get-system-directory
  - get-universal-time
  - get-window-handle
  - get-window-line
  - get-window-start-line
  - get-windows-directory
  - getf
  - gethash
  - gethash-region
  - global-set-key
  - global-unset-key
  - go
  - goal-column
  - goto-bol
  - goto-char
  - goto-column
  - goto-eol
  - goto-last-modified-line
  - goto-line
  - goto-marker
  - goto-matched-parenthesis
  - goto-virtual-bol
  - goto-virtual-column
  - goto-virtual-eol
  - goto-virtual-line
  - graphic-char-p
  - handler-case
  - hash-table-count
  - hash-table-p
  - hash-table-rehash-size
  - hash-table-size
  - hash-table-test
  - hide-command-bar
  - hide-restricted-region
  - hide-tool-bar
  - html-highlight-mode
  - if
  - ignore-errors
  - ignored-extensions
  - imagpart
  - ime-push-composition-string
  - ime-register-word-dialog
  - import
  - in-package
  - incf
  - indent-for-comment
  - indent-region
  - indent-relative
  - indent-to
  - insert
  - insert-buffer
  - insert-buffer-substring
  - insert-file
  - insert-file-contents
  - insert-menu-item
  - insert-menu-separator
  - insert-popup-menu
  - insert-register
  - integer-length
  - integerp
  - interactive
  - interactive-p
  - intern
  - internal-time-units-per-second
  - intersection
  - isqrt
  - jump-to-register
  - just-one-space
  - kana-char-p
  - kanji-char-p
  - kept-undo-information
  - key-to-string
  - keymapp
  - keywordp
  - kill-all-buffers
  - kill-all-local-variables
  - kill-buffer
  - kill-line
  - kill-local-variable
  - kill-paragraph
  - kill-process
  - kill-rectangle
  - kill-rectangle-selection
  - kill-rectangle-selection-to-clipboard
  - kill-region
  - kill-region-to-clipboard
  - kill-selected-buffer
  - kill-selection
  - kill-selection-to-clipboard
  - kill-subprocess
  - kill-word
  - kinsoku-bol-chars
  - kinsoku-eol-chars
  - kinsoku-extend-limit
  - kinsoku-goto-column
  - kinsoku-mode
  - kinsoku-shorten-limit
  - lambda
  - lambda-list-keywords
  - lambda-parameters-limit
  - last
  - launch-application
  - lcm
  - ldb
  - ldb-test
  - ldiff
  - length
  - let
  - let*
  - lisp-complete-symbol
  - lisp-indent-hook
  - list
  - list*
  - list-all-packages
  - list-archive
  - list-function
  - list-length
  - list-server-resources
  - list-servers
  - list-text-attributes
  - list-tool-bars
  - list-xyzzy-windows
  - listen
  - listp
  - load-file
  - load-keyword-file
  - load-library
  - load-session
  - local-keymap
  - local-set-key
  - local-unset-key
  - local-variable-p
  - lock-file
  - log
  - logand
  - logandc1
  - logandc2
  - logeqv
  - logior
  - lognand
  - lognor
  - lognot
  - logorc1
  - logorc2
  - logxor
  - long-float-p
  - long-operation
  - looking-at
  - looking-back
  - looking-for
  - lookup-dictionary
  - lookup-key-command
  - lookup-keymap
  - loop
  - lower-case-p
  - machine-name
  - macro-function
  - macroexpand
  - macroexpand-1
  - macrolet
  - make-array
  - make-backup-files
  - make-broadcast-stream
  - make-buffer-stream
  - make-concatenated-stream
  - make-condition
  - make-dispatch-macro-character
  - make-echo-stream
  - make-hash-table
  - make-keymap
  - make-list
  - make-list-from-keyword-table
  - make-local-variable
  - make-marker
  - make-package
  - make-process
  - make-random-state
  - make-sequence
  - make-sparse-keymap
  - make-string-input-stream
  - make-symbol
  - make-syntax-table
  - make-temp-file-name
  - make-two-way-stream
  - make-variable-buffer-local
  - make-vector
  - makunbound
  - map
  - map-backslash-to-slash
  - map-char-encoding-region
  - map-into
  - map-slash-to-backslash
  - mapc
  - mapcan
  - mapcar
  - mapcon
  - maphash
  - mapl
  - maplist
  - mark
  - mark-dialog-box
  - mark-page
  - mark-paragraph
  - mark-sexp
  - mark-whole-buffer
  - mark-word
  - marker-buffer
  - marker-point
  - markerp
  - mask-field
  - match-beginning
  - match-data
  - match-end
  - match-string
  - max
  - mc-autoload
  - mc-load-file
  - mc-load-library
  - member
  - member-if
  - member-if-not
  - menup
  - merge
  - merge-pathnames
  - message
  - message-box
  - meta-prefix
  - min
  - minibuffer-message
  - minibuffer-prompt
  - minibuffer-window
  - minibuffer-window-p
  - minor-mode-map
  - minusp
  - mismatch
  - mod
  - mode-line-format
  - mode-name
  - mode-specific-indent-command
  - modify-text-attributes
  - modify-text-attributes-if
  - modify-text-attributes-if-not
  - mouse-menu-popup
  - msgbox
  - multiple-value-bind
  - multiple-value-call
  - multiple-value-list
  - multiple-value-prog1
  - multiple-value-setq
  - namestring
  - narrow-to-region
  - nbutlast
  - nconc
  - need-buffer-save-p
  - need-not-save
  - negative-argument
  - new-file
  - new-pseudo-frame
  - newline
  - newline-and-indent
  - next-buffer
  - next-error
  - next-line
  - next-line-add-newlines
  - next-page
  - next-pseudo-frame
  - next-virtual-line
  - next-window
  - next-word
  - next-xyzzy-window
  - nil
  - nintersection
  - ninth
  - no-or-yes-p
  - not
  - not-modified
  - notany
  - notevery
  - nreconc
  - nreverse
  - nset-difference
  - nset-exclusive-or
  - nstring-capitalize
  - nstring-downcase
  - nstring-upcase
  - nsublis
  - nsubst
  - nsubst-if
  - nsubst-if-not
  - nsubstitute
  - nsubstitute-if
  - nsubstitute-if-not
  - nth
  - nthcdr
  - null
  - number-of-function-bar-labels
  - numberp
  - numerator
  - nunion
  - oddp
  - open
  - open-filer
  - open-line
  - open-network-stream
  - open-rectangle
  - open-rectangle-selection
  - open-session-dialog
  - open-stream-p
  - operate-on-rectangle
  - operate-on-rectangle-selection
  - or
  - os-build-number
  - os-csd-version
  - os-major-version
  - os-minor-version
  - os-platform
  - other-buffer
  - other-pseudo-frame
  - other-window
  - overwrite-char
  - overwrite-mode
  - overwrite-rectangle
  - package-name
  - package-use-list
  - package-used-by-list
  - packagep
  - pairlis
  - parse-integer
  - parse-point-syntax
  - paste-from-clipboard
  - paste-rectangle-from-clipboard
  - path-equal
  - pathname-device
  - pathname-directory
  - pathname-host
  - pathname-match-p
  - pathname-name
  - pathname-type
  - peek-char
  - perform-replace
  - phase
  - pipe-command
  - plain-error
  - plusp
  - point
  - point-marker
  - point-max
  - point-min
  - point-to-register
  - pop
  - pop-to-buffer
  - popup-list
  - popup-string
  - pos-not-visible-in-window-p
  - pos-visible-in-window-p
  - position
  - position-if
  - position-if-not
  - post-buffer-modified-hook
  - post-buffer-modified-hook-enabled-p
  - pre-selection-p
  - preceding-char
  - prepend-to-register
  - previous-buffer
  - previous-line
  - previous-page
  - previous-pseudo-frame
  - previous-virtual-line
  - previous-window
  - previous-word
  - previous-xyzzy-window
  - prin1
  - princ
  - print-buffer
  - print-dialog
  - process-buffer
  - process-eol-code
  - process-exit-code
  - process-filter
  - process-incode
  - process-marker
  - process-outcode
  - process-send-n
  - process-send-string
  - process-send-y
  - process-sentinel
  - process-status
  - processp
  - proclaim
  - prog
  - prog*
  - prog1
  - prog2
  - progn
  - provide
  - psetq
  - pseudo-frame-selector
  - push
  - pushnew
  - quietly-read-abbrev-file
  - quit
  - quote
  - quote-char
  - quote-region
  - quote-string
  - quoted-printable-decode-region
  - quoted-printable-decode-region-to-file
  - random
  - rassoc
  - rassoc-if
  - rassoc-if-not
  - rational
  - rationalize
  - rationalp
  - re-search-backward
  - re-search-backward-again
  - re-search-forward
  - re-search-forward-again
  - read
  - read-as-string
  - read-buffer-name
  - read-char
  - read-char-encoding
  - read-char-no-hang
  - read-command-name
  - read-delimited-list
  - read-directory-name
  - read-exact-char-encoding
  - read-exist-buffer-name
  - read-exist-file-name
  - read-file
  - read-file-name
  - read-file-name-list
  - read-from-string
  - read-function-name
  - read-integer
  - read-into
  - read-line
  - read-line-into
  - read-preserving-whitespace
  - read-registry
  - read-sexp
  - read-string
  - read-symbol-name
  - read-variable-name
  - readtable-case
  - readtablep
  - realp
  - realpart
  - recenter
  - redo
  - reduce
  - refresh-screen
  - refresh-tool-bars
  - regexp-keyword-list
  - regexp-quote
  - regexpp
  - region-beginning
  - region-end
  - register-history-variable
  - rem
  - remhash
  - remove
  - remove-duplicates
  - remove-if
  - remove-if-not
  - remove-trail-slash
  - remprop
  - rename
  - rename-buffer
  - rename-file
  - rename-pseudo-frame
  - repeat-backward-search
  - repeat-complex-command
  - repeat-forward-search
  - replace
  - replace-buffer
  - replace-match
  - replace-string
  - require
  - resolve-shortcut
  - rest
  - restore-window-configuration-register
  - return
  - return-from
  - revappend
  - reverse
  - reverse-region
  - rewind-ime-composition
  - rotatef
  - round
  - row-major-aref
  - rplaca
  - rplacd
  - run-console
  - run-hook-with-args
  - run-hook-with-args-until-success
  - run-hook-with-args-while-success
  - run-hooks
  - safe-caaaar
  - safe-caaadr
  - safe-caaar
  - safe-caadar
  - safe-caaddr
  - safe-caadr
  - safe-caar
  - safe-cadaar
  - safe-cadadr
  - safe-cadar
  - safe-caddar
  - safe-cadddr
  - safe-caddr
  - safe-cadr
  - safe-car
  - safe-cdaaar
  - safe-cdaadr
  - safe-cdaar
  - safe-cdadar
  - safe-cdaddr
  - safe-cdadr
  - safe-cdar
  - safe-cddaar
  - safe-cddadr
  - safe-cddar
  - safe-cdddar
  - safe-cddddr
  - safe-cdddr
  - safe-cddr
  - safe-cdr
  - save-all-buffers
  - save-all-buffers-kill-xyzzy
  - save-buffer
  - save-buffers-kill-xyzzy
  - save-excursion
  - save-restriction
  - save-session
  - save-session-dialog
  - save-some-buffers
  - save-window-configuration-to-register
  - save-window-excursion
  - scan-buffer
  - schar
  - screen-height
  - screen-width
  - scroll-down-both-window
  - scroll-down-other-window
  - scroll-left
  - scroll-other-window
  - scroll-right
  - scroll-up-both-window
  - scroll-up-other-window
  - scroll-window
  - scroll-window-horizontally
  - search-backward
  - search-backward-again
  - search-forward
  - search-forward-again
  - second
  - select-buffer
  - select-pseudo-frame
  - selected-buffer
  - selected-pseudo-frame
  - selected-window
  - selection-backward-char
  - selection-backward-word
  - selection-beginning-of-buffer
  - selection-beginning-of-line
  - selection-beginning-of-virtual-line
  - selection-end-of-buffer
  - selection-end-of-line
  - selection-end-of-virtual-line
  - selection-forward-char
  - selection-forward-word
  - selection-mark
  - selection-next-page
  - selection-next-virtual-line
  - selection-paragraph
  - selection-point
  - selection-previous-page
  - selection-previous-virtual-line
  - selection-start-end
  - selection-whole-buffer
  - self-insert-command
  - sequencep
  - set
  - set-buffer
  - set-buffer-alternate-file-name
  - set-buffer-colors
  - set-buffer-eol-code
  - set-buffer-file-name
  - set-buffer-fileio-encoding
  - set-buffer-fold-type-column
  - set-buffer-fold-type-column-update
  - set-buffer-fold-type-none
  - set-buffer-fold-type-none-update
  - set-buffer-fold-type-window
  - set-buffer-fold-type-window-update
  - set-buffer-fold-width
  - set-buffer-modified-p
  - set-default
  - set-default-directory
  - set-default-fold-width
  - set-difference
  - set-dispatch-macro-character
  - set-exclusive-or
  - set-extended-key-translate-table
  - set-file-write-time
  - set-fill-column
  - set-fill-prefix
  - set-function-bar-label
  - set-goal-column
  - set-kinsoku-chars
  - set-local-window-flags
  - set-macro-character
  - set-mark
  - set-mark-command
  - set-marker
  - set-menu
  - set-meta-bit
  - set-minor-mode-map
  - set-number-of-function-bar-labels
  - set-per-device-directory
  - set-process-eol-code
  - set-process-filter
  - set-process-incode
  - set-process-outcode
  - set-process-sentinel
  - set-syntax-comment-column
  - set-syntax-end-c++-comment
  - set-syntax-end-comment
  - set-syntax-end-multi-comment
  - set-syntax-escape
  - set-syntax-from-char
  - set-syntax-junk
  - set-syntax-match
  - set-syntax-math
  - set-syntax-option
  - set-syntax-punctuation
  - set-syntax-quote
  - set-syntax-start-c++-comment
  - set-syntax-start-column-comment
  - set-syntax-start-comment
  - set-syntax-start-multi-comment
  - set-syntax-string
  - set-syntax-symbol
  - set-syntax-symbol-prefix
  - set-syntax-tag
  - set-syntax-whitespace
  - set-syntax-word
  - set-tab-columns
  - set-text-attribute
  - set-text-color
  - set-variable
  - set-window
  - set-window-configuration
  - set-window-flags
  - setf
  - setq
  - setq-default
  - setup-temp-buffer
  - seventh
  - shell-execute
  - shift-region
  - shiftf
  - short-float-p
  - show-command-bar
  - show-html-help
  - show-tool-bar
  - show-winhelp
  - shrink-window
  - shrink-window-horizontally
  - si:*activate-toplevel
  - si:*builtin-function-p
  - si:*load-library
  - si:*paste-hook*
  - si:*set-readtable-case
  - si:*stream-line-number
  - si:base64-decode
  - si:base64-encode
  - si:canonicalize-type
  - si:closure-variable
  - si:dump-image-path
  - si:getenv
  - si:make-chunk
  - si:make-string-chunk
  - si:md5
  - si:quoted-printable-decode
  - si:system-root
  - si:unpack-string
  - si:uudecode
  - si:uuencode
  - si:www-url-decode
  - si:www-url-encode
  - signal-process
  - signum
  - simple-string
  - simple-string-p
  - simple-vector-p
  - sin
  - single-float-p
  - sinh
  - sit-for
  - sixth
  - skip-chars-backward
  - skip-chars-forward
  - skip-syntax-spec-backward
  - skip-syntax-spec-forward
  - skip-token
  - skip-white-backward
  - skip-white-forward
  - sleep-for
  - smart-indentation
  - software-type
  - software-version
  - some
  - sort
  - spec-map
  - special
  - special-file-p
  - special-form-p
  - specific-command-prefix
  - split-line
  - split-string
  - split-window
  - split-window-vertically
  - sqrt
  - stable-sort
  - standard-char-p
  - start-selection
  - start-selection-as-line
  - start-selection-as-region
  - start-timer
  - start-xyzzy-server
  - step
  - stop-selection
  - stop-timer
  - stop-xyzzy-server
  - store-match-data
  - streamp
  - string
  - string-capitalize
  - string-downcase
  - string-equal
  - string-greaterp
  - string-left-trim
  - string-lessp
  - string-looking-at
  - string-match
  - string-matchp
  - string-not-equal
  - string-not-greaterp
  - string-not-lessp
  - string-rectangle
  - string-rectangle-selection
  - string-replace-match
  - string-right-trim
  - string-trim
  - string-upcase
  - string/=
  - string<
  - string<=
  - string=
  - string>
  - string>=
  - stringp
  - sub-directory-p
  - sublis
  - subseq
  - subsetp
  - subst
  - subst-if
  - subst-if-not
  - substitute
  - substitute-if
  - substitute-if-not
  - substitute-key-definition
  - substitute-string
  - substring
  - subtypep
  - svref
  - switch-pseudo-frame
  - switch-to-buffer
  - switch-to-buffer-other-window
  - symbol-function
  - symbol-name
  - symbol-package
  - symbol-plist
  - symbol-value
  - symbolp
  - syntax-c++-comment-p
  - syntax-close-p
  - syntax-close-tag-p
  - syntax-end-c++-comment-p
  - syntax-end-comment-p
  - syntax-end-multi-comment-1-p
  - syntax-end-multi-comment-2-p
  - syntax-escape-p
  - syntax-junk-p
  - syntax-math-p
  - syntax-open-p
  - syntax-open-tag-p
  - syntax-punctuation-p
  - syntax-quote-p
  - syntax-start-column-comment-p
  - syntax-start-comment-p
  - syntax-start-multi-comment-1-p
  - syntax-start-multi-comment-2-p
  - syntax-string-p
  - syntax-symbol-p
  - syntax-symbol-prefix-p
  - syntax-table
  - syntax-table-p
  - syntax-whitespace-p
  - syntax-word-p
  - t
  - tab-bar-add-item
  - tab-bar-current-item
  - tab-bar-delete-item
  - tab-bar-find-item
  - tab-bar-list-items
  - tab-bar-modify-item
  - tab-bar-select-item
  - tab-columns
  - tabify
  - tagbody
  - tail-f
  - tailp
  - tan
  - tanh
  - tenth
  - terpri
  - third
  - throw
  - title-bar-format
  - toggle-ime
  - toggle-over
  - toggle-read-only
  - toggle-session-auto-save
  - toggle-trace-on-error
  - tool-bar-exist-p
  - tool-bar-info
  - track-popup-menu
  - transpose-chars
  - transpose-lines
  - transpose-paragraphs
  - transpose-region
  - transpose-words
  - trap-errors
  - truename
  - truncate
  - two-way-stream-input-stream
  - two-way-stream-output-stream
  - type-of
  - typep
  - undefine-key
  - undefined
  - undo
  - undo-boundary
  - unexport
  - unicode-char
  - unintern
  - uninterned
  - union
  - universal-argument
  - unless
  - unread-char
  - unregister-history-variable
  - unset-marker
  - unset-minor-mode-map
  - unshift-region
  - untabify
  - unuse-package
  - unwind-protect
  - up-list
  - upcase-region
  - upcase-word
  - update-mode-line
  - upper-case-p
  - use-keymap
  - use-local-menu
  - use-package
  - use-syntax-table
  - user-config-path
  - user-homedir-pathname
  - user-name
  - uudecode-region
  - uudecode-region-to-file
  - valid-path-p
  - values
  - values-list
  - vconcat
  - vector
  - vector-pop
  - vector-push
  - vector-push-extend
  - vectorp
  - verify-visited-file-modtime
  - version-up-xyzzy
  - view-register
  - virtual-bolp
  - virtual-eolp
  - what-cursor-position
  - when
  - while
  - widen
  - wild-pathname-p
  - window-buffer
  - window-columns
  - window-coordinate
  - window-height
  - window-lines
  - window-width
  - windowp
  - with-hash-table-iterator
  - with-input-from-buffer
  - with-input-from-selected-buffer
  - with-input-from-string
  - with-interval-message
  - with-open-file
  - with-open-stream
  - with-output-to-buffer
  - with-output-to-selected-buffer
  - with-output-to-string
  - with-output-to-temp-buffer
  - with-package-iterator
  - with-selected-window
  - with-set-buffer
  - word-char-p
  - write
  - write-char
  - write-file
  - write-region
  - write-registry
  - wrong-disk
  - wrong-disk-pathname
  - xyzzy-dumped-p
  - xyzzyŒ񋟂ĂXg[̎
  - y-or-n-p
  - yank
  - yank-and-pop
  - yank-pop
  - yank-rectangle
  - yank-rectangle-as-region
  - yank-rectangle-selection
  - yank-selection
  - yank-selection-and-pop
  - yank-to-clipboard
  - yes-no-or-cancel-p
  - yes-or-no-p
  - zap-to-char
  - zerop
  - ǂ̊֐̓ɉ̂ł傤H
  - G[֌W
  - L[[ht@C̏
  - L[\gp\
  - R}hɂqXgύXɂ́H
  - `N̊Tv
  - obt@̓\
  - pbP[W
  - pbP[W̊Tv
  - t@C̗
  - ̃wb_tb^Ɋւ\L
  - e탍[h֌W̊֐̈Ⴂ
  - e팾L[}bv
  - Nt[
  - ^ꗗ
  - sԍON/OFF
  - K\̕\L

