Converted from C:/xyzzy/reference/reference.xml by xml2xxx.l at 06/03/29 11:12:27
======================================================================
*
[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
[Section    ]: ϐƒ萔
[Description]: 
obt@activateꂽƂɔCӂ̏s߂Ɏgp܂B
ftHgł̓t@C̏CtmFĂ܂B


*after-save-buffer-hook*
[Type       ]: Variable
[Package    ]: editor
[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-fill-hook
[Type       ]: Variable
[Package    ]: editor
[Seealso    ]: auto-fill-hook
[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ł͂ȂAfuncall̂Œӂ邱


*auto-mode-alist*
[Type       ]: Variable
[Package    ]: editor
[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-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
[File       ]: files.l
[Section    ]: ϐƒ萔
[Description]: 
find-file̍ŏŎs܂B
run-hook-with-args-until-successŎŝŒӂ邱


*before-save-buffer-hook*
[Type       ]: Variable
[Package    ]: editor
[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
[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@Eo[őIĂobt@łBAobt@Eo[
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@Eo[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-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*)


*change-buffer-colors-hook*
[Type       ]: Variable
[Package    ]: editor
[Section    ]: ϐƒ萔
[Description]: 
r


*char-encoding-list*
[Type       ]: Variable
[Package    ]: editor
[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* , nil
[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
[Section    ]: ϐƒ萔
[Description]: 
obt@deactivateꂽƂɔCӂ̏s߂Ɏgp
BftHgł̓Nbv{[h̓sĂ܂B


*default-buffer-mode*
[Type       ]: Variable
[Package    ]: editor
[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-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"))


*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Ƃ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*
[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*
[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*
[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
[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*
[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*
[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*
[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
[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-file-not-found-hook*
[Type       ]: Variable
[Package    ]: editor
[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
[File       ]: files.l
[Section    ]: ϐƒ萔
[Description]: 
find-file̍ŌŎs܂B


*find-file-read-only-hook*
[Type       ]: Variable
[Package    ]: editor
[File       ]: files.l
[Section    ]: ϐƒ萔
[Description]: 
find-file-read-only̒ŌĂяo܂B

QlF
  (run-hooks '*find-file-read-only-hook*)


*gensym-counter*
[Type       ]: Variable
[Package    ]: lisp
[Seealso    ]: gensym
[File       ]: evalmacs.l
[Section    ]: V{
[Description]: 
gensym ōV{̖OɂłB
g邽тɃCNg܂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*
[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
[File       ]: gresregd.l
[Section    ]: ϐƒ萔
[Description]: 
gresreg-dialoggresregΏۂ̃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


*ime-mode-hook*
[Type       ]: Variable
[Package    ]: editor
[Seealso    ]: toggle-ime
[Section    ]: [h
[Description]: 
IME̐ؑւɌĂяo܂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
[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
[Section    ]: o
[Description]: 
L[{[h̓͂\Xg[łB


*keyword-load-path*
[Type       ]: Variable
[Package    ]: editor
[Seealso    ]: *etc-path*
[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
[File       ]: region.l
[Section    ]: [W
[Description]: 
killi[܂B
*kill-ring*͒*kill-ring-max*ł郊Oobt@łB


*kill-ring-max*
[Type       ]: Variable
[Package    ]: editor
[File       ]: region.l
[Section    ]: [W
[Description]: 
killŕۑłB*kill-ring*̒łB


*kill-xyzzy-hook*
[Type       ]: Variable
[Package    ]: editor
[Seealso    ]: *query-kill-xyzzy-hook*
[Section    ]: ϐƒ萔
[Description]: 
xyzzy̏IɎs܂B


*last-command*
[Type       ]: Variable
[Package    ]: editor
[Section    ]: ϐƒ萔
[Description]: 
ŌɎsR}hĂ܂BO*this-command*̒lݒ肳܂B


*lisp-popup-completion-list*
[Type       ]: Variable
[Package    ]: editor
[Seealso    ]: lisp-complete-symbol
[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*
[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


*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
[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
[Section    ]: t@C
[Description]: 
[_Ńt@C𓮍삳ĂƂ́At@CI̓ݒ肵܂B

  t   傫ۑ܂
  nil 傫ۑ܂


*modules*
[Type       ]: Variable
[Package    ]: lisp
[Seealso    ]: provide , require
[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
[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
[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
[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*
[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*
[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*
[Section    ]: ϐƒ萔
[Description]: 
R}htŌĂ΂ꂽɐl܂B


*print-circle*
[Type       ]: Variable
[Package    ]: lisp
[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
[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
[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
[File       ]: region.l
[Section    ]: eLXg
[Description]: 
p\ړqłB̓Iɂ́Aquote-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


*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
[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


*select-pseudo-frame-hook*
[Type       ]: Variable
[Package    ]: editor
[Seealso    ]: t[̊Tv , new-pseudo-frame , select-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
[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
[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
[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
[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
[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
[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)                 => #\L


*wrap-search*
[Type       ]: Variable
[Package    ]: editor
[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    ]: *
[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    ]: ϐƒ萔
[Description]: 



: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    ]: /=
[File       ]: builtin.l
[Section    ]: l
[Description]: 
ׂē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


abbrev-mode
[Type       ]: Function
[Arguments  ]: abbrev-mode &optional (ARG () SV)
[Package    ]: editor
[Seealso    ]: quietly-read-abbrev-file
[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
[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


add-file-history-to-menu
[Type       ]: Function
[Arguments  ]: add-file-history-to-menu
[Package    ]: editor
[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
[File       ]: minibuf.l
[Section    ]: ϐƒ萔
[Description]: 
iڍוsj

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
[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
[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
[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    ]: 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    ]: alphanumericp
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
p[A-Za-z]ǂ𔻒肵܂B

  CHAR : 肷镶


alphanumericp
[Type       ]: Function
[Arguments  ]: alphanumericp CHAR
[Package    ]: lisp
[Seealso    ]: alpha-char-p
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
p[A-Za-z0-9]ǂ𔻒肵܂B

  CHAR : 肷镶


and
[Type       ]: Macro
[Arguments  ]: and {FORM}*
[Package    ]: lisp
[Seealso    ]: or
[File       ]: evalmacs.l
[Section    ]: \
[Description]: 
tH[nilłȂԂԂɕ]܂B
tH[łnilȂ΁Aŕ]𒆒fnilԂďI܂B
SẴtH[nilłȂ΁AŌɎstH[̒lԂ܂B

  ;;; exp1 not-nilȂ exp2sA
  ;;; exp2 not-nilȂ exp3sA
  ;;; exp3 not-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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
̊֐́ALISTS ̑Svf܂ރXgԂ܂BŌ 1 e
Xg͑SăRs[AύX邱Ƃ͂܂Bempty V[PX͌
ʂɉ̉eyڂ܂񂪁AŌɒuꂽ nil ͂̑ȎS̃Rs
[点邱ƂɂȂ_ɒӂĉB

1 ̋@\ƂāA (^̃V[PXł͂Ȃ) LISTS  1 ^
ʂȏꍇɂ́Aŏɂ̐^ 10i print \̕ɕϊ
Bi̋@\{ɂ܂Hj

Ō̈́AǂȃIuWFNgłĂ܂܂BAʏ̓
XgłARs[ꂽϊ邱Ƃ͂܂B LISTS^
ꍇɂ́Anil Ԃ܂B

gpF
  ;;; ^̕ϊ̋@\̂ǂs
  (setq x '(1 2 3))               => (1 2 3)
  (append x '(4 5))               => (1 2 3 4 5)
  x                               => (1 2 3)
  (eq x (append x nil))           => nil
  (append nil x [4 5] "67" nil)   => (1 2 3 4 5 54 55)
  (append)                        => nil


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
[File       ]: register.l
[Section    ]: [W
[Description]: 
START  END Ŏw肳郊[WAWX^ R Ɋi[ĂeL
Xg̖֒ǉ܂B
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
[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*
[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
[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
[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
[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
[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
[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
[Section    ]: ϐƒ萔
[Description]: 
͂̌ʁAfill-columnzdo-auto-fills܂B


auto-fill-mode
[Type       ]: Function
[Arguments  ]: auto-fill-mode &optional (ARG () SARG)
[Package    ]: editor
[File       ]: fill.l
[Section    ]: eLXg
[Description]: 
lߍ݃[h̊JnƏIgO܂B


auto-save
[Type       ]: BufferLocal
[Package    ]: editor
[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    ]: 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

֐ĂяóAX̃t@C[hĂ̂悤Ɏs
𑱂܂B߂ɎgȂ֐autoloadŐ錾Ăƃʂ
ߖł܂B܂ANȂ܂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)

--- mule̐ ---

Function: autoload symbol filename &optional docstring interactive macro

̊֐́A(filename I[g[h悤) symbol Ŗtꂽ
 (̓}N)`܂B filename ́Å֐ĂԎ load 
npXłB 

docstring ́Å֐p̃hLe[VłB(ʏ)̊֐
̊֐`̂̂ƓXgOɂȂ܂B 

interactive  non-nil ̏ꍇÅ֐̓C^NeBuɌĂ΂܂B 
(ł)S interactive specification ^Kv͂܂B 
macro  non-nil ̏ꍇÅ֐()}NłB 

symbol ł non-nil ̊֐ZꍇA autoload () nil 
Ԃ܂B (֐Z) void ̏ꍇA symbol ̊֐Z (autoload 
filename docstring interactive macro ) ƂI[g[htH[ݒ
܂B 

symbol ̖O̊֐ĂԂƁA(܂)I[g[htH[]A 
filename ̖Õt@C load Ń[h܂B (̌) symbol ̊
Z Lisp ֐}NwƂɂȂ܂BȂȂꍇAG[
ɂȂ܂B 

(e̕]ŃG[) t@C̕]SɍsȂȂꍇA
[hɍsȂꂽ֐` provide Ăяo undone ܂(󒍁F
܂)B́A(G[𒼂)Ă autoload ł悤ɂ
߂łB


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
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
J[\Cfg̖is̍ŏ̋󔒂łȂjֈړ܂B


backward-char
[Type       ]: Function
[Arguments  ]: backward-char &optional (N 1)
[Package    ]: editor
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
w肳ꂽɈړ܂BsȂΑOs̏I[Ɉʒu܂B

݊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
[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
[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


backward-paragraph
[Type       ]: Function
[Arguments  ]: backward-paragraph &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: forward-paragraph
[File       ]: paragrph.l
[Section    ]: |WV
[Description]: 
J[\i̐擪Ɉړ܂B


backward-sexp
[Type       ]: Function
[Arguments  ]: backward-sexp &optional (ARG 1) NOERROR
[Package    ]: editor
[Seealso    ]: forward-sexp
[File       ]: sexp.l
[Section    ]: obt@
[Description]: 
lisp-modeS1߂܂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
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
J[\̒PɈړ܂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
[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
[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
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
sɈړ܂Bgoto-bolinteractivełłB


beginning-of-virtual-line
[Type       ]: Function
[Arguments  ]: beginning-of-virtual-line
[Package    ]: editor
[Seealso    ]: goto-virtual-bol
[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
[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
[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>)


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


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-fileio-encoding
[Type       ]: Function
[Arguments  ]: buffer-fileio-encoding &optional BUFFER
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
obt@̊R[hԂ܂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    ]: 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
[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    ]: 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
[File       ]: buf-menu.l
[Section    ]: obt@
[Description]: 
obt@ꗗ\܂B
ꗗ̒ł̓obt@̑IA폜Ȃǂł܂B


buffer-mode
[Type       ]: BufferLocal
[Package    ]: editor
[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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
obt@ɌѕtĂvZXԂ܂B
vZXmake-processō쐬܂B


buffer-read-only
[Type       ]: BufferLocal
[Package    ]: editor
[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    ]: 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 , file-position , make-buffer-stream , xyzzyŒ񋟂ĂXg[̎
[File       ]: builtin.l
[Section    ]: o
[Description]: 
buffer-streamłXg[̃|CgԂ܂B

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


buffer-stream-set-point
[Type       ]: Function
[Arguments  ]: buffer-stream-set-point STREAM POINT
[Package    ]: editor
[Seealso    ]: xyzzyŒ񋟂ĂXg[̎
[File       ]: builtin.l
[Section    ]: o
[Description]: 
buffer-streamłXg[̃|Cgw肵܂B

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

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


buffer-substring
[Type       ]: Function
[Arguments  ]: buffer-substring FROM TO
[Package    ]: editor
[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
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
iڍוsj
--- mule̐ ---
̊֐́AXg̑̃obt@̏ύX邱ƂȂAobt@Xg
̏I buffer-name u܂B́Aother-buffer (ł)ԂȂo
bt@ɂȂ܂B buffer-name ^ȂꍇAftHg̓Jg
obt@ɂȂ܂B 

buffer-name Jgobt@̏ꍇAꂪ selected EBhEŕ\
ĂꍇA other-buffer őIobt@Œu܂B selected 
EBhEȊÕEBhEŕ\ĂꍇA͂̂܂܂ɂ܂B 

C^NeBuɌĂ΂ꂽꍇA buffer-name ̓ftHgŃJgob
t@ɂȂ܂B


butlast
[Type       ]: Function
[Arguments  ]: butlast LIST &optional (N 1)
[Package    ]: lisp
[Seealso    ]: nbutlast , last
[File       ]: list.l
[Section    ]: Xg
[Description]: 
Xg̍ŌNvfXgԂ܂B̃Xg͕ύX܂B

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


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)))


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
[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
[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
[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
[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[(T)]-[L[{[h}N܂(O)]-[ۑ]L[{[h}ŃA
[c[(T)]-[L[{[h}N܂(O)]-[ǂݍ]ŌォI邱Ƃ\ł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
[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 : iڍוsj
  :input          : W͂gpOvOłΓ̓t@C
                    w肵܂B
  :output         : Wo͂gpOvOłΏo̓t@C
                    w肵܂B
  :error          : iڍוsj
  :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
[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    ]: capitalize-region , 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
[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
[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
[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
[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    ]: 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
[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
[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    ]: *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
[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    ]: 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
[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
[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    ]: 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
[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
[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
[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
[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
[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


clrhash
[Type       ]: Function
[Arguments  ]: clrhash HASH-TABLE
[Package    ]: lisp
[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
[File       ]: builtin.l
[Section    ]: 
[Description]: 
R[hCODE̕Ԃ܂B
LN^ƕR[hƂ̊Ԃ̑ݕϊɂ́Achar-codeg܂B

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


coerce
[Type       ]: Function
[Arguments  ]: coerce OBJECT TYPE
[Package    ]: lisp
[Seealso    ]: type-of
[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    ]: 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


commandp
[Type       ]: Function
[Arguments  ]: commandp OBJECT
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: ֐
[Description]: 
֐interactive錾Ă tԂAłȂnilԂ܂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 , scan-buffer
[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
[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
[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    ]: 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    : qXgɎgp郊Xgw
  :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
[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
[File       ]: evalmacs.l
[Section    ]: \
[Description]: 
cond CLAUSE...
     `cond'͔Cӌ̑II܂B`cond'̌XCLAUSE̓Xg
     łȂ΂Ȃ܂B̃XgCARCONDITIONłBc̗vf
     ()BODY-FORMSłBċ(clause)͎̂悤ɂȂ
     B

          (CONDITION BODY-FORMS...)

     `cond'͌X̋CONDITION]ĂƂɂāA̋̕
     eLXgǂ̏Ŏ܂BCONDITION̒l`nil'łȂ΁A
     ̋́uv܂B̏ꍇA`cond' ͂BODY-FORMS]A
     BODY-FORMS̍Ō̒l`cond'̒lƂȂ܂Bc͖̋܂B

     CONDITION̒l`nil'Ȃ΁A̋́usvA`cond'͎̋ɐ
     ڂA CONDITIONĂ܂B

     ׂĂCONDITION`nil'ɕ]ꂽꍇAȂ킿AׂĂ̋傪
     sꍇA`cond'`nil'Ԃ܂B

     ͎̂悤ɂȂĂ邩܂B

          (CONDITION)

     ̏ꍇACONDITIOÑeXgʂ`nil'łȂ΁ACONDITION̒l
     `cond'`̒lɂȂ܂B

     ȉ̗ł͎l̋ĂāAꂼ`x'̒llAAob
     t@AV{̂ǂꂩł邩eXg܂B

          (cond ((numberp x) x)
                ((stringp x) x)
                ((bufferp x)
                 (setq temporary-hack x) ; ̋
                 (buffer-name x))        ;  body-forms
                ((symbolp x) (symbol-value x)))

     Ō̋Ő傪ǂȂꍇɂ́A̍Ō̋
     sƂƂ悭܂Bs߂Ɏ͎̂悤
     ɍŌ̋CONDITIONƂ`t'gp܂B`(t BODY-FORMS)'B`
     `t'`t'ɕ]A`nil'ɂ͂Ȃ炸AāA̋͌
     ĎsAňłɂ͓B`cond'񋟂܂B

     Ⴆ΁A

          (cond ((eq a 'hack) 'foo)
                (t "default"))
          => "default"

     ̎`a'̒l`hack'Ȃ`foo'ԂAłȂΕ
     `"default"'Ԃ`cond'łB

̍\`cond'ł`if'ł\邱Ƃł܂B
āAǂg̑I̓X^C̖łBႦ:

     (if A B C)
     ==
     (cond (A B) (t C))


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
[File       ]: builtin.l
[Section    ]: VXe
[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
[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


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
[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      IɃt@C̕ύX݂܂B
  :if-access-denied : ANZXۂꂽꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂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
[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
[File       ]: builtin.l
[Section    ]: j[
[Description]: 
old-menu̍\new-menuɃgbvxŃRs[܂B

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


copy-rectangle
[Type       ]: Function
[Arguments  ]: copy-rectangle P1 P2
[Package    ]: editor
[Seealso    ]: kill-rectangle , copy-rectangle-selection
[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
[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
[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
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


copy-region-to-clipboard
[Type       ]: Function
[Arguments  ]: copy-region-to-clipboard FROM TO
[Package    ]: editor
[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
[File       ]: select.l
[Section    ]: [W
[Description]: 
Iꂽ̈Rs[āA*selection-ring*̐擪ɒǉ܂B
ǉeyank-selectionœ\t܂B
ftHgł'F8'ɊtĂ܂B


copy-selection-to-clipboard
[Type       ]: Function
[Arguments  ]: copy-selection-to-clipboard
[Package    ]: editor
[File       ]: select.l
[Section    ]: [W
[Description]: 
I͈͂Nbv{[hɓ]܂B

gpF
  ;;; 1. JISɕϊĕۑ
  ;;; 2. [t@C]-[J]ŊR[h[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
[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
[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
[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
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
[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
[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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: j[
[Description]: 
Vɍ쐬̃j[Ԃ܂B

  TAG : ʗp̃^Ow肵܂B

j[̒g͋Ȃ̂ŁAȉ̊֐œo^Kv܂B
g𓮓IɍKv΁Adefine-menugpǂł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    ]: get-buffer-create , *create-buffer-hook* , find-name-buffer , obt@̓\
[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
[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
[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-tab-bar
[Type       ]: Function
[Arguments  ]: create-tab-bar BAR CALLBACK
[Package    ]: editor
[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 , nil
[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
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
݂̌ʒuԂ܂B


current-line-columns
[Type       ]: Function
[Arguments  ]: current-line-columns
[Package    ]: editor
[Seealso    ]: current-column , char-columns
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
݂̕\šԂ܂B
s (#\LFD)  2 ƈ܂B


current-line-number
[Type       ]: Function
[Arguments  ]: current-line-number
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
݂̕s̍sԍԂ܂B


current-menu
[Type       ]: Function
[Arguments  ]: current-menu &optional BUFFER
[Package    ]: editor
[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    ]: goto-virtual-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    ]: goto-virtual-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
[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
[File       ]: dabbrev.l
[Section    ]: eLXg
[Description]: 
I̓WJɂԂɕ\܂B


dabbrev-popup
[Type       ]: Function
[Arguments  ]: dabbrev-popup
[Package    ]: editor
[Seealso    ]: dabbrev-expand , popup-list
[File       ]: dabbrev.l
[Section    ]: eLXg
[Description]: 
dabbrev-expand̃|bvAbvXgłłB


dde-execute
[Type       ]: Function
[Arguments  ]: dde-execute CHAN DATA
[Package    ]: editor
[Seealso    ]: dde-poke , dde-request , dde-terminate
[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
[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
[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


declare
[Type       ]: Misc
[Package    ]: lisp
[Seealso    ]: special
[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
[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)

---  ---
Description: returns universal-time in Decoded Time format, allowing for 
time-zone. If this is unspecified, the value returned is for the current 
time zone set by *time-zone*. Nine values are returned, as for get-decoded-time.
  (multiple-value-list
    (decode-universal-time 3100393640))
  => (20 27 13 1 4 1998 2 nil -9)

  (multiple-value-list
    (decode-universal-time (file-write-time "c:/autoexec.bat"))
  => (20 27 13 1 4 1998 2 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
[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
[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
[File       ]: abbrev.l
[Section    ]: [h
[Description]: 
abbrev-table`܂B
iڍוsj


define-command-bar
[Type       ]: Function
[Arguments  ]: define-command-bar SYM NAME &optional EDGE X Y W
[Package    ]: editor
[Seealso    ]: delete-command-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-history-variable
[Type       ]: Macro
[Arguments  ]: define-history-variable NAME &optional (INITIAL-VALUE nil sv) DOC
[Package    ]: editor
[Seealso    ]: 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
[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    ]: define-popup-menu
[File       ]: menu.l
[Section    ]: j[
[Description]: 
ŒIȃj[`܂B
`@define-popup-menuQƂĉBIɃj[𐶐
ɂcreate-menuQƂĉBdefine-menuŐj[
add-menu-iteminsert-menu-itemȂǂōڂǉ邱Ƃ\łB


define-popup-menu
[Type       ]: Macro
[Arguments  ]: define-popup-menu &body BODY
[Package    ]: editor
[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)
[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
[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


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֐ς
                     ܂Bw肷֐3̈ƂA IuWFNgA
                     Xg[AiڍוsjƂ܂B3́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 ()>"


defun
[Type       ]: Macro
[Arguments  ]: defun NAME (&rest LAMBDA-LIST) &body BODY
[Package    ]: lisp
[Seealso    ]: lambda
[File       ]: evalmacs.l
[Section    ]: ֐
[Description]: 
֐`܂B

--- mule̐ ---
defun ́AV lisp ֐`ꍇ(ʏ)@łB defun ́A 
symbol ̃tH[̎c̕֐̖OƂĒ`܂B (
)̃V{̊֐ZA parameter-list  forms 郉
_ (lambda parameter-list . forms) w悤ɂ邱ƂōsȂ܂B
lZ͊֐ZƂ͓ƗĂ邽߁AV{O[oϐƂ
pĂ܂܂B 

(ŏqׂ悤) forms ̍ŏ 2̃tH[́AhLe[V
XgO錾ł邱Ƃł܂B defun ͊֐̍Ē``FbN
Ă͂Ȃ߁A (car ̂悤) primitive m点()`Ă
܂Ƃ肦܂B defun  symbol Ԃ܂B 

  (defun foo () 5)
  => foo
  (foo)
  => 5
  (defun bar (a &optional b &rest c)
      (list a b c))
  => bar
  (bar 1 2 3 4 5)
  => (1 2 (3 4 5))
  (bar 1)
  => (1 nil nil)
  (bar)
  -> ERROR: Wrong number of arguments.
  (defun capitalize-backwards ()
      "This function makes the last letter of a word upper-case."
      (interactive)
      (backward-word 1)
      (forward-word 1)
      (backward-char 1)
      (capitalize-word 1))
  => capitalize-backwards


defvar
[Type       ]: Macro
[Arguments  ]: defvar NAME &optional (INITIAL-VALUE () SV) DOC
[Package    ]: lisp
[File       ]: evalmacs.l
[Section    ]: ϐƒ萔
[Description]: 
O[oȃXyVϐ錾܂B_Ci~bNȃXR[v܂B

--- ȉmule̐ ---

Special Form: defvar symbol [value [doc-string]]

̓tH[́AR[hǂސlɑ΂A symbol ϐƂ (ʏ)
[JɃoChꂸɗp邱Ƃm点܂B (ʏ) symbol ɂ́A
lXȃvOŕύXl^܂B symbol ͕]܂B 

L̐錾ɉA defvar (̑)̓܂B 

IvViȃA[Mg^ƁA defvar ̓A[Mg var 
]A symbol (Ȃ) unbound łꍇǍʂ symbol
̃O[olɐݒ肵܂B symboloChĂꍇA value ͕]
sȂ܂B 

doc-string ݂ꍇÁA (Emacs ̃wvVXe) symbol 
̃vpeB[Xg indicator (??) variable-documentation ̉ɒu
܂B doc-string ̍ŏ̕ `*' łꍇA̕ϐ (ʏ)[
U[ύXsȂ[U[IvVłƂ܂B user-variable-p 
܂B doc-string ͕]܂B 

defvar ͂̒lƂ symbol Ԃ܂B 

ȉɎŏ̗ł́A([U[ɑ΂) foo 錾܂B̃tH[
 foo ̒lZ͐ݒ肵܂B 2 Ԗڂ̃tH[ bar ̒l 23 ݒ
AhLe[VXgO^܂B bar ̓[U[IvV
ł͂܂B 4 Ԗڂ̃tH[ bar ̃hLe[VXgO
ύXA bar [U[IvVɂ܂Al͕ς܂(Z (1+ 
23) ͎s܂)B 

  (defvar foo)
  => foo
  (defvar bar 23 "The normal weight of a bar.")
  => bar
  (user-variable-p 'bar)
  => nil
  (defvar bar (1+ 23) "*The normal weight of a bar.")
  => bar
  bar
  => 23
  (user-variable-p 'bar)
  => t

̃tH[́Adefvar ɓȂ̂Ă܂B 

  (defvar symbol value doc-string)
  ==
  (progn
    (if (not (boundp symbol))
        (setq symbol value))
    (put 'symbol 'variable-documentation 'doc-string)
    'symbol)


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
[File       ]: builtin.l
[Section    ]: V[PX
[Description]: 
SEQUENCE̒ITEMƈv̂폜SEQUENCEԂ܂B
SEQUENCE͕ύX܂BSEQUENCEێ΁AremovegƁ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    ]: t[̊Tv , 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-char
[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
[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
[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
[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
[File       ]: cmds.l
[Section    ]: eLXg
[Description]: 
ZNVőI𒆂Ȃ΃ZNVŜAłȂ΃J[\̈
u̕폜܂Bdelete-charƂ̓ZNV̓삪قȂ܂B


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̃V[PX͕ύX܂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
[File       ]: cmds.l
[Section    ]: eLXg
[Description]: 
s̃J[\ʒȗŐ󔒂폜܂B


delete-if
[Type       ]: Function
[Arguments  ]: delete-if PREDICATE SEQUENCE &key :from-end :start :end :count :key
[Package    ]: lisp
[Seealso    ]: remove-if
[File       ]: builtin.l
[Section    ]: V[PX
[Description]: 
SEQUENCE̒PREDICATE𖞂̂폜܂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
[File       ]: builtin.l
[Section    ]: V[PX
[Description]: 
SEQUENCE̒PREDICATE𖞂Ȃ̂폜܂B


delete-indentation
[Type       ]: Function
[Arguments  ]: delete-indentation &optional ARG
[Package    ]: editor
[File       ]: cmds.l
[Section    ]: 
[Description]: 
Cfg폜O̍sƘA܂B
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
[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
[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
A݃J[\EBhE~jobt@EBhȄꍇ͑
EBhE폜܂B

߂lF
  t     EBhE̍폜Ɋւ炸 t Œ

⑫F
  {֐̓R}hŁAݒł C-x 1 ɃoChĂ܂B


delete-package
[Type       ]: Function
[Arguments  ]: delete-package PACKAGE
[Package    ]: lisp
[Seealso    ]: make-package , defpackage , pbP[W
[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    ]: t[̊Tv , new-pseudo-frame , delete-all-pseudo-frames
[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
[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
[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
~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
  {֐̓R}hŁAݒł C-x 0 ɃoChĂ܂B
  
  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
[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


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
[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
[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       ]: 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́AlȂ̂ŁAmultiple-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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: ̑
[Description]: 
炵܂Hiڍוsj

gpF
  ;;; 炷B
  (ding)
  => t


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    ]: read-directory-name
[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
[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
[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
[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


dolist
[Type       ]: Macro
[Arguments  ]: dolist (VAR LISTFORM &optional (RESULTFORM ''())) &body BODY
[Package    ]: lisp
[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)


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)))))


dotimes
[Type       ]: Macro
[Arguments  ]: dotimes (VAR COUNTFORM &optional (RESULTFORM ''())) &body BODY
[Package    ]: lisp
[File       ]: evalmacs.l
[Section    ]: \
[Description]: 
(dotimes (<ϐ> <> <l>)
  <1> ... <n>)

w肳ꂽ񐔂JԂsB

܂<>]B̒lnƂƁC0`n-1܂ł̂ꂼ
lɑ΂āC<ϐ>̐lɃoChāC{̂<1>
`<n>܂ł]BȂ킿{̎nJԂB{̎̕]
nJԂƁC<l>]Cdotimes̒lƂĕԂB
܂<l>͏ȗłC̏ꍇdotimes̒lnilłB

dotimes̈ʌ`́C

(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    ]: up-list
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
J[\Oɂ ARG ̊ʂ̌Ɉڂ܂B

  (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    ]: capitalize-region , upcase-region
[File       ]: builtin.l
[Section    ]: [W
[Description]: 
[W̒Pɂ܂B


downcase-word
[Type       ]: Function
[Arguments  ]: downcase-word &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: downcase-region , upcase-word
[File       ]: cmds.l
[Section    ]: 
[Description]: 
J[\ʒuP̖܂łɕϊ܂B


drive-dialog
[Type       ]: Function
[Arguments  ]: drive-dialog &optional DRIVE
[Package    ]: editor
[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    ]: version-up-xyzzy
[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::*last-search-regexp*
[Type       ]: Variable
[Package    ]: editor
[Section    ]: EK\
[Description]: 
O̐K\p^[ۑĂ܂B


ed::*last-search-string*
[Type       ]: Variable
[Package    ]: editor
[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
[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
[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
[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
[File       ]: register.l
[Section    ]: ̑
[Description]: 
WX^ R ɒl VALUE i[܂B


ed::toggle-mode
[Type       ]: Function
[Arguments  ]: toggle-mode VAR ARG SV
[Package    ]: editor
[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
[File       ]: builtin.l
[Section    ]: V[PX
[Description]: 
SEQUENCEINDEXԖڂ̗vfԂ܂B
INDEX0Ƃ܂BȂnilԂ܂B


Emacs ݊ł͂ȂK\͌\̂ł傤H
[Type       ]: Tips
[Section    ]: EK\
[Description]: 
\'  \`  \=  \c  \C ꂾł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
[File       ]: builtin.l
[Section    ]: ϐƒ萔
[Description]: 
post-buffer-modified-hookLɂ܂B
[xyzzy:06354]Q
xyzzy 0.2.1.186`


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

---  ---
Description: returns an integer which represents the number of seconds 
from midnight 1 January 1900 GMT to the time specified by the given 
components of Decoded Time format. If time-zone is unspecified, it defaults 
to the current time zone and the integer is adjusted to take account of 
daylight saving time. If time-zone is specified, the integer is adjusted 
accordingly but no account is taken of daylight saving time.

QƁF
  timestmp.l


end-of-buffer
[Type       ]: Function
[Arguments  ]: end-of-buffer
[Package    ]: editor
[Seealso    ]: beginning-of-buffer , set-mark-command
[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
[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
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
ݍs̏IɈړ܂B


end-of-virtual-line
[Type       ]: Function
[Arguments  ]: end-of-virtual-line
[Package    ]: editor
[Seealso    ]: goto-virtual-eol
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
\s̍sɈړ܂B
goto-virtual-eol  interactive łłB


endp
[Type       ]: Function
[Arguments  ]: endp OBJECT
[Package    ]: lisp
[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
[File       ]: builtin.l
[Section    ]: EBhE
[Description]: 
EBhE̍sEύX܂B
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
[File       ]: window.l
[Section    ]: EBhE
[Description]: 
J[\̂EBhE̕傫܂B

gpF
  ;;; lister̃}[WEBhE̕ꍇ
  (enlarge-window-horizontally (- *lister-margin* (window-width)))


enum-buffers
[Type       ]: Function
[Arguments  ]: enum-buffers FN
[Package    ]: editor
[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
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
X  Y IuWFNgȂtAłȂȂnilԂ܂B
l╶ɑ΂Ă͌㓯łtƂȂۏ͂܂Bxyzzył́A
ltƂȂ邪ł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
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
X  Y IuWFNgA^̐l܂͕^ŒlԂ܂B
tAłȂ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
[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
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
equalƓ悤 X  Y r܂BႦΑ啶Ə͋ʂ܂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
[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
[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
[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
[File       ]: misc.l
[Section    ]: ]
[Description]: 
~jobt@R}hΘbIɓ͂Ďs܂B[ESC x]


execute-shell-command
[Type       ]: Function
[Arguments  ]: execute-shell-command COMMAND &optional INFILE OUTPUT ENVIRON DIRECTORY
[Package    ]: editor
[Seealso    ]: call-process , execute-subprocess
[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Ȃꍇ́Cexecute-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 , command-output-mode , shell-command-line
[File       ]: process.l
[Section    ]: vZX
[Description]: 
vO BUFFNAME Ŏw肵obt@Ŏs܂B
ʂ́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
[File       ]: abbrev.l
[Section    ]: eLXg
[Description]: 
J[\ʒuŐÓI̓WJs܂B
abbrev-mode ̎ self-insert-command łs܂B


export
[Type       ]: Function
[Arguments  ]: export SYMBOLS &optional PACKAGE
[Package    ]: lisp
[Seealso    ]: pbP[W
[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

---  ---
Description: Symbols should be a symbol or a list of symbols which are 
made external symbols of package. Symbols in the list that are already 
external are unaffected whilst those that are internal but not inherited 
become external. If a symbol in the list is inherited and thus internal, 
the symbol is first imported into package, as if by import, and the becomes 
external. By convention, a call to export is placed at the beginning of 
a file to advertise all the symbols that are intended for use by other 
programs. export returns t. package should be a package or the name or 
nickname of a package.

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


extract-archive
[Type       ]: Function
[Arguments  ]: extract-archive ARCHIVE-FILE TO-DIRECTORY &rest FILES
[Package    ]: editor
[Seealso    ]: create-archive , delete-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
[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
[File       ]: cmds.l
[Section    ]: obt@
[Description]: 
ɏXN[܂B[C-Down]


fboundp
[Type       ]: Function
[Arguments  ]: fboundp SYMBOL
[Package    ]: lisp
[Seealso    ]: boundp
[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       ]: 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    ]: read-directory-name
[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
[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̕VAfile1B


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-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 , decode-universal-time , format-date-string
[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
[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-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
[File       ]: builtin.l
[Section    ]: t@C
[Description]: 
t@C܂B

  RESULT : 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
[File       ]: fill.l
[Section    ]: |WV
[Description]: 
lߍݎ̐܂Ԃ̌ێ܂B
l 72 łB

gp:
  ;;; l 62 ɕύXB
  (setq-default fill-column 62)

Jgobt@̒lύXꍇ́AFunction set-fill-column 
gp܂B


fill-paragraph
[Type       ]: Function
[Arguments  ]: fill-paragraph
[Package    ]: editor
[Seealso    ]: fill-region-as-paragraph
[File       ]: fill.l
[Section    ]: 
[Description]: 
݂̒ilߍ݂܂B


fill-pointer
[Type       ]: Function
[Arguments  ]: fill-pointer VECTOR
[Package    ]: lisp
[Seealso    ]: array-has-fill-pointer-p , make-array , vector-pop , vector-push , length
[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
[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-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


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
[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-buffer
[Type       ]: Function
[Arguments  ]: find-buffer BUFFER-NAME
[Package    ]: editor
[Seealso    ]: find-name-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
[File       ]: files.l
[Section    ]: t@CVXe
[Description]: 
w肳ꂽt@CJ܂B

--- mule ̐ ---
Command: find-file filename

̊֐́A filename ƂÕt@C([U[)GfBbgł
悤ɂ܂B find-file-noselect ĂŃt@Cɑ΂obt@I
( : select)܂B 

C^NeBuɌĂ΂ꂽꍇA filename (~jobt@)vv
go܂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

--- mule ̐ ---
Command: find-file-other-window filename

̊֐́A (ʂ̃EBhE)t@C filename GfBbg܂B 2
͂ȏ̃EBhEʏɑ݂ꍇAIĂȂ(
: non-selected)EBhEp܂B 1EBhE݂Ȃ
ꍇA𕪊܂B nil Ԃ܂B 

C^NeBuɌĂ΂ꂽꍇA filename (~jobt@)vv
go܂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 , create-new-buffer
[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-file
[File       ]: files.l
[Section    ]: t@CVXe
[Description]: 
݂̃obt@Ďw肳ꂽt@CJ܂B

݊F
  muleɂ͂ȂB


find-package
[Type       ]: Function
[Arguments  ]: find-package NAME
[Package    ]: lisp
[Seealso    ]: pbP[W , defpackage , delete-package
[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
[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
[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
[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 , 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 , 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
[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
[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
[File       ]: errors.l
[Section    ]: G[
[Description]: 
grep*compilation*obt@ŎsƁAYsփWv\łB
Ȍ́Anext-error(F11)ƂŎ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
[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
[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
[File       ]: builtin.l
[Section    ]: ϐƒ萔
[Description]: 
w肳ꂽV{̊֐`ւ̑܂B
ȍ~fboundpnilԂ悤ɂȂ܂BV{ւ̒lƊ֐`̑
͓ƗĂ̂Ł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
[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
(following-char)


format
[Type       ]: Function
[Arguments  ]: format DESTINATION CONTROL-STRING &rest ARGUMENTS
[Package    ]: lisp
[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
[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    ]: preceding-char , *prefix-args*
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
w肳ꂽEɈړ܂BsΎsɈړ܂B

̊֐́A|CgE ARG ܂(ARG ̏ꍇAɓ
܂)Bobt@( clipped ̈)̐擪I[zĂ܂ꍇA 
beginning-of-buffer  end-of-buffer G[o܂B 

C^NeBuɌĂ΂ꂽꍇA ARG ͐l̃vtBbNXA[M
gɂȂ܂B 

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


forward-line
[Type       ]: Function
[Arguments  ]: forward-line &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: previous-line , forward-virtual-line , *prefix-args*
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
sɈړ܂B

--- mule̐ ---
Command: forward-line &optional count

̊֐́A|Cg̈ʒu count s̍s̐擪ɓ܂B 
count ̏ꍇAɓ܂B 

obt@( clipped ̈)ɏ\ȍs݂ȂꍇA|Cg
obt@( clipped ̈) ̐擪(͏I[)ɓ܂B 

count ƎۂɓsƂ̍Ԃ܂B 3 sȂobt@̓ 
5 sɓ悤wƁA|Cg̍Ō̍s̏IɈʒutA2 
ԂƂɂȂ܂B 

C^NeBuɌĂ΂ꂽꍇA count ͐l̃vtBbNXA[M
gɂȂ܂B


forward-list
[Type       ]: Function
[Arguments  ]: forward-list &optional ARG NO-ERRORS
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
ÕXg̏I[ֈړ܂B
  
  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-paragraph
[Type       ]: Function
[Arguments  ]: forward-paragraph &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: backward-paragraph
[File       ]: paragrph.l
[Section    ]: |WV
[Description]: 
J[\i̖Ɉړ܂B


forward-sexp
[Type       ]: Function
[Arguments  ]: forward-sexp &optional ARG NO-ERRORS
[Package    ]: editor
[Seealso    ]: backward-sexp
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
lisp-modeS1i߂܂B

gpF
  (forward-sexp)


forward-virtual-line
[Type       ]: Function
[Arguments  ]: forward-virtual-line &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: forward-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
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
J[\O̒PɈړ܂B


fourth
[Type       ]: Function
[Arguments  ]: fourth X
[Package    ]: lisp
[Seealso    ]: cadddr
[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
[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
[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
[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


get
[Type       ]: Function
[Arguments  ]: get SYMBOL INDICATOR &optional DEFAULT
[Package    ]: lisp
[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-buffer-alternate-file-name
[Type       ]: Function
[Arguments  ]: get-buffer-alternate-file-name &optional BUFFER
[Package    ]: editor
[Seealso    ]: set-buffer-alternate-file-name
[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 , obt@̓\
[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
[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
[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
[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-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
[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
[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-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-menu
[Type       ]: Function
[Arguments  ]: get-menu MENU TAG-OR-POSITION &optional TAG-OR-POSITION-P
[Package    ]: editor
[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
[File       ]: builtin.l
[Section    ]: j[
[Description]: 
j[̒^ÖʒuĕԂ܂B

  MENU : 郁j[w肵܂B
  TAG  : ^Ow肵܂B

ȂꍇɂnilԂ܂B
ꍇɂ͂̈ʒuƂ܂ރj[Ԃ܂B


get-properties
[Type       ]: Function
[Arguments  ]: get-properties PLACE INDICATOR-LIST
[Package    ]: lisp
[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
[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       ]: 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-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
[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    ]: 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
[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


goal-column
[Type       ]: Function
[Arguments  ]: goal-column
[Package    ]: editor
[Seealso    ]: set-goal-column
[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
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
sɈړ܂B

݊F
  xyzzyIWî悤łB
  ̂łĝĂ݂B


goto-char
[Type       ]: Function
[Arguments  ]: goto-char POINT
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
w肳ꂽʒuɃJ[\ړ܂B̈ʒupoint, point-min, 
point-max̃|CgԂ֐gp邱Ƃœ邱Ƃ\łB

--- mule̐ ---
̊֐́AJgobt@̃|Cg(Jgobt@) position 
ݒ肵܂B position  1 ȉ̏ꍇA|Cgobt@̐擪ɐݒ肵
܂Bobt@̒ȏ̏ꍇA|Cgobt@̏I[ɐݒ肵܂B 

clipping pꂽꍇA position (ȑOƂ)̃obt
@̐擪v܂A clipped ̈̊OɎꂽ position  clipped 
̈̐擪I[̈ʒuƂȂ܂B 

C^NeBuɌĂ΂ꂽꍇA(ꂪ^Ăꍇ) position ̓v
tBbNXA[MgɂȂA(^ĂȂꍇ) ~jobt@
ݍ݂܂B 
goto-char  position Ԃ܂B


goto-column
[Type       ]: Function
[Arguments  ]: goto-column COLUMN &optional EXCEED-P
[Package    ]: editor
[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
[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
[File       ]: cmds.l
[Section    ]: obt@
[Description]: 
݂̃obt@ōŋߕύXꂽs̐擪Ɉړ܂B


goto-line
[Type       ]: Function
[Arguments  ]: goto-line LINE
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
w肳ꂽsԍɃWv܂B܂ԂLɂĂĕ\sɃW
vꍇɂ́Agoto-virtual-linegp܂B

̊֐́A(obt@̐擪 1 sڂƐ) line sڂ̍s̐擪Ƀ|C
gݒ肵܂B line  1 菬ꍇA|Cgobt@̐擪ɒu
܂Bobt@̍s傫ꍇAobt@Ō̍s̏Iɐݒ肵
B 

clipping pꂽꍇA line (܂)̃obt@̐擪琔
܂Aclipped ̈̊O line w肳ƁA|Cg clipped ̈
̐擪IɈʒut邱ƂɂȂ܂B 

C^NeBuɌĂ΂ꂽꍇA(^Ăꍇ) line ͐l̃vt
BbNXA[MgɂȂ܂BłȂꍇA line ~jobt@
ǂݍ݂܂B


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
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
|Cgɑ݂LN^Asyntax-open-psyntax-close-p
ꍇɁAΉLN^Ɉړ܂BΉe튇ʂɈړ
Ɏg܂B


goto-virtual-bol
[Type       ]: Function
[Arguments  ]: goto-virtual-bol
[Package    ]: editor
[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
[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
[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
[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


handler-case
[Type       ]: Macro
[Arguments  ]: handler-case FORM &rest CASES
[Package    ]: lisp
[Seealso    ]: ignore-errors , unwind-protect , error
[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
[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
[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
[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
[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
[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


if
[Type       ]: Special Form
[Arguments  ]: if TEST THEN [ELSE]
[Package    ]: lisp
[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    ]: handler-case , unwind-protect
[File       ]: handler.l
[Section    ]: G[
[Description]: 
{̂]ƂɔG[SĖ܂B
G[ꍇɂ́Aignore-errorsnilԂ܂B

C++̏ꍇF
  try {
    return resolve_shortcut("c:\\autoexec.bat");
  } catch (...) {
    return nil;
  }

xyzzy̏ꍇF
  (ignore-errors  (resolve-shortcut "c:/autoexec.bat"))


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
[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    ]: pbP[W , *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
[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
[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
[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
[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
[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
[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    ]: find-file
[File       ]: files.l
[Section    ]: t@CVXe
[Description]: 
w肳ꂽt@CJ[\̈ʒuɓǂݍ݂܂B

--- mule ̐ ---
Command: insert-file filename

̊֐́At@C filename ̓eJgobt@̃|Cǧɑ}
܂B filename ǂݍ݉\ȃt@CłȂꍇAG[ɂȂ܂B
̓C^NeBuɗp邽߂̂̂ insert-file-contents ȊÔ
Ƃ (قƂ)sȂ܂B


insert-file-contents
[Type       ]: Function
[Arguments  ]: insert-file-contents FILENAME &optional VISIT-P OFFSET SIZE
[Package    ]: editor
[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
[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
[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
[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
[File       ]: register.l
[Section    ]: [W
[Description]: 
WX^ R ̓eobt@ɑ}܂B
R ɃeLXg܂͋`̈悪ĂȂƃG[ɂȂ܂B


integerp
[Type       ]: Function
[Arguments  ]: integerp OBJECT
[Package    ]: lisp
[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 , buffer-modified-p
[File       ]: builtin.l
[Section    ]: ֐
[Description]: 
ΘbIȃ}N֐̒`́AKinteractivew肷Kv܂B
ȉ̏ʂŎg}N֐͑ΘbIłȂ΂Ȃ܂B

  1) M-x Ăяoꍇ
  2) define-key, global-set-key ŃL[oChꍇ
  3) c[o[ɓo^ꍇ

ȉ̂悤ɈΘbIɓnƂ\łB

  ;;; Ȃ
  (defun foo ()
    (interactive) ... )

  ;;; 鎞
  (defun foo (n)
    (interactive "nPercent: ") ... )

nPercent:̂ŏ̂P(łnjȉ̂悤ȈӖ܂B
Qڈȍ~(Percent:),~jobt@ɕ\̕ɂȂ܂B

  b   ɑ݂obt@̖O
  f   ɑ݂t@C̖O
  n   ij
  s   
  B   obt@̖Oi݂ȂĂ悢j
  F   t@C̖O  i݂ȂĂ悢j
  N   BAR}hvtBbNXtŋNꂽꍇ́A
      p
  S   V{
  D   fBNg
  liGj  t@C̕IłBt@C̃Xg܂B

  :title0 "mojiretsu"
  :default0 "bar"
                  :default0 , :default1, :default2Ƃ悤Ɏwł܂
  :history0 'execute

--99/08/23ǉ
 1. (interactive "0C \n1s \n2b") ݂ɁA
    䕶(Č̂ł傤H)̑Oɐ
    悤Ȃ̂łA͂ǂӖ
    ̂ł傤H
    # misc.l  execute-extended-command Ɏ
    # ܂ǁAϕ܂ւB(^^;

0 ̂ƂAvvgɐ܂BȊȌꍇ
͖܂BǁAӖ͂܂(^^;

|  2. (interactive "sH : " :history0 "H") 
|     A:history[01]? Ƃ̑g݂ɂȂ́A
|     ǂł傤H

~jobt@ۂɌĂ΂ *enter-minibuffer-hook* 
(minibuf.l  prologue-minibuffer)̈Ɏg܂B
Ȃ݂ɁAminibuffer-initialize ̐݌v͂ԂԈ
܂B


--------------ȉmule̐---------------------------
Special Form: interactive [arg-descriptors]

̓tH[́A()֐R}hł邱ƁA(܂) "M-x 
AɃoChꂽL[͂邱ƂŃC^NeBuɌĂяo
Ƃł" ƁA錾܂B arg-descriptors ́A"(ΏۂƂ)֐
C^NeBuɌĂԏꍇAǂ̂悤ɃA[Mg^邩" 
B interactive (Ă΂ꂽꍇ)sȂ܂B arg-descriptors ̕]
sȂ킸A() nil Ԃ܂B arg-descriptors ^ȂꍇA 
(ΏۂƂ)֐̓A[MgɌĂ΂܂BA(Ώۂ
)֐ 1 ȏ̃A[MgKvƂꍇAG[ɂȂ܂B 

arg-descriptors XgOłȂꍇÁA]ɂ (ΏۂƂ) 
֐ɓnA[Mg̃XgtH[łȂĂ͂܂
B 

arg-descriptor XgȌꍇÃXgO (̃R[hK
vƂꍇ) vvgɑR[hō\ĂȂĂ͂
BvvǵAXgȌI肩j[CŏI܂Bj[C
̌ (̃A[Mgp) 2 Ԗڂ̃R[hƃvvgƂ^
Ƃł܂(ȉl)B 

XgO̍ŏ̕ * ̏ꍇAobt@[hI[łꍇG
[o(󒍁Fsignal)܂B̏ꍇA()̕ŏ̃R[h
Ƃėp܂B 

R[h̑́A()A[Mg̉ (obt@A֐At
@CA) ̖OłȂĂ͂ȂƂw܂B̂悤ȏꍇA 
(Emacs ɂ)ftHĝ̂^ƂƂɁAȂ (󒍁F
ɍȂ)O͎󂯓ȂȂ܂ (Emacs  `[No Match]' ƕ
AvvgoAĂіO߂܂)B TAB, SPC, RET ́A֐ 
completing-read ɏ]O completion sȂ܂B 

ȉ̃e[uɂāA"completion" ƃ}[NꂽR[h completion 
sȂ܂B "existing" ƃ}[Nꂽ̂()Ov܂B 
"default" ƃ}[Nꂽ̂̓ftHg܂B "prompt" ̓vv
gȂĂ͂܂B 

a 

  ֐(i.e., fboundp ł(󒍁Ffboundp 𖞂)V{)B
  existing, completion, prompt
  b
  obt@Bexisting, completion, prompt
  B
  obt@Bcompletion, prompt
  c
  Bprompt
  C
  R}h(i.e. C^NeBu֐)Bexisting, completion,
  prompt
  d
  |Cg̃|WV𐔒lƂėp܂BNo I/O
  D
  fBNgBexisting, completion, default, prompt
  f
  ֐Bexisting, completion, default, prompt
  F
  ֐Bexisting, default, prompt
  k
  L[V[PXB (JgȃL[}bv) R}h undefined 
  ꂽR}h܂ŕǂݍ݁ÃL[V[PXXg
  OƂĊ֐ɓn܂BJ[\̓GR[GAɈړ܂B
  prompt
  m
  (lƂĂ)}[Ñ|WVBNo I/O
  n
  lBlKvƂ܂Bprompt
  N
  ̃vtBbNXA[Mg֐ɓn܂BvtBbN
  XA[Mg nil ̏ꍇA (n ɂ悤)lǂݍ݂
  BlKvƂ܂Bprompt
  p (p)
  ꂽvtBbNXA[Mg֐ɓn܂BNo I/O
  P (啶P)
  ̃vtBbNXA[Mg֐ɓn܂BNo I/O
  r
  |Cgƃ}[NA֐ɑ΂ 2(l) A[MgƂ
  (ɂ)n܂B No I/O
  s
  XgOǂݍ݁ALFD  RET Ń^[~l[g܂B̂ǂ
  (󒍁FLFD  RET) C-q p邱ƂŃXgOɊ܂߂邱Ƃ
  ł܂B prompt
  S
  XgOǂݍ݁A(󒍁Fwhitespace) ̂ǂꂩŃ^[~
  l[g܂Bǂݍ܂ꂽ̂́AV{Ƃ intern ܂B
  C-q p邱Ƃŋ󔒕XgOɊ܂߂邱Ƃ͂ł܂Bʏ
  V{^[~l[g镶(e.g., ()[]) (󒍁Fł͂̃X
  gO)^[~l[g܂B prompt
  v
  [U[IvVƂĐ錾ꂽϐ(i.e., user-variable-p)B
  existing, completion, prompt
  x
  Lisp tH[ǂݍ݁ALFD  RET Ń^[~l[g܂B
  ǂݍ܂XgO̃_uNH[g^CvOɃ^[~
  l[gꂽꍇA̃_uNH[gǉ܂BXgxNg
  ǂݍłāAŌ̕ )  ] ̑OɃ^[~l[gꂽ
  AG[o܂B (󒍁Fǂݍ)tH[͕]܂B
  prompt
  X
  (x ɂ悤)tH[ǂݍ񂾌A]Ǎʂ֐
  n܂B prompt
  (defun foo1 ()                    ;foo1 ̓A[Mg炸A
      (interactive)                 ;2 word Ɉړ邾B
      (forward-word 2))
  => foo1
  (defun foo2 (n)                   ;foo2 ̓A[Mg 1A
      (interactive "p")             ; ꂽvtBbNXłB
      (forward-word (* 2 n)))
  => foo2
  (defun foo3 (n)                 ;foo3 ̓A[Mg 1A
      (interactive "nCount:")     ; ~jobt@ǂݍ܂B
      (forward-word (* 2 n)))
  => foo3
  (defun three-b (b1 b2 b3)
    "Select three existing buffer (prompting for them in the Minibuffer)
  Put them into three windows, selecting the last one."
      (interactive "bBuffer1:\nbBuffer2:\nbBuffer3:")
      (delete-other-windows)
      (split-window (selected-window) 8)
      (switch-to-buffer b1)
      (other-window 1)
      (split-window (selected-window) 8)
      (switch-to-buffer b2)
      (other-window 1)
      (switch-to-buffer b3)
    )
  => three-b
  (three-b "*scratch*" "declarations.texinfo" "*mail*")
  => nil

  Q commandp
=================
ȉAԈ B

===䕶Xg }===

()
䕶 {}[ŏIϊl]     ͒l

{}
 E: Existing     ݂郂m͂ȂIȂ
 C: Completion   ͌\E⊮
 P: Prompt       ~jobt@Ń[U[
 D: Dialog       _CAO\邱Ƃ

[ŏIϊl]
{xx}    - ֐ɂ xxx ^̒l
{xx/yy} - ͒lȗ͖`lƁAyy^B
{xx|yy} - ͒ldlƁAyy ̌^ł
{*****} - Ȃł

===䕶Xg===
a       {ECP }[symbol]          ֐B
b       {ECP }[buffer]          obt@B
B       { CP }[buffer/string]   obt@B
c       {  P }[character]       L[̓LN^B
C       {ECP }[symbol]          C^NeBuR}hB
d       {    }[integer]         Iobt@ł̈ʒuB
D       {ECPD}[string]          fBNgB
e       { CP }[string]          s\t@CB
f       { CPD}[string]          t@CB
F       { CP }[string]          t@CB
k       {  P }[character|cons]  L[V[PXB
l       {ECPD}[string|cons]     t@CBB
m       {    }[integer]         }[NB
M       {    }[integer]         IJnʒuB
n       {  P }[integer/nil]     lB
N       {  P }[integer/nil]     lBOu(c-u)D̗pB
p       {    }[integer]         Ouɂ鐔lB
P       {    }[integer/nil]     Ouɂ鐔lB
r       {    }[integer]         [WB}[NɗB
R       {    }[integer]         Í͈BJnʒuɗB
s       {  P }[string]          B
S       { CP }[symbol]          V{B
v       {ECP }[symbol]          ϐB
x       {  P }[*****]           lispB
X       {  P }[*****]           lispB֐ɂ͕]̒ln

AgGhHiIjJKoOqQtTuUVwWyYzZ       ܂̂ƂgȂ

===̑===
*       interactive ̐擪ɂȂĂƂ́A
        Iobt@ ReadOnly ƃG[ɂႤB
          (interactive "*fFiles : ")   ;;; Ȋ
\n      ̐䕶gꍇAŋ؂
          (interactive "*fFiles : \np")::: Ȋ
0       e䕶̑OɒuĂƁAvvg
        Ou(C-u)}ĕ\B
          (interactive "0fFiles : ")   ::: Ȋ
1-9     e䕶̑Oɒu邯ǁAƂ肠ӖB


interactive-p
[Type       ]: Function
[Arguments  ]: interactive-p
[Package    ]: editor
[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
[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

---  ---
Description: Similar to find-symbol but creates a new symbol if a match 
is not found for string. The new symbol with print name string is created 
and is added to package. package becomes the home package of the new 
symbol, and the symbol is returned. The new symbol created is internal 
unless package is the keyword package in which case the symbol is external. 
The second value returned is as for find-symbol , except that nil indicates 
that a new symbol was created. read uses intern to convert symbol names 
into the symbols themselves.


intersection
[Type       ]: Function
[Arguments  ]: intersection LIST1 LIST2 &rest REST &key :test :test-not :key
[Package    ]: lisp
[Seealso    ]: nintersection
[File       ]: list.l
[Section    ]: Xg
[Description]: 
LIST1  LIST2 ̗Ɋ܂܂vf̃XgĕԂ܂B
nintersection ƈႢ̃Xg͕ύX܂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
R Ƀ}[J[ĂȂƃG[ɂȂ܂B


just-one-space
[Type       ]: Function
[Arguments  ]: just-one-space
[Package    ]: editor
[Seealso    ]: delete-horizontal-spaces
[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
[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
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
CHARԂ܂B
iڍוsj


kept-undo-information
[Type       ]: BufferLocal
[Package    ]: editor
[Seealso    ]: undo , undo-boundary , clear-undo-boundary
[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


keymapp
[Type       ]: Function
[Arguments  ]: keymapp OBJECT
[Package    ]: editor
[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
[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
[File       ]: buffer.l
[Section    ]: obt@
[Description]: 
obt@폜܂BAkill-buffer̓obt@ύXĂƍ
ĂǂĂ܂B}NŎgۂɂ́Adelete-bufferg
قł傤B([UɕɂȂ폜܂j

܂A*query-kill-buffer-hook*ɃtbN֐ݒ肷ƁAƎ̗pŃob
t@̔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    ]: signal-process , make-process
[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*
[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
[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
[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
[File       ]: region.l
[Section    ]: [W
[Description]: 
[Wkill ringɓ܂B

--- 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
[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
[File       ]: select.l
[Section    ]: [W
[Description]: 
Iꂽ̈؂A*selection-ring*̐擪ɒǉ܂B
ǉeyank-selectionœ\t܂B
ftHgł'F7'Ɋ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
[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


kill-word
[Type       ]: Function
[Arguments  ]: kill-word &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: kill-region , forward-word
[File       ]: cmds.l
[Section    ]: [W
[Description]: 
J[\ʒuO̒P̖܂ł؂ALOɒǉ܂B
[ESC d]
J[\P̓rɂꍇ́AJ[\ʒu炻̒P̖܂łA
ΏۂƂȂ܂B


lambda
[Type       ]: Misc
[Arguments  ]: lambda LAMBDA-LIST [[{DECLARATION}* | DOCUMENTATION]] {FORM}*
[Package    ]: lisp
[File       ]: evalmacs.l
[Section    ]: \
[Description]: 
֐ɖOtKvȂA葱LqꍇɃ_
  pB_̓Ԗڂ̈̓_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[^wqALiApThj
  Ŏ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
      Ȃ郊XgB
  
    ((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-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
[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)


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


ldiff
[Type       ]: Function
[Arguments  ]: ldiff LIST OBJECT
[Package    ]: lisp
[Seealso    ]: tailp
[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    ]: fill-pointer
[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*
[File       ]: builtin.l
[Section    ]: ϐƒ萔
[Description]: 
[Jȕϐ`ătH[]܂B

--- mule̐ ---
̊֐́A binding-list ɏ]ϐoChA forms ̑SẴtH
[ɕ]܂B let  (forms )Ō̃tH[̒lԂ܂B 

binding-list ̊evf́AV{(̏ꍇÃV{ nil ɃoC
h)AtH[ (symbol value-form) ̃Xg(̏ꍇAlet  value- 
form ]ʂ symbol ɃoCh) łB 

tH[(̑S)]O let tH[ exit ꍇA (󒍁Fo
Chꂽ)V{̃[JoCfBO苎܂B 

value-form ̓V{̃oCfBOsȂO (S)Aꂽɕ]
܂(ɂ邱Ƃł??)B̗ɂāAZ  Y ̑O̒l
(2)ɃoChAVlɂ̓oCh܂B 

  (setq Y 2)
  => 2
  (let (X
        (Y 1)
        (Z Y))
    (list X Y Z))
  => (nil 1 2)


let*
[Type       ]: Special Form
[Arguments  ]: let* ({VAR|(VAR [VALUE])}*) {declaration}* {FORM}*
[Package    ]: lisp
[Seealso    ]: let
[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
[File       ]: lispmode.l
[Section    ]: V{
[Description]: 
Lisp ̃V{⊮܂B[ESC TAB]


list
[Type       ]: Function
[Arguments  ]: list &rest ARGS
[Package    ]: lisp
[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-all-packages
[Type       ]: Function
[Arguments  ]: list-all-packages
[Package    ]: lisp
[Seealso    ]: pbP[W
[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
[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
[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


listen
[Type       ]: Function
[Arguments  ]: listen &optional INPUT-STREAM
[Package    ]: lisp
[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
[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
[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
[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")


local-unset-key
[Type       ]: Function
[Arguments  ]: local-unset-key KEY
[Package    ]: editor
[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
[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
[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
[File       ]: number.l
[Section    ]: l
[Description]: 
rbgAND܂BCł&łB

gpF
  ;;; 2i#b11110000#b00110011̃rbg̐ςB
  (format nil "~8,'0b" (logand #b11110000 #b00110011))
  => "00110000"


logior
[Type       ]: Function
[Arguments  ]: logior &rest ARGS
[Package    ]: lisp
[Seealso    ]: logand
[File       ]: number.l
[Section    ]: l
[Description]: 
rbgOR܂BCł|łB

gpF
  ;;; 2i#b00110000#b00000011̃rbg̘aB
  (format nil "~8,'0b" (logior #b00110000 #b00000011))
  => "00110011"


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
[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 , K\̕\L
[File       ]: builtin.l
[Section    ]: EK\
[Description]: 
݂̃J[\ʒuőOɐK\Ń}b`tAȂnilԂ܂B

gpF
  ;;; s(ƃ}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)))


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)


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
[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
[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
[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    ]: aref , setf , make-vector , length , array-dimensions
[File       ]: array.l
[Section    ]: z
[Description]: 
DIMENSIONS Ŏ傫E̔zAlƂĕԂ܂B
ADIMENSIONS  nil ȂA[z񂪂܂B
Ƃ΁Aϐ hoge 4̔z(4̃xNg)ɂ邽߂ɂ́A

  (setf hoge (make-array 4))
  => #(nil nil nil nil)

ϐ foo 2x4̔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))
  (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


make-backup-files
[Type       ]: BufferLocal
[Package    ]: editor
[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
[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[̎
[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
[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-echo-stream
[Type       ]: Function
[Arguments  ]: make-echo-stream INPUT-STREAM OUTPUT-STREAM
[Package    ]: lisp
[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
[File       ]: builtin.l
[Section    ]: nbV
[Description]: 
nbVe[u쐬ĕԂ܂B


make-keymap
[Type       ]: Function
[Arguments  ]: make-keymap
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: L[}bv
[Description]: 
̃L[}bv쐬܂B


make-list
[Type       ]: Function
[Arguments  ]: make-list SIZE &key :initial-element
[Package    ]: lisp
[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
[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 , buffer-local-variables
[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    ]: set-marker
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
̃}[J[ĕԂ܂B

  BUFFER : }[J[obt@w肵܂B


make-package
[Type       ]: Function
[Arguments  ]: make-package PACKAGE-NAME &key :nicknames :use :internal-size :external-size
[Package    ]: lisp
[Seealso    ]: defpackage , delete-package , in-package
[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 , buffer-process , mode-line-format , process-send-string , set-process-sentinel , set-process-filter
[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́CvZX̊֘Atꂽobt@ł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
[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         xNg
  '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    ]: with-input-from-string
[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 , symbol-package
[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
[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
ʂ̐Ftskip-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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: ϐƒ萔
[Description]: 
w肳ꂽV{̒lւ̑܂B
ȍ~boundpnilԂ悤ɂȂ܂BV{ւ̒lƊ֐`̑
͓ƗĂ̂Ł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    ]: make-sequence , mapcar
[File       ]: sequence.l
[Section    ]: V[PX
[Description]: 
SEQUENCE  FUNCTION KpāARESULT-TYPE ɉV[PXԂ܂B

RESULT-TYPE  make-sequence  TYPE Ɠ̂g܂B
FUNCTION ̈ mapcar ƓlASEQUENCE ̊evfЂƂôƂȂ܂B
MORE-SEQUENCES ꍇ͂ mapcar Ɠ悤ɓKp܂B
  
mapcar Ƃ̈Ⴂ͕zɂKpł邱ƂƁARESULT-TYPE ̎w肪KvȂƂł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
[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

---  ---
Description: similar to mapcar except that the value returned is list 
rather than a list of values returned by the calls to function. As such, 
a mapc form is evaluated for its side effects rather than the value it 
returns.

--- Ӗ ---
mapc͖߂lAFUNCTIONɂĕԂꂽl̃Xgł͂ȂƂƂ̈
łLISTȓ_āAmacpcarɗǂĂB̂߁Amapc͖߂l
ł͂ȂpړIƂĕ]B


mapcan
[Type       ]: Function
[Arguments  ]: mapcan FN LISTS &rest MORE-LISTS
[Package    ]: lisp
[Seealso    ]: mapcar
[File       ]: evalmacs.l
[Section    ]: \
[Description]: 
̓nmapcarɂ悭Ă܂A֐̌Ăяoʂ̃Xg
̂Ԃ܂B

---  ---
Description: similar to mapcar except that the values returned by calls 
to function are combined using the destructive function nconc rather than 
the non-destructive function list. As such, mapcan can potentially destroy 
its arguments.

--- Ӗ ---
mapcanFUNCTIONɂĕԂꂽlinon-destructiveȊ֐listł͂ȂA
destructiveȊ֐nconcɂāj邱ƂāAmapcarɗǂ
B̂߁Amapcan͂̒`j󂷂邱ƂɂȂĂB

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    ]: maplist
[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)

---  ---
Description: passes successive, corresponding top level elements of each 
of the lists to function. function should thus be able to accept as many 
arguments as there are lists. The value returned by mapcar is a list of 
the values returned by each function call. If the argument lists are not 
of equal length, evaluation of the mapcar form is terminated when the 
last element of the shortest list has been passed to function. Any elements 
in the other lists that have not been processed are ignored.

--- Ӗ ---
mapcar ͊eXg̍ŏʂ̑ΉvfQ FUNCTION Ɉn܂B
FUNCTION ̓Xĝ悤ȑ̈󂯓Ȃ΂Ȃ܂B
mapcar ԂĺAFUNCTION ̂ꂼ̌Ăяol̃XgłBA
̃XgłȂAmapcar ̕]͈ԒZXgŏI
܂B

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
[File       ]: evalmacs.l
[Section    ]: \
[Description]: 
̓nmaplistɂ悭Ă܂A֐̌Ăяoʂ̃Xg
̂Ԃ܂B


maphash
[Type       ]: Function
[Arguments  ]: maphash FUNCTION HASH-TABLE
[Package    ]: lisp
[Seealso    ]: with-hash-table-iterator
[File       ]: hash.l
[Section    ]: nbV
[Description]: 
nbVe[ůevf֐ɓn܂B

  FUNCTION   : L[ƒl󂯎֐
  HASH-TABLE : nbVe[uw肵܂B

gpF
  (setf (gethash #\a hsh) "Apple")  => "Apple"
  (setf (gethash #\b hsh) "Banana") => "Banana"
  (setf (gethash #\c hsh) "Cake")   => "Cake"
  (with-output-to-selected-buffer
    (maphash #'(lambda (x y) (format t "~S ~S~%"x y)) hsh))
  #\a "Apple"
  #\b "Banana"
  #\c "Cake"


mapl
[Type       ]: Function
[Arguments  ]: mapl FUNCTION LIST &rest MORE-LISTS
[Package    ]: lisp
[Seealso    ]: maplist
[File       ]: builtin.l
[Section    ]: \
[Description]: 
̓nmaplistƂ悭Ă܂A߂lɂ͗^ꂽXg
̂܂ܕԂ܂B


maplist
[Type       ]: Function
[Arguments  ]: maplist FUNCTION LIST &rest MORE-LISTS
[Package    ]: lisp
[Seealso    ]: mapcar
[File       ]: builtin.l
[Section    ]: \
[Description]: 
̃Xg֐̖߂l̃Xg쐬ĕԂ܂B
͊eXgAڂcdrAOڂcddr֐ɓn܂B

---  ---
Description: similar to mapcar but passes successive, corresponding tails 
of the argument lists to function. So, on the first call to function, the 
argument lists are passed in their entirety. On the second call the cdr 
of each argument list is passed. On the third, the cddr of each argument 
list is passed, and so on. This process is repeated until the tail of an 
argument list is a null list. The value returned by maplist is a list of 
the values returned by each call to function.

--- Ӗ ---
maplist ́AFUNCTION ɑΉeC̕ FUNCTION ɓnƂ
āAmapcar ɗǂĂBFUNCTION ̍ŏ̌ĂяoŁÃXg͊
Sɓn܂Bxڂ̌Ăяoł͊éA cdr  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
[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-paragraph
[Type       ]: Function
[Arguments  ]: mark-paragraph
[Package    ]: editor
[File       ]: paragrph.l
[Section    ]: [W
[Description]: 
i̖Ƀ}[NA擪Ƀ|Cgݒ肵܂B


mark-sexp
[Type       ]: Function
[Arguments  ]: mark-sexp &optional (ARG 1)
[Package    ]: editor
[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    ]: set-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
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
w肳ꂽOBJECT}[J[Ԃ܂B

  t     OBJECT̓}[J[
  nil   OBJECT̓}[J[ł͂Ȃ


match-beginning
[Type       ]: Function
[Arguments  ]: match-beginning REGNUM
[Package    ]: editor
[Seealso    ]: match-end , match-string
[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
[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
[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
[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
[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    ]: 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 , 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
[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
[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
[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
[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
[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
[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 , set-text-color
[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
[File       ]: mouse.l
[Section    ]: j[
[Description]: 
|bvAbvj[\܂B

  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
[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
[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 ---

---  ---
Description: evaluates values-form and binds each of the variables provided 
to the respective value returned. If there are more variables than values 
returned, nil is bound to the excess variables. If there are more values 
returned that variables the excess values are discarded. The form arguments 
are then evaluated as an implicit progn construct. The multiple-value-bind 
form returns the value or values returned by evaluating the last form 
argument. See also let.

 (multiple-value-bind (a b c d e)
    (values 1 2 3 4 5)
  (format nil "~D ~D ~D ~D ~D" a b c d e))
 => "1 2 3 4 5"


multiple-value-list
[Type       ]: Macro
[Arguments  ]: multiple-value-list FORM
[Package    ]: lisp
[Seealso    ]: values , 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-setq
[Type       ]: Special Form
[Arguments  ]: multiple-value-setq VARIABLES FORM
[Package    ]: lisp
[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
[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Ԃ܂BLISTύX܂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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
̃XgɂƂĂXgԂ܂B
͕ύX܂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
[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
[File       ]: cmds.l
[Section    ]: ֐
[Description]: 
ɑR}hɕ̑Oun܂B[ESC -]


new-pseudo-frame
[Type       ]: Function
[Arguments  ]: new-pseudo-frame NAME &optional SAVE-P SELECTED-FN DELETED-FN
[Package    ]: editor
[Seealso    ]: t[̊Tv , select-pseudo-frame , delete-pseudo-frame , *select-pseudo-frame-hook*
[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
[File       ]: cmds.l
[Section    ]: eLXg
[Description]: 
s}܂B[RET]


newline-and-indent
[Type       ]: Function
[Arguments  ]: newline-and-indent &optional (ARG 1)
[Package    ]: editor
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
sA݂钼O̍sƓCfg܂B
[hɈˑCfgR}h͎gp܂B


next-buffer
[Type       ]: Function
[Arguments  ]: next-buffer
[Package    ]: editor
[Seealso    ]: previous-buffer , *next-buffer-in-tab-order*
[File       ]: buffer.l
[Section    ]: obt@
[Description]: 
̃obt@ɐؑւ܂BGfB^Ōݑ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


next-line
[Type       ]: Function
[Arguments  ]: next-line &optional (N 1)
[Package    ]: editor
[Seealso    ]: next-virtual-line
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
Ns̕sɈړ܂B
  t    ŏIsȊȌꍇ
  nil  ŏIs̏ꍇ


next-line-add-newlines
[Type       ]: Variable
[Package    ]: editor
[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*
[File       ]: page.l
[Section    ]: EBhE
[Description]: 
wy[WʂXN[܂B
*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
[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
  t    ŏIsȊȌꍇ
  nil  ŏIs̏ꍇ


next-window
[Type       ]: Function
[Arguments  ]: next-window WINDOW &optional MINIBUF
[Package    ]: editor
[Seealso    ]: previous-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


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 ͕ύX܂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
[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
܂ύXĂȂƂɂȂ܂B
(set-buffer-modified-p nil)interactivełłB


notany
[Type       ]: Function
[Arguments  ]: not-any 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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
X 𔽓] Y ܂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]: 
SEQUENCEtɂVSEQUENCE쐬ĕԂ܂Bsequence͔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 ͕ύX܂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 ͕ύX܂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͕ύX܂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ɂԂ܂BSTRING͕ύX܂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啶ɂԂ܂BSTRING͕ύX܂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 ɒu܂B
 TREE ͒u܂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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
TREE̒OLDNEWɒuTREEԂ܂B
TREE͒u܂B

gpF
  ;;; Kŵc[substĂ݂Ba͂̂܂
  (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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
TREE̒TEST𖞂̂NEWɒûԂ܂B
TREEύX_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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
TREE̒TEST𖞂Ȃ̂NEWɒûԂ܂B
TESTύX_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
[File       ]: sequence.l
[Section    ]: V[PX
[Description]: 
SEQUENCE ɑ΂ OLDITEM Ƃ :test 𖞑vf NEWITEM ɒuԂ܂B
 SEQUENCE ͕ύX܂B

  :test     : eXgs2Zq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇ͗̒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ɒuԂ܂B
SEQUENCE͕ύX܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇ͗̒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ɒuԂ܂B
SEQUENCE͕ύX܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇ͗̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪A non-nil ŖusB :count
              ^ꂽ݈̂ӖB


nth
[Type       ]: Function
[Arguments  ]: nth N LIST
[Package    ]: lisp
[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
[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
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
OBJECT()ȂtAȊ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
[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 ͕ύX܂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


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))


open
[Type       ]: Function
[Arguments  ]: open FILENAME &key :direction :if-exists :if-does-not-exist :encoding :share
[Package    ]: lisp
[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
                        sR[h*default-fileio-encoding*Ɉˑ܂B
        :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
[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
[File       ]: builtin.l
[Section    ]: VXe
[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


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
[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 {FORM}*
[Package    ]: lisp
[Seealso    ]: and
[File       ]: evalmacs.l
[Section    ]: \
[Description]: 
tH[nil̊ԂԂɕ]܂B
tH[łnilłȂ΁Aŕ]𒆒fătH[̒lԂ
ďI܂BSẴtH[nilȂ΁AnilԂ܂B

  ;;; exp1 nilȂAŎs𒆎~nilԂB
  ;;; exp2 nilȂAŎs𒆎~nilԂB
  ;;; ...
  ;;; ŌɎ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
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
ŋ(?)\Ăobt@ɐؑւ܂B


other-pseudo-frame
[Type       ]: Function
[Arguments  ]: other-pseudo-frame
[Package    ]: editor
[Seealso    ]: previous-pseudo-frame , next-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
[File       ]: window.l
[Section    ]: EBhE
[Description]: 
ꂽEBhE̒ړ܂B

  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
[File       ]: builtin.l
[Section    ]: pbP[W
[Description]: 
pbP[Ŵ̖擾܂B

gpF
  (package-name (find-package "ed"))
  => "editor"


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
[File       ]: builtin.l
[Section    ]: o
[Description]: 
𐮐ɕϊĕԂ܂Bl̂̂ƁA̗̕LȌ
lŕԂ܂B

---  ---
Description: examines the characters of string specified by :start and 
:end, and attempts to parse an integer ignoring whitespace characters. 
The keyword :radix defines the base to which the integer is to be parsed 
and must be in the range 2 to 36. If :junk-allowed is non-nil, the first 
value returned is the integer parsed or nil if no acceptable digits were 
found. If :junk-allowed is nil, an error is signaled if the substring is 
not an integer in the appropriate base, with optional sign. Note that 
radix specifiers #o, #b, #x and #nR are not recognized, nor is the decimal 
point.

--- Ӗ ---
parse-integer  :start  :end Ŏꂽ̕т`FbNA
𖳎Đ̓ǂݍ݂݂܂B :radix L[[h͐lǂݍ
܂ׂ`܂B 2  36 ܂ł͈̔͂ɂȂ΂Ȃ
BA :junk-allowed  nil ȊOœǂݍ߂Ȃ nil 
Ȃ܂BA :junk-allowed  nil œǂݍ߂Ȃ΃G[
܂BȂAƂ#o #b #x y #nR ͔FłȂ̂Œӂ
ƁB

# ƂȂĂ܂A󔒂͓Ă͂߂݂B

gpF
  (parse-integer "123")
  => 123
     3
  (parse-integer "123+23")
  => sȐľ`ł: "123+23"
  (parse-integer "123+23" :junk-allowed t)
  => nil
     3
  (parse-integer "a" :radix 16)
  => 10


parse-point-syntax
[Type       ]: Function
[Arguments  ]: parse-point-syntax &optional POINT
[Package    ]: editor
[Seealso    ]: syntax-table
[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^Ɉ͂܂ꂽ̈
  nil      LȊÖ̗


paste-from-clipboard
[Type       ]: Function
[Arguments  ]: paste-from-clipboard
[Package    ]: editor
[Seealso    ]: paste-rectangle-from-clipboard , si:*paste-hook*
[File       ]: select.l
[Section    ]: [W
[Description]: 
Nbv{[h̓e\t܂B


paste-rectangle-from-clipboard
[Type       ]: Function
[Arguments  ]: paste-rectangle-from-clipboard
[Package    ]: editor
[Seealso    ]: paste-from-clipboard
[File       ]: select.l
[Section    ]: [W
[Description]: 
paste-from-clipboardƂ͈قȂANbv{[h̓e`œ\t܂B


path-equal
[Type       ]: Function
[Arguments  ]: path-equal PATHNAME1 PATHNAME2
[Package    ]: lisp
[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
[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

gpF
  ;;; W͂̕B
  (peek-char *standard-input* nil 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
[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


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
[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
[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
[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
[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


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
[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
[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
[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
[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]: 
Cӂ̃obt@ŔCӂ̑삪sꂽƂɌĂяo܂B
[xyzzy:06354]Q
xyzzy 0.2.1.186`
  
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
[File       ]: builtin.l
[Section    ]: |WV
[Description]: 
ZNV݂ t Ȃ nil Ԃ܂B


preceding-char
[Type       ]: Function
[Arguments  ]: preceding-char
[Package    ]: editor
[Seealso    ]: following-char
[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


previous-line
[Type       ]: Function
[Arguments  ]: previous-line &optional (N 1)
[Package    ]: editor
[Seealso    ]: forward-line , previous-virtual-line
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
1sOɈړ܂B

gpF
  (previous-line)


previous-page
[Type       ]: Function
[Arguments  ]: previous-page
[Package    ]: editor
[Seealso    ]: next-page
[File       ]: page.l
[Section    ]: EBhE
[Description]: 
1y[WʂXN[܂B
*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
[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
  t    擪sȊȌꍇ
  nil  擪s̏ꍇ


previous-window
[Type       ]: Function
[Arguments  ]: previous-window WINDOW &optional MINIBUF
[Package    ]: editor
[Seealso    ]: next-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


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]: 
vZXtĂ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
[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̊R[hw肵܂B


process-outcode
[Type       ]: Function
[Arguments  ]: process-outcode PROCESS
[Package    ]: editor
[Seealso    ]: set-process-outcode
[File       ]: builtin.l
[Section    ]: vZX
[Description]: 
PROCESSɐݒ肳ꂽo͗p̊R[hw肵܂B


process-send-string
[Type       ]: Function
[Arguments  ]: process-send-string PROCESS STRING
[Package    ]: editor
[Seealso    ]: make-process
[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-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
[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ł͂Ȃ


prog1
[Type       ]: Macro
[Arguments  ]: prog1 FIRST &body BODY
[Package    ]: lisp
[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
[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
[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
[File       ]: evalmacs.l
[Section    ]: ϐƒ萔
[Description]: 
ϐɒlݒ肵܂B

  (psetq ϐ1 l1 ϐ2 l2 ... ϐN lN)

L̗lɕϐƒl̑gCӂׂ̐邱Ƃł܂B 

setqƎĂ܂setq珇ɕϐɑĂ̂ɑ΂Apsetq͒l
Sĕ]ő܂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
[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
[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
[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

  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

  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
[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
[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-buffer-name
[Type       ]: Function
[Arguments  ]: read-buffer-name PROMPT &key :default :history
[Package    ]: editor
[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   : qXg̃Xg

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
[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

---- Common Lisp ------
Description: reads one character from the current stream and returns it 
as an object. If end of file is encountered, the operation of read-char 
is determined by the eof-error-p and eof-value arguments (see read).


read-char-encoding
[Type       ]: Function
[Arguments  ]: read-char-encoding PROMPT &key :history
[Package    ]: editor
[Seealso    ]: *char-encoding-list*
[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   : qXg̃Xg

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
[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
[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   : qXg̃Xg


read-directory-name
[Type       ]: Function
[Arguments  ]: read-directory-name PROMPT &key :default :title :history
[Package    ]: editor
[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   : qXg̃Xg

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 Ƃ̈Ⴂ͖HHH
(ڍוs)
(interactive "Z") ɑ܂B


read-exist-buffer-name
[Type       ]: Function
[Arguments  ]: read-exist-buffer-name PROMPT &key :default :history
[Package    ]: editor
[Seealso    ]: read-buffer-name
[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   : qXg̃Xg


read-exist-file-name
[Type       ]: Function
[Arguments  ]: read-exist-file-name PROMPT &key :default :title :history
[Package    ]: editor
[Seealso    ]: read-file-name
[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   : qXg̃Xg


read-file-name
[Type       ]: Function
[Arguments  ]: read-file-name PROMPT &key :default :title :history
[Package    ]: editor
[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   : qXg̃Xg

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
[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   : qXg̃Xg


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
[File       ]: builtin.l
[Section    ]: ~jobt@
[Description]: 
~jobt@Ƀvvg\ă[U[֐͂̂҂܂B
[U[̓͂֐̃V{Ԃ܂B
(interactive "a") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : qXg̃Xg


read-integer
[Type       ]: Function
[Arguments  ]: read-integer PROMPT
[Package    ]: editor
[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-line
[Type       ]: Function
[Arguments  ]: read-line &optional INPUT-STREAM EOF-ERROR-P EOF-VALUE RECURSIVE-P
[Package    ]: lisp
[File       ]: builtin.l
[Section    ]: o
[Description]: 
---  ---
Description: is usually used to read text from the keyboard. It reads 
characters from input-stream until the #\newline character is encountered, 
and collects them into a string without the #\newline character. This 
function returns two values. The first is the string collected.  The 
second is non-nil if the operation is terminated on end of file and nil 
otherwise. If end of file is encountered immediately, operation of read-line 
is determined by the eof-error-p and eof-value arguments.

--- Ӗ ---
read-line̓L[{[heLXgǂݍނ̂Ɏg܂B#\LFDoĂ
܂INPUT-STREAM當ǂݍ݂܂BāA#\LFDȊOW߂ĕ
ɂ܂Bread-line͓̒lԂ܂Bŏ̒l͏W߂񂻂̂
̂łBڂ̒ĺAt@C̏I[܂łĂ܂non-nilԂ܂B
łȂnilԂ܂Bt@C̏I[ɌꂽA
read-lineEOF-ERROR-PEOF-VALUEɂI܂B


read-registry
[Type       ]: Function
[Arguments  ]: read-registry SECTION KEY &optional ROOT
[Package    ]: editor
[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
[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
[File       ]: builtin.l
[Section    ]: ~jobt@
[Description]: 
~jobt@Ƀvvg\ă[U[͂̂҂܂B
[U[̓͂Ԃ܂B
(interactive "s") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : qXg̃Xg

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
[File       ]: builtin.l
[Section    ]: ~jobt@
[Description]: 
~jobt@Ƀvvg\ă[U[V{͂̂҂܂B
[U[̓͂V{Ԃ܂B
(interactive "S") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : qXg̃Xg


read-variable-name
[Type       ]: Function
[Arguments  ]: read-variable-name PROMPT &key :default :history
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: ~jobt@
[Description]: 
~jobt@Ƀvvg\ă[U[ϐ͂̂҂܂B
[U[̓͂ϐ̃V{Ԃ܂B
(interactive "v") ɑ܂B

  PROMPT     : vvg
  :default   : lƂ镶
  :history   : qXg̃Xg


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
w肵ȂΌݍsʂ̒Ɉʒu܂B
(recenter 0)ŌݍsEChËԏɗ܂B


redo
[Type       ]: Function
[Arguments  ]: redo
[Package    ]: editor
[Seealso    ]: 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
[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
[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
[File       ]: builtin.l
[Section    ]: f[^^
[Description]: 
w肳ꂽOBJECTRpCςݐK\Ԃ܂B

  t     OBJECT̓RpCςݐK\
  nil   OBJECT̓RpCςݐK\ł͂Ȃ


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
[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
[File       ]: builtin.l
[Section    ]: V[PX
[Description]: 
SEQUENCE̒ITEMƈv̂폜SEQUENCEԂ܂B
SEQUENCE͂̂܂܁BSEQUENCEύX΁AdeletegƁ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 , remove
[File       ]: sequence.l
[Section    ]: V[PX
[Description]: 
SEQUENCE ̒dvf폜V[PXԂ܂B
remove lÃV[PX͕ύX܂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    ]: delete-if
[File       ]: builtin.l
[Section    ]: V[PX
[Description]: 
SEQUENCE̒PREDICATE𖞂̂폜SEQUENCEԂ܂B
SEQUENCE͂̂܂܁B


remove-if-not
[Type       ]: Function
[Arguments  ]: remove-if-not PREDICATE SEQUENCE &key :from-end :start :end :count :key
[Package    ]: lisp
[Seealso    ]: delete-if-not
[File       ]: builtin.l
[Section    ]: V[PX
[Description]: 
SEQUENCE̒PREDICATE𖞂Ȃ̂폜SEQUENCEԂ܂B
SEQUENCE͂̂܂܂łB


remove-trail-slash
[Type       ]: Function
[Arguments  ]: remove-trail-slash STRING
[Package    ]: editor
[Seealso    ]: append-trail-slash
[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
[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
[File       ]: buffer.l
[Section    ]: obt@
[Description]: 
obt@Ɋ֘AÂꂽt@CύX܂Bobt@ɕύX܂B
ύXɐnilȊO̒lAsnilԂ܂B

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
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
t@C͕ςɃobt@ύX܂B

--- mule̐ ---
̊֐́AJgobt@ buffer-name Ƀl[܂B 

buffer-name XgOłȂ肻̖Õobt@łɑ݂Ă
AG[ɂȂ܂B nil Ԃ܂B


rename-file
[Type       ]: Function
[Arguments  ]: rename-file FILE NEW-NAME &key :if-exists :if-access-denied
[Package    ]: lisp
[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      IɃt@C̕ύX݂܂B
  :if-access-denied : ANZXۂꂽꍇ̓w肵܂B
        :error          G[o͂܂B
        :skip           G[͏o͂AnilԂ܂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
[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
[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
[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
[File       ]: search.l
[Section    ]: EK\
[Description]: 
obt@ĕŒu܂Bperform-replacegĎ
܂B

  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

--- mule̐ ---
Command: replace-string string replacement &optional delimited

̊֐́A string ̏o(󒍁Foccurrences) replacement Œu܂B


require
[Type       ]: Function
[Arguments  ]: require MODULE-NAME &optional PATHNAME
[Package    ]: lisp
[Seealso    ]: load-library , provide , *modules*
[File       ]: evalmacs.l
[Section    ]: ]
[Description]: 
w肵W[ǂݍ݂܂BɓǍς݂łΉ܂B

---  ---
Description: the argument module-name, which can be a string or a symbol 
(in which case the print name of the symbol is used), should be the name 
of some Lisp subsystem, which may or may not be already in the Lisp image. 
require checks to see if it has been loaded by looking for it on the list 
which is the value of *modules*. The test is case-sensitive. If the module 
name is not on the *modules* list, require tries to load it into Lisp. 
If pathname is present as a single pathname or a list of pathnames, require 
loads those files in order. If the argument pathname is not present, 
require attempts to load the file named module-name (or the print name 
of module-name if it is a symbol). If the module is already present, 
require returns nil. It is an error if the files cannot be loaded for any 
reason. Note that module-name is typically a symbol and, since symbol 
print names rarely also name files, it is recommended that pathname be 
supplied. 

݊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
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
[File       ]: builtin.l
[Section    ]: \
[Description]: 
ubNEo܂B
---  ---
Description: used to terminate the evaluation of the block construct with 
name NAME. The name argument is not evaluated and must be a symbol. When 
return-from is encountered the result-form is evaluated if present and 
evaluation of the block is terminated. The block returns the value returned 
by the result-form or nil if no result-form is present. If name is nil, 
return-from can be used to terminate the evaluation of do  and prog 
constructs that automatically create a block called nil to enclose their 
argument forms.

Example:

(block fred
  (setq x 10)
  (loop (incf x) (if (> x 20) (return-from fred x))))
 21


revappend
[Type       ]: Function
[Arguments  ]: revappend X Y
[Package    ]: lisp
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
X 𔽓] Y ܂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]: 
SEQUENCEtɂVSEQUENCE쐬ĕԂ܂Bsequence͂̂܂܂ł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
[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
(rotatef a b c d)Ƃƈȉ̂悤ɂȂ܂B

        a   b   c 
sOF 1   2   3
            
          
   (*)      (*)
                      
        a   b   c 
sF 2   3   1
            

---  ---
Description: similar to shiftf except that the value accessed by the 
form place1 is not discarded. Instead it is assigned to the location 
accessed by the form placeN. Therefore, the list of place forms is 
treated like a circular register that is rotated by one position. 
Returns nil As in the case of setf and psetf, the ANSI standard 
specifies that one can rotatef more than one value to a place which has 
more than one store variable and which has an appropriately defined 
setf-method.

--- Ӗ ---
1Ԗڂ̃tH[ɂĎQƂl̂ĂȂƂshiftfƓ
łB̑ɁANԖڂ̃tH[ɂĎQƂʒuɁA1Ԗڂ̃t
H[ɂĎQƂlݒ肳܂B̂߁AtH[̃Xg͊
̃WX^ƂĈ܂BsetfpsetfɂĂnilԂꍇ
AANSIł́AsetfɂK؂ɒ`ꂽЂƂȏ̊i[p̕ϐɒl
悤rotatefłƒ߂Ă܂B

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
[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-hook-with-args
[Type       ]: Function
[Arguments  ]: run-hook-with-args HOOK &rest ARGS
[Package    ]: editor
[Seealso    ]: run-hooks
[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
[File       ]: builtin.l
[Section    ]: [h
[Description]: 
run-hooksƓ悤Ɋ֐s܂Brun-hooksƈقȂ蕜Al
  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
[File       ]: builtin.l
[Section    ]: [h
[Description]: 
run-hooksƓ悤Ɋ֐s܂Brun-hooksƈقȂ蕜Al
  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
[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
[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
[File       ]: list.l
[Section    ]: Xg
[Description]: 
(cdr X)  X  nil  cons łȂ΃G[ɂȂ܂
 safe-cdr ̓G[𔭐 nil Ԃ܂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

--- mule̐ --- 
̓tH[́AJgobt@̃|Cgƃ}[NZ[uA forms 
]A|Cgƃ}[NXgA܂B (throw  error ɂ) 
 exit ̏ꍇ|Cgƃ}[N̒lXgA܂B}[J[̓obt@
̃|WVƂƂɂ̃obt@wĂ邽߁A}[NXgA
Ƃ (Emacs ) Jgobt@ notion (󒍁F??) XgA邱
ƂɂȂ܂B 

Jgobt@ notion ύXȂĂ͂ȂꍇAJgobt
@̃|Cg𓮂ȂĂ͂ȂꍇAJgobt@ƃ|Cg
XgAł悤ɂ̂ (WI)@łB 

ʂ̃obt@̃|Cg}[N̓Z[u܂B̂()|C
g}[Nɑ΂ύX save-excursion  exit ێ܂B 

save-excursion ́Aswitch-to-buffer ̂悤Ȋ֐Ŕj󂳂ꂽEBhE 
obt@̑Ή̓XgA܂B selected EBhEXgA@
 1 save-excursion  save-window-excursion p邱Ƃł(ZN
V  25.11 [save-window-excursion]Ay[W 248 Q)B 

Ԃl(Ō)]ꂽtH[̕ԂlAtH[^Ă
Ȃꍇ nil ɂȂ܂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-some-buffers
[Type       ]: Function
[Arguments  ]: save-some-buffers &optional VERBOSE (FN #'WRITE-FILE)
[Package    ]: editor
[File       ]: files.l
[Section    ]: t@CVXe
[Description]: 
JĂobt@ۑ܂B
  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
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    ]: regexpp , compile-regexp , match-beginning , match-end , perform-replace , markerp , make-marker , set-marker , skip-chars-forward , K\̕\L
[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    ]: 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
[File       ]: builtin.l
[Section    ]: EBhE
[Description]: 
xyzzỹEBhEŜ̍sɂȂ̂Ԃ܂B


screen-width
[Type       ]: Function
[Arguments  ]: screen-width
[Package    ]: editor
[Seealso    ]: screen-height
[File       ]: builtin.l
[Section    ]: EBhE
[Description]: 
xyzzỹEBhEŜ̕ɂȂ̂Ԃ܂B


scroll-down-both-window
[Type       ]: Function
[Arguments  ]: scroll-down-both-window
[Package    ]: editor
[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
[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
[File       ]: cmds.l
[Section    ]: EBhE
[Description]: 
EBhEw茅AɃXN[܂B[C-x <]
̐lw肷ƋtɃXN[܂B

⑫:
  version 0.2.2.234 ł͕tɂȂĂ܂B


scroll-other-window
[Type       ]: Function
[Arguments  ]: scroll-other-window &optional ARG
[Package    ]: editor
[Seealso    ]: scroll-window
[File       ]: cmds.l
[Section    ]: EBhE
[Description]: 
̃EBhEXN[܂B
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
[File       ]: cmds.l
[Section    ]: EBhE
[Description]: 
EBhEw茅AEɃXN[܂B[C-x >]
̐lw肷ƋtɃXN[܂B

⑫:
  version 0.2.2.234 ł͕tɂȂĂ܂B


scroll-up-both-window
[Type       ]: Function
[Arguments  ]: scroll-up-both-window
[Package    ]: editor
[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
[File       ]: cmds.l
[Section    ]: EBhE
[Description]: 
̃EBhEwsXN[܂B


scroll-window
[Type       ]: Function
[Arguments  ]: scroll-window ARG
[Package    ]: editor
[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 n)


scroll-window-horizontally
[Type       ]: Function
[Arguments  ]: scroll-window-horizontally ARG
[Package    ]: editor
[Seealso    ]: scroll-window
[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
[File       ]: search.l
[Section    ]: EK\
[Description]: 
ǑőO܂B


second
[Type       ]: Function
[Arguments  ]: second X
[Package    ]: lisp
[Seealso    ]: first , cadr
[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
[File       ]: buffer.l
[Section    ]: obt@
[Description]: 
obt@I_CAO\܂B
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    ]: t[̊Tv , switch-pseudo-frame , pseudo-frame-selector , find-pseudo-frame , new-pseudo-frame , *select-pseudo-frame-hook*
[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
[File       ]: pframe.l
[Section    ]: EBhE
[Description]: 
ݑIĂt[Ԃ܂B


selected-window
[Type       ]: Function
[Arguments  ]: selected-window
[Package    ]: editor
[Seealso    ]: set-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
[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
[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
[File       ]: builtin.l
[Section    ]: ϐƒ萔
[Description]: 
V{ɒl𑩔܂B

  SYMBOL : V{
  VALUE  : ݒ肷l

gpF
  ;;; fooƂV{ɒl𑩔Ă݂B
  (boundp 'foo)         => nil
  (set 'foo 2)          => 2
  (boundp 'foo)         => t
  foo                   => 2


set-buffer
[Type       ]: Function
[Arguments  ]: set-buffer BUFFER
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
obt@I܂B

--- mule̐ ---
̊֐́A buffer Jgobt@ɂ܂Ãobt@ 
select ĂEBhEɕ\邱Ƃ͂܂B(Emacs )R
}hxɖ߂() select ĂEBhẼobt@(
)JgɂȂ邱ƂӖĂ܂B 

̊֐́A(Jgobt@ȊÕobt@ŃGfBbgsȂ)R}h
ۂɗp܂B buffer Ŏobt@Ԃ܂B 

buffer ()obt@wȂꍇAG[ɂȂ܂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
[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
[File       ]: builtin.l
[Section    ]: ϐƒ萔
[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
[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
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
obt@̊R[hCODEɂ܂Bݒ肵R[h
buffer-fileio-encodingŎQƂ邱Ƃł܂B

  CODE   : R[hw肵܂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
[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
[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
[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
[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
[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
[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
[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
[File       ]: list.l
[Section    ]: Xg
[Description]: 
̃Xg̍Ԃ܂B

---  ---
Description: Copies list1 and list2 and returns the 
elements of list1 that do not match any element in list2 using the test 
specified by the :test or :test-not argument. The order of the elements 
in the returned list may not reflect their relative positions within 
list1.

--- Ӗ ---
set-difference  LIST1  LIST2 Rs[āALIST2 ɈvȂ LIST1 
̗vfԂ܂BṽeXg :test y :test-not ̈Ŏw肵܂B
Ԃ郊Xg̗vf̏Ԃ́ALIST1 ̏Ԃۏ؂܂B

gpF
  (set-difference  '(3 6 9) '(2 4 6 8 10))
  => (9 3)


set-exclusive-or
[Type       ]: Function
[Arguments  ]: set-exclusive-or LIST1 LIST2 &rest REST &key :test :test-not :key
[Package    ]: lisp
[Seealso    ]: nset-exclusive-or
[File       ]: list.l
[Section    ]: Xg
[Description]: 
LIST1  LIST2 ̂ꂩɂ̂݊܂܂vf̃XgĕԂ܂B
nset-exclusive-or ƈႢ̃Xg͕ύX܂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
w肳ꂽĺAϐ fill-column ɑ܂B

  COL : lߍ݌
        Ȃꍇ́Ã݂J[\ʒǔlߍ݌ɐݒ肵
        ܂B


set-fill-prefix
[Type       ]: Function
[Arguments  ]: set-fill-prefix
[Package    ]: editor
[File       ]: fill.l
[Section    ]: ̑
[Description]: 
s|Cg܂łfill prefixɐݒ肵܂BsŎ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
[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-local-window-flags
[Type       ]: Function
[Arguments  ]: set-local-window-flags WINDOW-OR-BUFFER FLAGS ON-OR-OFF
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: EBhE
[Description]: 
EBhE̓obt@̊e\𐧌䂵܂B

 BUFFER-OR-WINDOW : obt@EBhÊꂩw肵܂B
 FLAG             : ̃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
 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)


set-macro-character
[Type       ]: Function
[Arguments  ]: set-macro-character CHAR FUNCTION &optional NON-TERMINATING-P READTABLE
[Package    ]: lisp
[File       ]: builtin.l
[Section    ]: o
[Description]: 
iڍוsj

gpF
  (set-macro-character #\? 'read-test)
  (defun read-test (stream ch)
    (list '*question* (read stream)))


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
[File       ]: cmds.l
[Section    ]: |WV
[Description]: 
}[Nݒ肵܂B
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    ]: make-marker , unset-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
[File       ]: builtin.l
[Section    ]: j[
[Description]: 
w肳ꂽj[ftHg̃j[ɂ܂Bxyzzy㕔ɏ펞\
悤ɂȂ܂B

  MENU : ݒ肷郁j[w肵܂B
         j[svȂnilw肵܂B


set-minor-mode-map
[Type       ]: Function
[Arguments  ]: set-minor-mode-map KEYMAP &optional BUFFER
[Package    ]: editor
[Seealso    ]: unset-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
[File       ]: builtin.l
[Section    ]: ̑
[Description]: 
t@NVo[̃x̐ݒ肵܂Bwł鐔́A
4/5/8/10/12/15ł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
[File       ]: builtin.l
[Section    ]: vZX
[Description]: 
vZX̏o͂H邽߂̃tB^w肵܂B


set-process-incode
[Type       ]: Function
[Arguments  ]: set-process-incode PROCESS CODE
[Package    ]: editor
[Seealso    ]: set-process-outcode
[File       ]: builtin.l
[Section    ]: vZX
[Description]: 
vZXset-process-filterɓ͂ꍇ̊R[hw肵܂B


set-process-outcode
[Type       ]: Function
[Arguments  ]: set-process-outcode PROCESS CODE
[Package    ]: editor
[Seealso    ]: set-process-incode
[File       ]: builtin.l
[Section    ]: vZX
[Description]: 
vZXɑ΂send-process-stringꍇ̊R[hw肵܂B


set-process-sentinel
[Type       ]: Function
[Arguments  ]: set-process-sentinel PROCESS SENTINEL
[Package    ]: editor
[Seealso    ]: process-sentinel , set-process-filter
[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    ]: syntax-table
[File       ]: builtin.l
[Section    ]: V^bNX
[Description]: 
w肳ꂽ#\SPCȊÕLN^ꍇɃRgsƌ
܂B̃LN^ɂꍇɂ́A
set-syntax-optionQƂĉ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    ]: syntax-end-c++-comment-p
[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    ]: syntax-end-comment-p
[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
[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    ]: 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-junk
[Type       ]: Function
[Arguments  ]: set-syntax-junk SYNTAX-TABLE CHAR
[Package    ]: editor
[Seealso    ]: syntax-junk-p
[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
[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
[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 , 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
[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
[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
[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-optionQƂĉB


set-syntax-start-comment
[Type       ]: Function
[Arguments  ]: set-syntax-start-comment SYNTAX-TABLE CHAR &optional PARSE-SEXP-IGNORE-COMMENT-P
[Package    ]: editor
[Seealso    ]: syntax-start-comment-p
[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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: V^bNX
[Description]: 
V^bNXe[uɃ^O̊JnLƏILݒ肵܂B
HTMLXMLñ[hɐݒ肷Ƃ݂ł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
[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
[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 , set-text-color , find-text-attribute
[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
[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
[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̏


setf
[Type       ]: Macro
[Arguments  ]: setf {PLACE NEW-VALUE}*
[Package    ]: lisp
[Seealso    ]: setq
[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ɋ̃xNg(setfsetqł悢)
  => #(nil nil nil)
  (setf (aref hoge 1) 5); hogexNg2Ԗڂ̐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
[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 , 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
[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


shrink-window-horizontally
[Type       ]: Function
[Arguments  ]: shrink-window-horizontally &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: enlarge-window-horizontally
[Section    ]: EBhE
[Description]: 
J[\̂EBhE̕܂B

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
[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:*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
[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
[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:closure-variable
[Type       ]: Function
[Arguments  ]: si:closure-variable CLOSURE
[Package    ]: system
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: EBhE
[Description]: 
ʂ񕪊܂Bsƕw\łB

  ARG      : sw肵܂B
  VERTICAL : cɕ܂B
        t       ɓ񕪊܂B
        nil     cɓ񕪊܂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
[File       ]: window.l
[Section    ]: EBhE
[Description]: 
A split-window ̉ɓ񕪊̂ƓłB


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
[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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: EK\
[Description]: 
match-data őޔĂ_̏Ԃ߂܂B


streamp
[Type       ]: Function
[Arguments  ]: streamp OBJECT
[Package    ]: lisp
[File       ]: builtin.l
[Section    ]: o
[Description]: 
OBJECTXg[ۂԂ܂B
  t    OBJECT̓Xg[łB
  nil  OBJECT̓Xg[łȂB


string
[Type       ]: Function
[Arguments  ]: string X
[Package    ]: lisp
[File       ]: builtin.l
[Section    ]: 
[Description]: 
XȂ炻Ԃ܂BV{Ȃ炻̖OԂ܂B

gpF
  (string "foo")
  => "foo"
  (string 'bar)
  => "bar"


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

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
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRINGɂԂ܂BSTRING͕ύX܂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    ]: string=
[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>
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2啶Ɋ֌WȂrāAΈ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<
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2啶Ɋ֌WȂrďɍΈvȂ
̃CfbNXAłȂnilԂ܂B

gpF  
  (string-lessp "Aa" "ab")
  => 1
  (string-lessp "ac" "AB")
  => nil


string-match
[Type       ]: Function
[Arguments  ]: string-match REGEXP STRING &optional START END
[Package    ]: editor
[Seealso    ]: string-matchp , looking-at , K\̕\L
[File       ]: builtin.l
[Section    ]: 
[Description]: 
w肳ꂽ񂪐K\Ɉv邩ǂԂ܂B

  REGEXP : K\
  STRING : `FbN镶
  START  : ̊Jnʒu
  END    : ̏Iʒu

--- mule̐ ---
̊֐́A(string )K\ regexp ɍŏɃ}b`ꏊ̃Cf
bNXA (}b`Ȃꍇ) nil Ԃ܂B start  non-nil ̏ꍇA
T[` string ̂̃CfbNXsȂ܂B 

}b`̐(ŏ)̃CfbNX (match-end 0) ō܂B 
0 łȂA[Mg match-end  match-beginning ̓p^[
ʍ\(󒍁Fparenthesis constructs) Ƀ}b`TuXgÕC
fbNX^܂B 

  (string-match "X[a-z]*Y" "X1 Y Xab cY XabcY")
  => 12
  (match-end 0)
  => 17

݊F
  muleB
  Common LispȂB


string-matchp
[Type       ]: Function
[Arguments  ]: string-matchp REGEXP STRING &optional START END
[Package    ]: editor
[Seealso    ]: string-match
[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ēȂtA
ȂnilԂ܂Bstring-equal̔΂̋@\łB


string-not-greaterp
[Type       ]: Function
[Arguments  ]: string-not-greaterp STRING1 STRING2 &key :start1 :end1 :start2 :end2
[Package    ]: lisp
[Seealso    ]: string<=
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2啶Ɋ֌WȂrďɍΈvȂ
̃CfbNXAłȂnilԂ܂B


string-not-lessp
[Type       ]: Function
[Arguments  ]: string-not-lessp STRING1 STRING2 &key :start1 :end1 :start2 :end2
[Package    ]: lisp
[Seealso    ]: string>=
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2啶Ɋ֌WȂrďɍΈ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
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING啶ɂԂ܂BSTRING͕ύX܂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ēȂtAłȂnilԂ܂B
p̑啶Ə͋ʂ܂Bstring=̔΂̋@\łB


string<
[Type       ]: Function
[Arguments  ]: string< STRING1 STRING2 &key :start1 :end1 :start2 :end2
[Package    ]: lisp
[Seealso    ]: string-lessp
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2rďɍΈvȂ̃CfbNXA
łȂ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-not-greaterp
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2rďɍΈvȂ̃CfbNXA
łȂnilԂ܂B


string=
[Type       ]: Function
[Arguments  ]: string= STRING1 STRING2 &key :start1 :end1 :start2 :end2
[Package    ]: lisp
[Seealso    ]: string-equal
[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-greaterp
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2rďɍΈvȂ̃CfbNXA
łȂ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-not-lessp
[File       ]: builtin.l
[Section    ]: 
[Description]: 
STRING1STRING2rďɍΈvȂ̃CfbNXA
łȂ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
[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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
TREE ̒ ALIST  :key Ƃ :test 𖞂̂ VALUE ɒu܂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
[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
[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
[File       ]: builtin.l
[Section    ]: Xg
[Description]: 
TREE̒OLDNEWɒuTREẼ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
[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
[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
Ԃ܂B SEQUENCE ͕ύX܂񂪁A߂lƈꕔL
܂B

  :test     : eXgs2Zq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇ͗̒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ɒuԂ܂B
SEQUENCE͕ύX܂񂪁A߂lƈꕔL邩܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇ͗̒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ɒuԂ܂B
SEQUENCE͕ύX܂񂪁A߂lƈꕔL邩܂B

  TEST      : eXgsPZq
  :start    : JnʒuBftHg0Ŕ񕉂̐
  :end      : IʒuBftHgnilŁAnil̏ꍇ͗̒w肵
              ꍇƓB
  :count    : uő̉񐔁B
  :from-end : nil Ȃΐ擪Anon-nil ŖusB :count
              ^ꂽ݈̂ӖB


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
[File       ]: builtin.l
[Section    ]: 
[Description]: 
񒆂̃p^[uĕԂ܂B

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
[File       ]: builtin.l
[Section    ]: 
[Description]: 
w肳ꂽ̕Ԃ܂B

--- mule̐ ---
̊֐́A string  start ̕n end ̕ŏIXgO
 (V)Ԃ܂B̐́A(XgO̍Ō̕ -1 Ƃ) X
gȌI肩琔܂B 

start  end ̂ǂ炩 integer łȂA start  end ̌̕
wĂAǂ炩 integer XgO͈̔͂oĂ܂Ă
ꍇAG[ɂȂ܂B 

  (substring "abcdefg" 0)
  => "abcdefg"
  (substring "abcdefg" 0 2)
  => "ab"
  (substring "abcdefg" 5 nil)
  => "fg"
  (substring "abcdefg" -1 nil)
  => "g"

݊F
  Common Lispɂ͂Ȃ(commonłsubseqƂ炵j
  muleB


subtypep
[Type       ]: Function
[Arguments  ]: subtypep TYPE1 TYPE2
[Package    ]: lisp
[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
[File       ]: builtin.l
[Section    ]: z
[Description]: 
aref ƓłA svref ̓xNg(ꎟz)݂̂ɃANZXł܂B
܂AxNg 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
[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    ]: find-buffer , get-buffer-create , verify-visited-file-modtime
[File       ]: buffer.l
[Section    ]: obt@
[Description]: 
w肳ꂽobt@ɈړAEBhEɈړ܂Bobt@݂Ȃ
΃obt@쐬܂B̃obt@𑀍쒆̃EBhEɕ\Ƃ
Ȋ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
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
[File       ]: builtin.l
[Section    ]: ϐƒ萔
[Description]: 
V{ɑꂽ֐`Ԃ܂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
[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
[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
[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
[File       ]: builtin.l
[Section    ]: V{
[Description]: 
V{ɑĂlԂ܂B

  SYMBOL : lԂV{

gpF
  ;;; fooƂV{̒lԂĂ݂B
  (set 'foo 3)          => 3
  (symbol-value 'foo)   => 3
  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
[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
[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
[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-open-tag
[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
[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
[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
[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
[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
[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 , create-tab-bar
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[File       ]: cmds.l
[Section    ]: [h
[Description]: 
㏑p}Ci[[h𐧌䂵܂B
  nilȊO  ㏑[hɂ
  nil      }[hɂ
  ȗ   [hgO


toggle-read-only
[Type       ]: Function
[Arguments  ]: toggle-read-only &optional (ARG () SV)
[Package    ]: editor
[Seealso    ]: buffer-read-only , nil
[File       ]: buffer.l
[Section    ]: obt@
[Description]: 
obt@̏݋֎~gO܂B


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
[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
[File       ]: cmds.l
[Section    ]: eLXg
[Description]: 
|CĝЂƂO̕A|Cg̈ʒu̕ƌ܂B
|Cĝ͂ЂƂOɐi݂܂B


transpose-lines
[Type       ]: Function
[Arguments  ]: transpose-lines &optional (ARG 1)
[Package    ]: editor
[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
[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
[File       ]: cmds.l
[Section    ]: 
[Description]: 
J[\ʒu̒P̒PƓꊷ܂B


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    ]: floor , ceiling , round
[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
[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


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
[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
[File       ]: builtin.l
[Section    ]: obt@
[Description]: 
Ȏ܂B
UNDO̒߂̋E܂Ŗ߂܂B


undo-boundary
[Type       ]: Function
[Arguments  ]: undo-boundary
[Package    ]: editor
[Seealso    ]: clear-undo-boundary , undo
[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
[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
[File       ]: builtin.l
[Section    ]: pbP[W
[Description]: 
pbP[WɃV{΍폜tAȂnilԂ܂B


uninterned
[Type       ]: Misc
[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
[File       ]: list.l
[Section    ]: Xg
[Description]: 
LIST1  LIST2 𕹂XgĕԂ܂B
nunion ƈႢ̃Xg͕ύX܂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
[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
[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
[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    ]: 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    ]: capitalize-region , downcase-region
[File       ]: builtin.l
[Section    ]: [W
[Description]: 
[W̒P啶ɂ܂B


upcase-word
[Type       ]: Function
[Arguments  ]: upcase-word &optional (ARG 1)
[Package    ]: editor
[Seealso    ]: upcase-region , downcase-word
[File       ]: cmds.l
[Section    ]: 
[Description]: 
J[\ʒuP̖܂ł啶ɕϊ܂B


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
[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
[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
[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    ]: find-package , defpackage
[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
[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    ]: multiple-value-bind , multiple-value-list , multiple-value-setq
[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

Description: evaluates each of its argument forms in turn, then returns 
as multiple values the first value returned by each of the forms. If the 
form that calls a values form does not expect the number of values returned, 
any excess values are discarded. values is used to return multiple values 
from a form that would otherwise return a single value. There are a number 
of Lisp forms, defined using values, that return multiple values. values 
can also be used to restrict the number of values such forms return. For 
example, the Lisp function decode-float returns three values. However, 
the form below returns only the first value returned by the decode-float 
form, since values has one argument and it returns a single value for 
each of its arguments. The advantage is increased efficiency provided 
that the second and third value are not required.

(values (decode-float floating-point-number))

The form (values) returns zero values since it has zero arguments. 
Therefore, each of the values the calling form expects to receive are nil 
by default.

݊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 ȂxNg܂B

  (setf v (vector 1 2 "oop"))
  =>#(1 2 "oop")

xNg̊evfɃANZX邽߂ɂ́Asvref(邢aref)g܂B


vector-pop
[Type       ]: Function
[Arguments  ]: vector-pop VECTOR
[Package    ]: lisp
[Seealso    ]: fill-pointer , vector-push
[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
[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-array 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-array 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
[File       ]: builtin.l
[Section    ]: z
[Description]: 
xN^ɐVvfǉ܂BȂΊg܂B

  NEW-ELEMENTFVvf 
  VECTOR     FǉxN^
  EXTENSION  Fgꍇɂǂ̒xTCY傫邩

gpF
  ;;; vfƂ钷10̃xN^쐬l߂B
  (setq *stream* (make-vector 10 :element-type 'character
                                 :fill-pointer 0 :adjustable t))
  => ""
  (vector-push-extend #\a *stream*)  => 0
  *stream*                           => "a"
  (vector-push-extend #\b *stream*)  => 1
  *stream*                           => "ab"

  ;;; vfƂ钷10̃xN^쐬l߂B
  (setq s (make-vector 10 :element-type 'character
                          :fill-pointer 0 :adjustable t))
  => ""
  (dotimes (i 20)
    (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
[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
[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
[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
[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


wild-pathname-p
[Type       ]: Function
[Arguments  ]: wild-pathname-p PATHNAME
[Package    ]: lisp
[Seealso    ]: 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
[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
[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
[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
[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-output-to-selected-buffer
    (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
[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    ]: open
[File       ]: stream.l
[Section    ]: o
[Description]: 
---  ---
Description: evaluates the forms of the body as an implicit progn. stream 
is bound to a stream that is the result of applying open
 to filename and the options. If the stream cannot be opened, stream may 
be bound to nil. The file is automatically closed if the body is exited, 
even in error.

--- Ӗ ---
progn邩̂悤BODỸtH[Ԃɕ]܂BSTREAḾAFILE
OPTIONopenKpʂ̃Xg[ɑ܂BXg[
openɎsASTREAMnilɑ܂BFILEBODY甲ꍇ
IɃN[Y܂BƂꂪG[̏ꍇłĂB

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
[File       ]: stream.l
[Section    ]: o
[Description]: 
o̓Xg[J܂B

---  ---
evaluates the form stream to return a stream with dynamic extent. The 
value of the stream is bound to var, and then the body forms are 
evaluated as an implicit progn. The value of with-open-stream is that of 
the last form evaluated. On termination, whether normal or otherwise, 
the stream is closed by close.

--- Ӗ ---
STREAM̃tH[]ēIGNXeg̃Xg[Ԃ܂BԂ
Xg[̒lVARɑ܂BāABODỸtH[͈Öقprogn
̒ŕ]܂Bwith-open-stream̒ĺAŌBODỸtH[̂̂
Ȃ܂BIۂɂ炸AIɃXg[̓N[Y܂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
[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
[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))))


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:streamȗ
*standard-output*ɏo͂܂B
iڍוsj


write-char
[Type       ]: Function
[Arguments  ]: write-char CHARACTER &optional OUTPUT-STREAM
[Package    ]: lisp
[File       ]: builtin.l
[Section    ]: o
[Description]: 
OUTPUT-STREAM  CHARACTER o͂A CHARACTER Ԃ܂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
[Section    ]: t@CVXe
[Description]: 
jǂɂ݂ȂH


xyzzy-dumped-p
[Type       ]: Function
[Arguments  ]: xyzzy-dumped-p
[Package    ]: editor
[File       ]: builtin.l
[Section    ]: VXe
[Description]: 
Nxyzzy_vς݂ǂԂ܂B

  t     _vς
  nil   _vς݂ł͂Ȃ

_vƂĂċN܂ł͖߂ltɂȂ܂B


xyzzyŒ񋟂ĂXg[̎
[Type       ]: Tips
[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


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
[File       ]: region.l
[Section    ]: [W
[Description]: 
̗vfyank܂BÕR}hyankȂ*kill-ring*̃|C^[
炵āA̗vfyank܂B


yank-rectangle
[Type       ]: Function
[Arguments  ]: yank-rectangle
[Package    ]: editor
[Seealso    ]: kill-rectangle , yank-rectangle-selection , yank-rectangle-as-region
[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ɂǂ̂悤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
[File       ]: select.l
[Section    ]: [W
[Description]: 
*selection-ring*̐擪̗vf\t܂B
*selection-ring*ւcopy-selectionkill-selectionŒǉ܂B
ftHgł'F9'ɊtĂ܂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
[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
[File       ]: cmds.l
[Section    ]: 
[Description]: 
|Cgw肳ꂽLN^܂łkill܂B


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


``'(backquote)
[Type       ]: Misc
[Arguments  ]: form
[Package    ]: ???
[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)

QlF
  --- elisp-jpp ---
  
  tp̈̒ɓʂȕW`,'ƁA̒l͒萔łȂƂ\
  킵܂Btp`,'̈]AXg\ɂ̒l܂B
  
     (list 'a 'list 'of (+ 2 3) 'elements)
          => (a list of 5 elements)
     `(a list of ,(+ 2 3) elements)
          => (a list of 5 elements)
  
  ʂȕW`,@'p邱ƂŁA]lʂ̃Xg"gݍ
  (splice)"Ƃł܂Bgݍ܂ꂽXg̗vf́Aʂ̃Xĝق
  ̗vfƓx̗vfɂȂ܂B``'gȂȃR[h́AX
  ēǂ݂ɂȂ܂B܂B
     (setq some-list '(2 3))
          => (2 3)
     (cons 1 (append some-list '(4) some-list))
          => (1 2 3 4 2 3)
     `(1 ,@some-list 4 ,@some-list)
          => (1 2 3 4 2 3)


obt@폜ꂽobt@ǂׂɂ́H
[Type       ]: Tips
[Section    ]: ̑
[Description]: 
(defun deleted-buffer-p (buffer)
    (not (ignore-errors (buffer-kanji-fileio-code buffer))))


ǂ̊֐̓ɉ̂ł傤H
[Type       ]: Tips
[Seealso    ]: pbP[W̊Tv
[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
[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
[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
[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                               
  

Ⴆ΁ARETC-m͓Iɂ͓L[ƌȂ܂B̂悤ȃL[͈ȉ
̂ƂłB

    TAB         ; #\C-i
    LFD         ; #\C-j
    RET         ; #\C-m
    ESC         ; #\C-[
    DEL         ; #\C-?
    NUL         ; #\C-@
    #\C-SPC     ; #\C-@


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
[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
[Section    ]: obt@
[Description]: 
eX̃obt@́A(vO}ڃANZX邱Ƃ̂łȂ) ϐ̏W
Ă܂B (ǂ̂悤Ȍ`ł)ɗ^ꂽOvO}p
Ƃ͂ł܂񂪁A̒lANZXύXsȂ֐΂Α݂
܂B (Emacs 18 ɂ)́A

  name 
    obt@́Aobt@𖼎wXgOłB͈ӂł邱Ƃ
    ؂Ă܂BZNV 24.1 [buffer-name]Ay[W 224 QƁB

  save-modified 
    ̕ϐ́Aobt@(Ō)Z[uꂽԂ܂Bxref??

  modtime 
    ̕ϐ́Avisit ꂽt@C modification time ܂B
    ͂̃t@C邩ǂ܂邩ɐݒ肳܂Bobt@
    t@Cɏ邽тɁA̕ϐ() t@C modification 
    r܂BZNV 22.3 [verify-visited-file-modtime]Ay[W
    204 Q

  auto-save-modified 
    ̕ϐ́Aobt@(Ō)I[gZ[uꂽԂ܂B

  last-window-start 
    ̕ϐ́A(Ō)obt@EBhEɕ\ꂽہA̕\Jn
    obt@̃|WV܂B

  undodata 
    ̕ϐ́Aobt@ɑ΂(Ō)sȂꂽ(󒍁Fset of)
    X undo 邽߂̕@A(Emacs )L^܂BZNV
    24.8 [undo]Ay[W 233 QƁB

  syntax_table_v 
    ̕ϐ́Aobt@ɑ΂V^bNXe[u܂BZNV
    37.3 [V^bNXe[u]Ay[W 354 QƁB

  markers 
    ̕ϐ́Aobt@̒w(SĂ)}[J[̃Xg܂Bob
    t@̓eύXۂ́Ã}[J[() Abvf[g
    Ă͂܂B`v^[ 28 [}[J[]Ay[W 267

  backup_up 
    ̕ϐ́A visit ꂽt@CobNAbvĂ邩ۂ
    tOłB

  mark 
    ̕ϐ́Aobt@ɑ΂}[N܂B}[N̓}[J[ł
    A}[N̓Xg markers ɂ܂܂܂B

  local_var_alist 
    ̕ϐ́A[Jϐ(̑S)ƂɑΉlƂ܂ association
    Xg܂B֐ buffer-local-variables ́ÃXg̃Rs[
    Ԃ܂B

--- ǉ ---
  mode-line-format 
    [hC̃tH[}bgłB

  title-bar-format
    ^Cgo[̃tH[}bgłB


pbP[W
[Type       ]: Tips
[Seealso    ]: pbP[W̊Tv
[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
[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
[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
[Section    ]: VXe
[Description]: 
N̏t[łB$XYZZY/xyzzy.exeNƁAŏinit.cc
   $XYZZY/lisp/startup.lĂяo܂Bȍ~̎ȃt[͈ȉ
  ̂ƂłB
  
  init.cc: 
    1. startupload-library 
       startup.l: 
        1. loadupload-library 
           loadup.l: 
            1. estartupload-library 
             iestartup.lŁAe:startup`j 
            2. historyload-library 
             ihistory.lŁAload-history-file`j 
            3. app-menuload-library 
             iapp-menu.lŁAinit-app-menus`j 
            4. siteinitload-library 
    2. _vȂ_v 
    3. e:startups 
       estartup.le: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-lineA*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
[Package    ]: lisp
[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
[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ʍ
  - ̑
  - G[
  - L[}bv
  - VXe
  - `N
  - obt@
  - pbP[W
  - EK\
  - o
  - ֐ꗗ

̑
  - C-z ŃACRɂ́H
  - DOS̃R}hLbNČʂ𕶎ɂɂ́H
  - OLEI[g[V̎gp
  - obt@폜ꂽobt@ǂׂɂ́H
  - L[[ht@C̏
  - R}hɂqXgύXɂ́H
  - t@C̗
  - ̃wb_tb^Ɋւ\L
  - e탍[h֌W̊֐̈Ⴂ
  - sԍON/OFF

G[
  - G[֌W

L[}bv
  - BS  C-h ɕʁX̋@\蓖Ăɂ́H
  - L[\gp\
  - e팾L[}bv

VXe
  - Nt[

`N
  - `N̊Tv

obt@
  - obt@̓\

pbP[W
  - ǂ̊֐̓ɉ̂ł傤H
  - pbP[W
  - pbP[W̊Tv

EK\
  - compile-regexp ƈꉞł傤H
  - Emacs ݊ł͂ȂK\͌\̂ł傤H
  - K\̕\L

o
  - xyzzyŒ񋟂ĂXg[̎

֐ꗗ
  - *
  - *activate-hook*
  - *after-save-buffer-hook*
  - *apropos-no-regexp*
  - *auto-fill-hook
  - *auto-mode-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-menu-mode-hook*
  - *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-load-path*
  - *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-file-not-found-hook*
  - *find-file-hooks*
  - *find-file-read-only-hook*
  - *gensym-counter*
  - *global-keymap*
  - *gmark-keep-column*
  - *grep-directory-name-hook*
  - *grep-hook*
  - *grepd-hook*
  - *gresreg-directory-name-hook*
  - *history-file-name*
  - *ime-mode-hook*
  - *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*
  - *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*
  - *rectangle-kill-buffer*
  - *save-buffer-no-filenames-hook*
  - *save-history*
  - *save-history-hook*
  - *save-resume-info*
  - *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
  - <
  - <=
  - =
  - >
  - >=
  - abbrev-mode
  - abbreviate-display-string
  - abs
  - acons
  - acos
  - acosh
  - 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-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-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
  - BS  C-h ɕʁX̋@\蓖Ăɂ́H
  - buffer-can-redo-p
  - buffer-can-undo-p
  - 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
  - C-z ŃACRɂ́H
  - 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-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
  - clrhash
  - code-char
  - coerce
  - command-apropos
  - command-execute
  - commandp
  - 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
  - copy-alist
  - copy-file
  - copy-keymap
  - copy-list
  - copy-menu-items
  - 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-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
  - declare
  - decode-escape-sequence
  - decode-mime-header
  - decode-universal-time
  - default-directory
  - default-value
  - defconstant
  - define-abbrev-table
  - define-command-bar
  - define-history-variable
  - define-key
  - define-menu
  - define-popup-menu
  - defmacro
  - defpackage
  - defstruct
  - 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
  - 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
  - dolist
  - DOS̃R}hLbNČʂ𕶎ɂɂ́H
  - dotimes
  - double-float-p
  - down-list
  - downcase-region
  - downcase-word
  - drive-dialog
  - dump-xyzzy
  - echo-stream-input-stream
  - echo-stream-output-stream
  - 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 ݊ł͂ȂK\͌\̂ł傤H
  - 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-shell-command
  - execute-subprocess
  - exp
  - expand-abbrev
  - export
  - expt
  - 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-writable-p
  - file-write-time
  - filer
  - filer-calc-directory-byte-size
  - filer-calc-directory-size
  - 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
  - find
  - find-buffer
  - find-file
  - find-file-in-archive
  - find-file-other-window
  - 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-paragraph
  - forward-sexp
  - forward-virtual-line
  - forward-word
  - fourth
  - fresh-line
  - fround
  - ftruncate
  - funcall
  - function
  - functionp
  - gc
  - gcd
  - gensym
  - get
  - 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-file-attributes
  - get-file-buffer
  - get-file-info
  - get-image-size
  - get-internal-real-time
  - get-menu
  - get-menu-position
  - get-properties
  - get-selection-type
  - get-short-path-name
  - get-special-folder-location
  - get-system-directory
  - get-universal-time
  - get-window-handle
  - get-window-start-line
  - get-windows-directory
  - getf
  - gethash
  - gethash-region
  - global-set-key
  - global-unset-key
  - 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
  - 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
  - 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
  - integerp
  - interactive
  - interactive-p
  - intern
  - intersection
  - isqrt
  - jump-to-register
  - just-one-space
  - kana-char-p
  - kanji-char-p
  - kept-undo-information
  - 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
  - lambda
  - lambda-parameters-limit
  - last
  - lcm
  - ldiff
  - length
  - let
  - let*
  - lisp-complete-symbol
  - list
  - list-all-packages
  - list-archive
  - list-function
  - list-length
  - list-server-resources
  - list-servers
  - list-text-attributes
  - list-tool-bars
  - listen
  - listp
  - load-file
  - load-keyword-file
  - load-library
  - local-unset-key
  - local-variable-p
  - lock-file
  - log
  - logand
  - logior
  - long-float-p
  - long-operation
  - looking-at
  - looking-back
  - looking-for
  - lookup-dictionary
  - 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-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-paragraph
  - mark-sexp
  - mark-whole-buffer
  - mark-word
  - marker-buffer
  - marker-point
  - markerp
  - 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-list
  - multiple-value-setq
  - namestring
  - narrow-to-region
  - nbutlast
  - nconc
  - need-buffer-save-p
  - need-not-save
  - negative-argument
  - 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
  - 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
  - OLEI[g[V̎gp
  - open
  - open-filer
  - open-line
  - open-network-stream
  - open-rectangle
  - open-rectangle-selection
  - 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
  - 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
  - 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
  - prin1
  - princ
  - print-buffer
  - print-dialog
  - process-buffer
  - process-eol-code
  - process-exit-code
  - process-filter
  - process-incode
  - process-outcode
  - process-send-string
  - process-sentinel
  - process-status
  - processp
  - 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-buffer-name
  - read-char
  - read-char-encoding
  - read-char-no-hang
  - read-command-name
  - read-directory-name
  - read-exact-char-encoding
  - read-exist-buffer-name
  - read-exist-file-name
  - read-file-name
  - read-file-name-list
  - read-from-string
  - read-function-name
  - read-integer
  - read-line
  - read-registry
  - read-sexp
  - read-string
  - read-symbol-name
  - read-variable-name
  - realp
  - realpart
  - recenter
  - redo
  - reduce
  - refresh-screen
  - refresh-tool-bars
  - regexp-keyword-list
  - regexp-quote
  - regexpp
  - 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-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-excursion
  - save-restriction
  - 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-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-local-window-flags
  - set-macro-character
  - set-mark
  - set-mark-command
  - set-marker
  - set-menu
  - 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-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
  - 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:*stream-line-number
  - si:base64-decode
  - si:base64-encode
  - 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-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-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-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
  - 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
  - write
  - write-char
  - 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
  - ``'(backquote)
  - obt@폜ꂽobt@ǂׂɂ́H
  - ǂ̊֐̓ɉ̂ł傤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

