@deffn 명령과 그 외의 정의 명령어로 함수, 변수, 매크로,
명령어, 옵션, 특수형태, 그리고 그 외의 artifact를 일관된 형태로 나타낼
수 있다.
Info 파일에서, 정의는 entity category---`함수', `변수', 혹은 무엇이든
간에---그 정의의 첫번째 줄에 나타나고, 그 다음에 그 entity의 이름과
인자가 온다. 인쇄된 매뉴얼의 경우, 이 명령어는 TeX이 그 entity의
이름과 그 인자를 왼쪽 공백에 출력하고, 그 category를 오른쪽 margin에
출력하도록 한다. 두개의 출력 형식 모두에서, 정의의 body는 들여쓰기
된다. 또, entity의 이름은 적당한 색인에 들어가게 된다: @deffn은
그 이름을 함수 색인에 넣고, @defvr은 변수 색인에 넣는 것 등과
같이 한다.
한개의 매뉴얼에서 한개의 주어진 이름에 대해 한개 이상의 정의가 있을
필요도 없고, 있어서도 안 된다. 요약이 들어 있는 부록은 명령어
정의보다는 @table을 사용해야 한다.
@deffn 명령은 함수와 같은 entity를 정의하는 데 쓴다.
@deffn 명령으로 정의를 하려면, @deffn 명령을 줄이 시작할
때 쓰고, 같은 줄에 그 entity의 category, 그 entity 자체의 이름, 그리고
(있다면) 그 인자를 쓴다. 그 다음에 계속되는 줄에 정의의 body를 쓴다.
(그 body에 예제를 포함시킬 수도 있다.) 끝으로, @end deffn
명령을 한줄에 단독으로 써서 정의를 끝낸다. (그 외의 정의 명령도 같은
형식으로 쓴다.)
정의의 template은 다음과 같다:
@deffn category name arguments... body-of-definition @end deffn
예를 들어,
@deffn Command forward-word count
This command moves point forward @var{count} words
(or backward if @var{count} is negative). ...
@end deffn
은 다음을 만든다.
- Command: forward-word count
- This function moves point forward count words (or backward if count is negative). ...
category의 이름을 title처럼 대문자로 시작하게 한다. `Interactive Command'처럼 category 이름에 공백이 들어가면, 그 주위에 중괄호를 쓴다. 예를 들어:
@deffn {Interactive Command} isearch-forward
...
@end deffn
그렇지 않으면 두번째 단어가 그 entity의 이름으로 잘못 받아들여질 것이다.
몇몇 정의 명령은 다른 것들보다 더 일반적이다. 예를 들어, @deffn
명령은 함수와 같은 것들---인자를 받아들이는 entity---에 쓰이는 일반적인
명령어이다. 이 명령을 쓸 때, 그 entity가 속해 있는 category를 지정한다.
@deffn 명령은 세개의 변형된 명령이 미리 정의되어 있다. 그것은
@defun, @defmac, 그리고 @defspec으로, 이
명령어들은 category를 알아서 지정해 준다: 각각 "함수", "매크로",
그리고 "Special Form"이다. (Lisp에서, special form은 함수와 매우
비슷한 entity이다.) @defvr 명령도 특정 종류의 변수를 쓰기 위해
몇개의 변형이 미리 지정되어 있다.
@defun처럼, specialized 정의에 쓰이는 template은 category를
지정할 필요가 없다는 것을 빼면 일반적인 정의에 쓰이는 template과
같다.
@defun name arguments... body-of-definition @end defun
즉,
@defun buffer-end flag
This function returns @code{(point-min)} if @var{flag}
is less than 1, @code{(point-max)} otherwise.
...
@end defun
은 다음을 만든다.
- Function: buffer-end flag
- This function returns
(point-min)if flag is less than 1,(point-max)otherwise. ...
정의 내에 @example을 사용하는 등, 함수 정의의 더 자세한 예를
보려면, See section A Sample Function Definition.
그 외의 specialized 명령은 @defun처럼 동작한다.
어떤 entity는 선택 가능하거나, 반복되는 인자를 받아들이는데, 이 인자는 square bracket과 말줄임표같은 기호로 구분해서 지정할 수 있다. 예를 들어, special form은 보통 함수보다 더 복잡한 방법으로, 그 인자 리스트를 여러개의 인자로 나눈다.
square bracket에 둘러쌓인 인자는 선택가능하다.
즉, `[optional-arg]'는
optional-arg가 선택 가능이라는 뜻이다.
뒤에 말 줄임표가 붙은 인자는 선택 가능하고, 한번 이상 반복될 수 있다.
즉, `repeated-args...'는 0개 혹은 그 이상의 인자를
뜻한다. 괄호는 Lisp에서, 인자들을 몇개의 리스트 구조로 한단계 더
인자들을 구분 지을 때 쓴다.
다음은 가상의 special form의 예로 @defspec 명령이 들어 있는
줄이다.
- Special Form: foobar (var [from to [inc]]) body...
이 예에서, 인자 from과 to는 선택 가능하지만, 두개다 있거나, 두개 다 없거나 해야 한다. 인자가 있으면, inc도 선택 가능하다. 이 인자들은 var 인자와 함께 리스트 안에 들어 있어서, 이 form의 나머지 element가 모두 들어 있는 body와 구분한다.
Texinfo 소스 파일에서, @defspec 줄은 다음과 같이 쓴다 (다음
예에서처럼, 두 줄에 걸쳐 나눠지지 않는다).
@defspec foobar (@var{var} [@var{from} @var{to}
[@var{inc}]]) @var{body}@dots{}
이 함수는 `foobar'로 `함수와 변수 색인'에 열거되어 있다.
정의에서 두개 이상의 `첫번째' 혹은 머릿줄을 쓰려면, 첫번째
@deffn 줄 다음에 @deffnx로 시작하는 줄을 쓴다.
@deffnx 명령은 앞줄과의 사이에 수직으로 공백을 넣지 않는 다는
것을 제외하면 @deffn와 완전히 똑같이 동작한다.
예를 들어,
@deffn {Interactive Command} isearch-forward
@deffnx {Interactive Command} isearch-backward
These two search commands are similar except ...
@end deffn
는 다음을 만든다.
그 외의 정의 명령도 각각 `x' 형태가 있다: @defunx,
@defvrx, @deftypefunx 등.
`x' 형태는 @itemx와 비슷하다; section @itemx.
Texinfo는 수십개의 정의 명령을 제공하고, 이 명령어를 모두 이 절에서 설명한다.
정의 명령은 자동으로 그 entity의 이름을 적당한 색인에 넣는다: 예를 들어,
@deffn, @defun, 그리고 @defmac은 함수 이름을
함수 색인에 넣는다; @defvr과 @defvar은 변수 이름을 변수
색인에 넣는다.
다음에 나올 예들은 대부분 Lisp의 예이지만, 이 명령들은 다른 프로그래밍 언어에도 사용될 수 있다.
이 절은 함수, 그리고 함수와 비슷한 entity들을 정의하는 명령어들을 설명한다:
@deffn category name arguments...
@deffn 명령은 함수, interactive commands, 그리고 그 외에 인자를
받아들이는 비슷한 entity들을 일반적으로 정의하는 명령이다.
정의하는 entity의 category를 나타내는 용어는 직접 결정해야 한다; 예를
들어, "함수"는 그 entity가 함수일때 쓸 수 있을 것이다. @deffn
명령은 줄이 시작할 때 쓰고, 같은 줄에 계속 entity의 catogory, 이
entity의 이름, 그리고 인수가 있다면 그 인수를 쓴다. 이 정의는
@end deffn 명령을 한줄에 단독으로 써서 끝낸다.
예를 들어, 다음에 정의가 있다.
@deffn Command forward-char nchars
Move point forward @var{nchars} characters.
@end deffn
이 예는 nchars라는 한개의 인자를 가진 forward-char라는
이름의 "명령어"를 간단히 정의했다.
@deffn은 nchars와 같은 인자의 이름을 @var가 사용된
경우와 같이 이탤릭체 혹은 대문자로 표시한다. 왜냐하면, 우리는 이 이름을
metasyntactic 변수로 생각하기 때문이다---이 인자들은 실제 인자의 값을
나타낸다. 여기 설명하는 텍스트 내에서, 이 인자의 값을 참조하려면
@var를 분명히 써서 인자 이름을 쓴다. 위의 예에서, 이런 방법으로
`@var{nchars}'를 썼다.
@deffn의 template은:
@deffn category name arguments... body-of-definition @end deffn
@defun name arguments...
@defun 명령은 함수를 정의하는 명령어이다. @defun은
`@deffn Function ...'와 같다.
예를 들어,
@defun set symbol new-value
Change the value of the symbol @var{symbol}
to @var{new-value}.
@end defun
은 인자가 symbol과 new-value인 함수 set을 간단히
설명한다. @defun 줄의 인자 이름은 마치 @var 안에 쓴
것처럼 자동으로 이탤릭체 혹은 대문자로 쓰여진다. 이 정의는 한줄에
단독으로 @end defun을 써서 끝낸다.
template은:
@defun function-name arguments... body-of-definition @end defun
@defun은 함수 색인에 항목을 만든다.
@defmac name arguments...
@defmac 명령은 매크로를 정의하는 명령어이다. @defmac은
`deffn Macro ...'와 동일하고, @defun과 비슷하게
동작한다.
@defspec name arguments...
@defspec 명령은 special form에 대한 정의 명령어이다. (Lisp에서,
special form은 function과 매우 비슷한 entity이다. see section `Special Forms' in GNU Emacs Lisp Reference Manual.) @defspec은
`@deffn {Special Form} ...'와 동일하고, @defun과
비슷하게 동작한다.
다음은 변수와 변수와 비슷한 entity를 정의하는 명령이다:
@defvr category name
@defvr 명령은 변수와 비슷한 무언가---어떤 값을 저장하고 있는
entity---를 일반적으로 정의하는 명령어이다. 정의될 entity의 category를
설명하는 용어를 지정해야 한다; 예를 들어, "Variable"은 그 entity가
변수일 때 쓸 수 있다. @defvr 명령을 줄이 시작할 때쓰고, 같은
줄에 그 entity의 category와 그 entity의 이름을 쓴다.
category 이름을 title처럼 대문자로 시작하게 한다. category 이름이
"User Option"처럼 공백문자를 포함하면, 중괄호로 둘러싼다. 그렇지
않으면 두번째 단어가 entity의 이름으로 잘못 들어갈 것이다. 예를 들어,
@defvr {User Option} fill-column
This buffer-local variable specifies
the maximum width of filled lines.
...
@end defvr
이 정의는 @end defvr을 한 줄에 단독으로 써서 끝낸다.
template은:
@defvr category name body-of-definition @end defvr
@defvr은 name에 대한 항목을 변수 색인에 만든다.
@defvar name
@defvar 명령어는 변수를 정의하는 명령어이다. @defvar은
`@defvr Variable ...'와 동일하다.
예를 들어:
@defvar kill-ring ... @end defvar기본 틀은:
@defvar name body-of-definition @end defvar
@defvar은 name에 대한 항목을 변수 색인에 만든다.
@defopt name
@defopt 명령은 user options에 대해 정의하는 명령어이다.
user option은 사용자가 원하는 대로 바꿀 수 있는 변수이다; Emacs에는
그러한 것이 많다 (see section `Variables' in The GNU Emacs Manual). @defopt는 `@defvr {User
Option} ...'와 같고, @defvar와 같이 동작한다.
@deftypefn 명령과 그의 변형은 C와 C++처럼 변수와 함수의 타입을
선언해야 하는 언어에서 함수를 설명하는 데 쓰인다.
@deftypefn category data-type name arguments...
@deftypefn 명령은 인자를 받아들이고, 타입이 있는 함수 및 그와
비슷한 entity를 정의하는 일반적인 명령어이다. @deftypefn 명령은
줄이 시작할 때 쓰고, 같은 줄에 설명할 entity의 category를 쓰고, return
값의 타입, 이 entity의 이름, 그리고 인자가 있다면 그 인자들을 쓴다.
예를 들어,
@deftypefn {Library Function} int foobar
(int @var{foo}, float @var{bar})
...
@end deftypefn
("..." 앞의 텍스트에서, 위에서는 두줄로 나타났지만, 실제로는 Texinfo
파일에서는 한 줄이다) 이것은 Info에서 다음을 만든다:
-- Library Function: int foobar (int FOO, float BAR) ...인쇄된 매뉴얼에서, 다음을 만든다:
이 의미는
- Library Function: int foobar (int foo, float bar)
- ...
foobar가 int를 리턴하고, 그 인자가
foo(int 타입)과 bar(float 타입)인 "라이브러리
함수"라는 뜻이다.
@deftypefn 안에 쓰는 인자의 이름은 @var가 자동으로 붙지
않는다---왜냐하면 @deftypefn 내의 실제 인자의 이름은 대부분
데이타 타입의 이름과, 키워드로 구분되기 때문이다. Texinfo는 자동으로
이걸 찾아내지 못한다. 그 대신에 인자의 이름 주위에 직접 @var를
써야 한다. 위의 예에서, 인자의 이름은 `foo'와 `bar'이다.
@deftypefn의 template은 다음과 같다:
@deftypefn category data-type name arguments ... body-of-description @end deftypefn만약 category나 data type이 한 단어보다 많을때 한개의 인자로 만들려면 중괄호로 묶어야 한다. Ada와 같은 package가 있는 언어 내의 프로시저를 설명하려 할때,
deftypefn을 앞의 문단에서 설명한 원칙과는 좀 다른 모양으로 써도
된다.
예를 들어:
@deftypefn stacks private push
(@var{s}:in out stack;
@var{n}:in integer)
...
@end deftypefn
(@deftypefn의 인자는 세 줄에 나눠져서 보이지만, 실제 Texinfo
파일에서는 한 줄이어야 한다.)
이 예에서, 프로시저는 프로시저로 구분되지 않고 stacks라는
패키지에 속한 것으로 분류되었고, 그 데이타 타입은 private이다.
(프로시저의 이름은 push이고, 그 인자는 s와 n이다.)
@deftypefn은 name에 대한 항목을 함수 색인 안에 만든다.
@deftypefun data-type name arguments...
@deftypefun 명령은 타입이 있는 언어 내의 함수에 쓰이도록 특화된
정의 명령이다. 이 명령은 `@deftypefn Function ...'와
동일하다.
즉,
@deftypefun int foobar (int @var{foo}, float @var{bar})
...
@end deftypefun
은 Info에서 다음과 같이 만든다:
-- Function: int foobar (int FOO, float BAR) ...그리고 다음은 인쇄된 매뉴얼이다:
그 template은:
- Function: int foobar (int foo, float bar)
- ...
@deftypefun type name arguments... body-of-description @end deftypefun
@deftypefun은 name에 대한 항목을 함수 색인에 넣는다.
@deftypemethod class data-type method-name arguments...
@deftypemethod 명령은 C++이나 Java와 같은 object-oriented typed
language 내의 method에 대한 정의 명령이다. 이 명령은
@deftypefn에 이 method를 포함하는 클래스를 정의하는 class
인자를 덧붙인 것과 비슷하다.
명령은 타입이 있는 언어 변수는 타입이 있는 함수와 비슷하게 처리된다.
See section Functions in Typed Languages. 일반적인 정의 명령인 @deftypevr은
@deftypefn과 대응되고, 특화된 정의 명령인 @deftypevar은
@deftypefun과 대응된다.
@deftypevr category data-type name
@deftypevr 명령은 타입이 있는 언어 내의 변수와 같은 것(어떤 값을
기록하는 entity)을 정의하는 명령이다. 정의할 entity의 category를
설명하는 말을 직접 결정해야 한다; 예를 들어, 그 entity가 변수일 때
"변수"가 사용될 수 있다.
@deftypevr 명령은 줄이 시작할 때 쓰고, 같은 줄에 설명할 entity의
category를 쓰고, 데이타 타입, 그리고 이 entity의 이름을 쓴다.
예를 들어:
@deftypevr {Global Flag} int enable
...
@end deftypevr
은 Info에서 다음을 만든다:
-- Global Flag: int enable ...그리고 다음은 인쇄된 매뉴얼에서이다:
template은:
- Global Flag: int enable
- ...
@deftypevr category data-type name body-of-description @end deftypevr
@deftypevr은 name에 대한 항목을 변수 색인에 넣는다.
@deftypevar data-type name
@deftypevar 명령은 타입이 있는 언어에서 변수를 선언하는 데 쓰는
특화된 정의 명령이다. @deftypevar은 `@deftypevr Variable
...'와 같다.
예를 들어:
@deftypevar int fubar ... @end deftypevar은 Info에서 다음을 만든다:
-- Variable: int fubar ...그리고 다음은 인쇄된 매뉴얼이다:
template은 다음과 같다:
- Variable: int fubar
- ...
@deftypevar data-type name body-of-description @end deftypevar
@deftypevar은 name에 대한 항목을 변수 색인에 넣는다.
다음은 object-oriented programming에 사용되는 abstract object 설명을 포맷팅하는 명령이다. 클래스는 abstract object를 정의하는 타입이다. 클래스의 instance는 그 클래스의 타입을 가진 특정한 object이다. instance variable은 이 클래스에 속하는 변수이면서 각각의 instance는 각각의 값을 가진다.
정의 내에서 클래스의 이름이 어떤 프로그래밍 시스템 내에서 어떤 클래스를
정의하는 이름이라면, 그 주위에 @code를 써야 한다. 그렇지 않으면
클래스 이름은 보통 텍스트 폰트로 인쇄된다.
@defcv category class name
@defcv 명령은 object-oriented programming에서 클래스에 속한
변수를 정의하는 일반적인 정의 명려이다. @defcv 명령 다음에는
세개의 인자가 온다; 정의할 변수의 category, 속해 있는 클래스, 그리고 그
이름이다. 즉,
@defcv {Class Option} Window border-pattern
...
@end defcv
위의 예는 Window 클래스의 border-pattern 클래스
옵션을 정의할 때 그 첫번째 줄을 어떻게 쓸지 보여준다.
template은
@defcv category class name ... @end defcv
@defcv는 변수 색인에 항목을 만든다.
@defivar class name
@defivar 명령은 object-oriented programming 내의 instance
변수를 정의하는 명령이다. @defivar는 `@defcv {Instance
Variable} ...'와 동일하다.
template은:
@defivar class instance-variable-name body-of-definition @end defivar
@defivar는 변수 색인에 항목을 하나 만든다.
@defop category class name arguments...
@defop 명령은 object-oriented programming에서 method와 같은
entity를 정의하는 데 쓰는 일반적인 명령이다. 이 entity는 함수와 같이
인자를 받지만, 이 enity는 특정 클래스와 연관되어 있다.
예를 들어, wrapper라고 부르는 시스템이 있다. 이 시스템은 method와
마찬가지로 클래스와 연관되어 있지만, 함수라기 보다는 매크로처름
동작한다. wrapper를 정의할 때 @defop Wrapper라고 쓸 수 있다.
어떤 경우에는 method와 operation을 구분하는 것이 좋다. 어떤
operation은 어떤 method에 대한 specification이라고 생각할 수 있다. 즉,
어떤 윈도우 시스템은 모든 윈도우 클래스에 expose라는 이름의
method를 만들 수 있다; 우리는 일반적으로 이 윈도우 시스템이 expose
operation을 정의 했다고 말할 수 있다. 보통, operation은 이름을 갖고
있고, 인자의 패턴을 지정하기도 한다; 이 operation을 implement하는 모든
method는 같은 인자를 받는다, 왜냐하면 이 operation을 사용하는
application은 어떤 method가 이 operation을 implement할 지 알지 않고도 이
operation을 사용할 수 있기 때문이다.
보통 method보다는 operation을 문서화 하는 것이 더 알기 쉽다. 예를 들어,
윈도우 application 개발자는 expose operation에 대해서 알아야
하지만, 주어진 윈도우의 클래스가 이 operation을 implement하는 method를
갖고 있는지 신경쓸 필요가 없다. 이 operation을 정의하려면, 다음과 같이
쓸 것이다:
@defop Operation windows expose
@defop 명령은 줄이 시작할 때 쓰고, 같은 줄에 operation의
category 이름, 이 operation의 클래스 이름, 이 operation의 이름, 그리고
그 인자가 있다면 인자들을 쓴다.
template은:
@defop category class name arguments... body-of-definition @end defop
@defop creates an entry, such as `expose on
windows', in the index of functions.
@defmethod class name arguments...
@defmethodd 명령은 object-oriented programming에서 method를
정의하는 명령이다. method는 일종의 함수로 특정한 object의 클래스와 그
서브클래스에 대한 operation을 implement한다. Lisp machine에서, method는
실제로 함수이지만, 보통 defmethod로 정의된다.
@defmethod는 `@defop Method ...'와 같다. 이 명령은
줄이 시작할 때 쓰고, 그 다음에 그 method의 클래스의 이름, 그 method의
이름, 그리고 인자가 있다면 인자들를 쓴다.
예를 들어,
@defmethod bar-class bar-method argument
...
@end defmethod
위의 예는 bar-class 클래스의 bar-method라는 method를
정의한다. 이 method는 한개의 인자를 받는다.
template은:
@defmethod class method-name arguments... body-of-definition @end defmethod
@defmethod는 `bar-method on bar-class와 같은
항목을 함수 색인에 만든다.
@deftypemethod class data-type name arguments...
@deftypemethod 명령은 C++이나 Java와 같은 object-oriented typed
language에서 method를 정의하는 명령어이다. 이것은 @defmethod
명령에 data-type의 인자를 더해서 그 method의 return type을
지정한다.
다음은 data type에 대한 명령어이다:
@deftp category name attributes...
@deftp 명령은 data type을 정의하는 일반적인 명령어이다. 이
명령은 줄이 시작할 때 쓰고, 같은 줄에 category, 타입의 이름(int나
float와 같은 단어), 그리고 그 타입의 object의 attribute 이름들을
쓴다. 즉, int나 float를 기술하기 위해 이 명령을 사용할
수도 있고, 이 경우에 data type을 category로 사용한다. (data
type은 어떤 object들의 category이고, 이 category는 이 object들에 대해
어떤 operation이 가능한지 결정하는 데 쓰인다.)
예를 들어, Lisp에서 pair는 특정 data type의 이름이고, 이 type의
object는 CAR와 CDR이라는 두개의 slot이 있다. 다음은 어떻게
pair를 기술하는 첫번째 줄의 예이다.
@deftp {Data type} pair car cdr
...
@end deftp
template은 다음과 같다:
@deftp category name-of-type attributes... body-of-definition @end deftp
@deftp는 data type 색인에 항목을 추가한다.
@deffn, @defun, 또는 그 외의 정의 명령을 사용해서 정의를
쓸 때, 이 인자는 그 정의의 의미를 나타내는데, forward-word 기능에
count를 사용해서 주의해서 쓰기 바란다. 또, 어떤 인자가
integer와 같은 타입의 이름인 경우, 실제 그 인자가 그 type인지
주의하라.
어떤 함수의 정의가 @defun과 @end defun 명령을 사용한다.
이 함수의 이름은 @defun 명령 다음에 오고, 같은 줄에 계속해서
인수의 리스트가 온다.
다음은 see section `Calling Functions' in The GNU Emacs Lisp Reference Manual에서 인용한 정의이다.
- Function: apply function &rest arguments
applycalls function with arguments, just likefuncallbut with one difference: the last of arguments is a list of arguments to give to function, rather than a single argument. We also say that this list is appended to the other arguments.
applyreturns the result of calling function. As withfuncall, function must either be a Lisp function or a primitive function; special forms and macros do not make sense inapply.(setq f 'list) => list (apply f 'x 'y 'z) error--> Wrong type argument: listp, z (apply '+ 1 2 '(3 4)) => 10 (apply '+ '(1 2 3 4)) => 10 (apply 'append '((a b c) nil (x y z) nil)) => (a b c x y z)An interesting example of using
applyis found in the description ofmapcar.
Texinfo 소스 파일에서, 이 예는 다음과 같이 보인다.
@defun apply function &rest arguments
@code{apply} calls @var{function} with
@var{arguments}, just like @code{funcall} but with one
difference: the last of @var{arguments} is a list of
arguments to give to @var{function}, rather than a single
argument. We also say that this list is @dfn{appended}
to the other arguments.
@code{apply} returns the result of calling
@var{function}. As with @code{funcall},
@var{function} must either be a Lisp function or a
primitive function; special forms and macros do not make
sense in @code{apply}.
@example
(setq f 'list)
@result{} list
(apply f 'x 'y 'z)
@error{} Wrong type argument: listp, z
(apply '+ 1 2 '(3 4))
@result{} 10
(apply '+ '(1 2 3 4))
@result{} 10
(apply 'append '((a b c) nil (x y z) nil))
@result{} (a b c x y z)
@end example
An interesting example of using @code{apply} is found
in the description of @code{mapcar}.@refill
@end defun
이 매뉴얼에서, 이 함수는 apply 라는 이름으로 명령어와 변수 색인에
들어 있다.
일반적인 변수와 user option은 함수와 같은 형식을 사용해서 기술된다. 단 변수는 인자를 받지 않는다.
Go to the first, previous, next, last section, table of contents.