[vim-ko commit] r20 - in 7.0: . doc

[codesite...@google.com]

Author: bwhite99
Date: Sun May 4 20:17:12 2008
New Revision: 20

Added:
7.0/doc/usr_24.kox
7.0/doc/usr_25.kox
7.0/doc/usr_26.kox
7.0/doc/usr_27.kox
7.0/doc/usr_28.kox
7.0/doc/usr_29.kox
Modified:
7.0/MEMO
7.0/Makefile
7.0/doc/usr_12.kox
7.0/doc/usr_22.kox
7.0/doc/usr_toc.kox

Log:
usr_24~usr_29 추가 및 memo 수정사항 반영



Modified: 7.0/MEMO
==============================================================================
--- 7.0/MEMO (original)
+++ 7.0/MEMO Sun May 4 20:17:12 2008
@@ -22,6 +22,9 @@
normal mode 보통? 일반? mode
visual mode 가시? 시각? mode
insert mode 입력? 삽입? mode
+command line mode 명령줄 상태
+Ex mode Ex 상태
+
replace 수정? 바꾸기?
option 설정? 설정사항? 선택사항? 기호? 옵션?
chapter 장
@@ -36,9 +39,10 @@

foo? bars? 아무개? 갑? 을? 하나? 두울?

-fold 폴드? 접음?
-closed fold 접힌 fold
-opened fold 펼쳐진 fold
+fold 폴드
+closed fold 닫힌 폴드
+opened fold 열린 폴드
+marker (in foldmethod) 표식
column 열
scroll binding 스크롤 연계? 스크롤 묶음?
default 기본값?
@@ -46,6 +50,7 @@
modifier command 수식 명령어? 꾸밈 명령어?
label 이름표? 라벨?
buffer 버퍼?
+. 마침표



@@ -79,6 +84,16 @@
alternate buffer 교대 버퍼
binary file 이진 파일
swap file 임시 파일
+keymap 키맵
+operator 오퍼레이터? 연산자? 명령? 변환기?
+text object 문자열 객체? 텍스트 객체?
+horizontal scroll bar 수평 스크롤 바
+blockwise Visual mode 블록 가시 상태? 구역 가시 상태?
+
+character class 문자 종류? 문자 집합?
+identifier 이름? 식별자?
+
+quickfix 빠른수정? 빨리고침?


Vim 그대로? 빔?

Modified: 7.0/Makefile
==============================================================================
--- 7.0/Makefile (original)
+++ 7.0/Makefile Sun May 4 20:17:12 2008
@@ -78,6 +78,7 @@
+'wq'; \
}; \
runvim $@ \
+ +'set fenc=utf-8' \
+'norm gg noFor Vim version 7.0. 0"ny$$uoVim version 7.0 대상. 0"my$$u c@r@t@r@t' \
+'norm gg noLast change: 0"ny$$uo새로고침: 0"my$$u c@r@t@r@t' \
+'norm gg no^Copyright: see |manual-copyright| 0"ny$$uo저작권: |manual-copyright| 참고 0"my$$u c@r' \

Modified: 7.0/doc/usr_12.kox
==============================================================================
--- 7.0/doc/usr_12.kox (original)
+++ 7.0/doc/usr_12.kox Sun May 4 20:17:12 2008
@@ -6,8 +6,8 @@
멋진 기술들


-몇 가지 명령을 조합하여 빔에서는 수많은 일들을 할 수 있습니다. 이 장에서는 몇
-가지 유용한 조합들을 살펴보겠습니다. 몇 가지 새로운 명령어가 등장합니다만,
+빔에서는 몇 가지 명령만을 조합하여 수많은 일들을 할 수 있습니다. 이 장에서는
+그 중 몇 가지 유용한 조합들을 살펴보겠습니다. 새로운 명령어도 등장합니다만,
대부분은 앞의 장들에서 살펴본 명령어들을 사용할 것입니다.

|12.1| 단어 바꾸기
@@ -30,9 +30,9 @@

:%s/four/4/g

-"%"는 파일의 모든 줄에서 바꾸기를 하라는 범위를 나타냅니다. 마지막 "g"는 한
-줄에 있는 모든 단어를 바꾸도록 지시합니다.
- 하지만 위와 같이 하는 경우 만약 파일에 "thirtyfour"같은 부분이 있다면, 이게
+범위를 나타내는 "%"는 파일의 모든 줄에서 바꾸기를 하라는 의미입니다. 마지막
+"g"는 한 줄에 있는 모든 단어를 바꾸도록 지시합니다.
+ 하지만 위와 같이 하는 경우 만약 파일에 "thirtyfour"같은 부분이 있다면,
"thirty4"로 의도치 않게 바뀌어버립니다. 이렇게 잘못 바뀌는 것을 막기 위해서는
단어의 앞에 "\<"를 써주면 됩니다: >

@@ -44,23 +44,23 @@
:%s/\<four\>/4/g

프로그래밍을 하는 중에, 주석 안에 있는 "four"는 바꾸면서 코드 내용에 들어있는
-"four"는 바꾸지 않고 싶다고 해봅시다. 이런 조건을 지정하기는 어렵기 때문에,
-"c" 를 마지막에 추가하여 치환이 일어날 때마다 물어보도록 하면 됩니다: >
-
+"four"는 바꾸지 않고 싶다고 가정해봅시다. 이런 조건을 지정하기는 어렵기
+때문에, "c" 를 마지막에 추가하여 치환이 일어날 때마다 사용자에게 물어보도록
+하면 됩니다: >

:%s/\<four\>/4/gc


여러 파일에서 치환하기

-여러 파일에서 단어 하나를 바꾸고 싶다고 합시다. 각 파일을 일일이 열어서 직접
+여러 파일에서 단어 하나를 바꾸고 싶다고 합시다. 각 파일을 일일이 열어서 직접
바꾸어주어도 되겠지만, 명령어 기록과 재생을 이용하면 훨씬 빠르게 할 수
있습니다.
".cpp"로 끝나는 C++ 파일들이 있는 디렉토리가 있다고 합시다. "GetResp"라는
함수를 "GetAnswer"로 바꾸고 싶다면 다음과 같이 하면 됩니다.

vim *.cpp 모든 C++ 파일을 인자로 하여 빔을 실행시킵니다.
- 첫 번째 파일이 열려있을 것입니다.
+ 일단 첫 번째 파일이 열릴 것입니다.
qq q 레지스터에 기록을 시작합니다.
:%s/\<GetResp\>/GetAnswer/g
첫 번째 파일에서 바꾸기를 합니다.
@@ -73,25 +73,28 @@
명령을 수행합니다.

마지막 파일에서는 ":wnext"로 다음 파일로 이동할 수 없기 때문에 에러가 발생할
-것입니다. 그러면 명령 수행이 끝나고 모든 내용이 바뀌었을 것입니다.
+것입니다. 그러면 명령 수행이 끝납니다. 여러파일에 들어있는 모든 내용이
+바뀌었을 것입니다.

유의사항:
- 기록된 명령어가 수행돌 때, 에러가 발생하면 수행이 멈추게 됩니다.
+ 기록된 명령어가 수행될 때, 에러가 발생하면 수행이 멈추게 됩니다.
따라서 명령어를 기록할 때는 에러가 발생하지 않도록 주의해야합니다.

한 가지 빠뜨린 것이 있습니다: 만약 .cpp 파일 중에 "GetResp"가 한 번도 나오지
-않는 파일이 있다면, 에러가 발생하면서 기록된 명령의 재생이 멈추게 됩니다. 이를
-막기 위해서는 치환 명령의 마지막에 "e"를 붙여 주면 됩니다: >
+않는 파일이 있다면, 치환 명령 수행 중에 에러가 발생하면서 기록된 명령의 재생이
+멈추게 됩니다. 이를 막기 위해서는 치환 명령의 마지막에 "e"를 붙여 주면
+됩니다: >

:%s/\<GetResp\>/GetAnswer/ge

"e"는 ":s"(치환) 명령어가 일치하는 문자열을 찾지 못하더라도 에러를 발생시키지
-않도록 지정합니다.
+않도록 지시합니다.

==============================================================================
*12.2* "성, 이름"을 "이름 성"으로 바꾸기

-다음과 같은 영어 이름 목록이 있다고 합시다:
+다음과 같은 영어 이름 목록이 있다고 합시다 (역주:영어 이름은 '성, 이름' 혹은
+'이름 성'의 형태로 표현 됩니다.):

Doe, John ~
Smith, Peter ~
@@ -105,16 +108,14 @@

:%s/\([^,]*\), \(.*\)/\2 \1/

-차근차근 살펴보도록 합시다. 물론 여기에는 치환 명령이 사용되었습니다. "%"는
+차근차근 살펴보도록 합시다. 물론 치환(":s") 명령이 사용되었습니다. "%"는
치환의 적용 범위를 나타내는데, 파일 전체를 의미합니다. 따라서 이 치환은 파일의
모든 줄에 적용 됩니다.
치환 명령에 사용되는 인자는 "/예전/새로운/" 형태입니다. "예전" 패턴과
-"바뀐" 문자열은 '/'(슬래시)로 구분됩니다. "예전" 패턴의 내용을 살펴봅시다:
+"새로운" 문자열은 '/'(슬래시)로 구분됩니다. "예전" 패턴의 내용을 살펴봅시다:
\([^,]*\), \(.*\) ~

- 첫 번째 \( \) 안의 내용은 '성'부분(역주:영어
- 이름은 '성, 이름' 혹은 '이름 성'의 형태로 표현
- 됩니다.)에 대응됨 \( \)
+ 첫 번째 \( \) 안의 내용은 '성'부분에 대응됨 \( \)
콤마가 아닌 모든 것에 대응됨 [^,]
몇 개든 상관없음 *
", "라는 문자열 자체에 대응됨 ,
@@ -124,17 +125,17 @@

"새로운" 문자열 부분에는 "\2", "\1"이 있습니다. 이런 것을
후방참조(backreference)라고 합니다. 후방참조는 패턴의 "\( \)"부분에
-대응된 것을 가리킵니다. "\2"는 두 번째 "\( \)"에 대응되는 문자열을 가리키는데
-이는 위 예에서 '이름' 부분입니다. "\1"은 첫 번째 "\( \)"부분, 즉 '성'부분을
+대응된 것을 가리킵니다. "\2"는 두 번째 "\( \)"에 대응된 문자열을 가리키는데,
+위 예에서는 '이름' 부분입니다. "\1"은 첫 번째 "\( \)"부분, 즉 '성'부분을
나타냅니다.
"새로운" 문자열 부분에는 후방참조가 9개까지 사용될 수 있습니다. "\0"은
특별히 패턴 전체에 대응된 내용을 가리킵니다. 치환 명령에는 몇 가지 특수 기능이
-더 있는데, 이는 |sub-replace-special| 에서 확인하십시오.
+더 있습니다. |sub-replace-special| 에서 살펴보시기 바랍니다.

==============================================================================
*12.3* 목록 정렬하기

-Makefile에는 다음과 같이 파일의 목록이 자주 쓰입니다:
+Makefile에는 다음과 같은 파일의 목록이 자주 쓰입니다:

OBJS = \ ~
version.o \ ~
@@ -146,7 +147,7 @@
patch.o \ ~
backup.o ~

-이 목록을 정렬하기 위해서는 외부 명령어인 'sort'를 사용하면 됩니다: >
+이 목록을 정렬하기 위해서는 외부 명령어인 "sort"를 사용하면 됩니다: >

/^OBJS
j
@@ -171,10 +172,10 @@

Makefile에서 각 줄의 맨 마지막에 있는 백슬래시는 다음 줄로 계속된다는 것을
의미합니다. 그런데, 정렬을 했더니 엉켜버리고 말았습니다. "backup.o"가 있는
-줄은 백슬래시로 끝나지 않습니다. 이 줄에도 백슬래시를 추가해야합니다.
+줄이 백슬래시로 끝나지 않으므로, 이 줄에도 백슬래시를 추가해야합니다.
가장 간단한 방법은 "A \<Esc>"로 백슬래시를 추가해주는 것입니다. 맨 마지막
줄에 있는 백슬래시는 그 다음에 빈 줄이 있기만 하면 되므로 그냥 놔두면 됩니다.
-나중에 새로운 내용이 추가되거나 순서를 바꾸더라도 문제가 없도록 말입니다.
+나중에 새로운 내용이 추가되거나 또 순서를 바꾸더라도 문제가 없도록 말입니다.

==============================================================================
*12.4* 줄의 순서 바꾸기
@@ -189,14 +190,14 @@

:g/^/m 0

-입니다. "^" 정규 표현식은 줄의 시작에 대응됩니다 (줄이 빈 줄이더라도). |:move|
-명령어는 대응되는 줄을 실제로는 존재하지 않는 0번째 줄의 다음으로 옮기게 되고,
-결과적으로 현재 대응되는 줄이 파일의 첫 번째 줄이 됩니다. |:global| 명령은
-줄이 바뀌기 전의 순서대로 처리를 하므로, |:global|은 차례대로 다음 줄을 처리하고
-계속해서 파일의 맨 첫 줄로 옮기게 됩니다.
+입니다. "^" 정규 표현식은 줄의 시작에 대응됩니다 (줄이 빈 줄이더라도).
+|:move| 명령어는 대응된 줄을 실제로는 존재하지 않는 0번째 줄의 다음으로 옮기게
+되고, 결과적으로 현재 대응된 줄이 파일의 첫 번째 줄이 됩니다. |:global|
+명령은 줄이 바뀌기 전의 순서대로 처리를 하므로, |:global|은 차례대로 다음 줄을
+처리하고, 계속해서 대응되는 줄을 파일의 맨 첫 줄로 옮기게 됩니다.

-이 명령을 일정 범위에 대해서도 쓸 수 있습니다. 먼저 첫번째 줄의 위로 커서를
-옮기고 "mt"로 마크를 만듭니다. 커서를 범위의 마지막 줄로 옮긴 후, 다음
+이 명령을 특정 범위에 대해서만 쓸 수도 있습니다. 먼저 범위의 첫번째 줄 위로
+커서를 옮기고 "mt"로 마크를 만듭니다. 커서를 범위의 마지막 줄로 옮긴 후, 다음
명령어를 입력합니다: >

:'t+1,.g/^/m 't
@@ -210,36 +211,37 @@

g CTRL-G

-g를 입력한 후, 스페이스바를 누르지 마십시오. 공백은 읽기 쉽도록 넣은 것입니다.
+g를 입력한 후, 스페이스바를 누르지 마십시오. 공백은 읽기 쉬우라고 넣은
+것입니다.
다음과 같이 결과가 표시됩니다:

Col 1 of 0; Line 141 of 157; Word 748 of 774; Byte 4489 of 4976 ~

-몇 번째 단어(748)를 보고 있는 지, 총 단어의 수(774)는 얼마인 지 알 수 있습니다.
+몇 번째 단어(748)를 보고 있는 지, 총 단어 수(774)는 얼마인 지 알 수 있습니다.

-파일 중 일부분만 단어 수를 세고 싶다고 합시다. 세고 싶은 부분의 시작부분으로
-가서 "g CTRL-G"를 누르고, 끝부분으로 가서 "g CTRL-G"를 누른 후, 보고있는 단어의
-위치를 암산으로 빼면 단어 수를 계산할 수 있습니다. 하지만 더 쉬운 방법도
-있습니다. 가시상태에서 세고 싶은 부분을 선택한 후, g CTRL-G 를 누르면 다음과
-같이 결과가 표시됩니다:
+파일 중 일부분만 단어 수를 세고 싶다고 합시다. 세고 싶은 부분의 처음으로 가서
+"g CTRL-G"를 누르고, 끝으로 가서 "g CTRL-G"를 누른 후, 보고있는 단어의 위치를
+암산으로 빼면 단어 수를 계산할 수 있습니다. 하지만 더 쉬운 방법도 있습니다.
+가시상태에서 세고 싶은 부분을 선택한 후, g CTRL-G 를 누르면 다음과 같이 결과가
+표시됩니다:

Selected 5 of 293 Lines; 70 of 1884 Words; 359 of 10928 Bytes ~

-이 밖에 단어나 줄 등을 세는 방법들은 |count-items|를 참고하십시오.
+이 밖의 단어나 줄 등을 세는 방법들은 |count-items|를 참고하십시오.

==============================================================================
*12.6* 매뉴얼 페이지 찾기

-쉘 스크립트나 C 프로그램을 작성ㅎ다보면, 명령어나 함수의 매뉴얼 페이지를 찾고
-싶을 때가 있습니다(유닉스환경만 해당됩니다). 간단한 방법은 다음과 같습니다:
+쉘 스크립트나 C 프로그램을 작성하다보면, 명령어나 함수의 매뉴얼 페이지를 찾고
+싶을 때가 있습니다(유닉스환경에만 해당됩니다). 간단한 방법은 다음과 같습니다:
커서를 도움말을 찾고 싶은 단어 위로 옮긴 후, 다음 버튼을 누릅니다 >

K

빔은 외부 명령어 "man"을 그 단어에 대해 실행시킬 것입니다. 만약 매뉴얼
페이지가 있다면 화면에 표시됩니다. 일반적인 페이저(pager, 결과를 화면에 한
-페이지씩 보여주는 프로그램으로 "more"같은 프로그램이 해당된다)가 사용되며,
-끝까지 보여진 뒤 <Enter>를 누르면 빔으로 다시 돌아올 것입니다.
+페이지씩 보여주는 프로그램으로 "more"같은 프로그램이 해당됩니다)가 사용되며,
+끝까지 본 뒤 <Enter>를 누르면 빔으로 다시 돌아올 것입니다.

하지만 이렇게 되면 매뉴얼 페이지와 작업중인 파일을 동시에 볼 수 없습니다.
빔 창에서 매뉴얼 페이지를 함께 볼 수 있는 방법이 있습니다. 먼저 매뉴얼
@@ -254,14 +256,14 @@

매뉴얼 페이지는 강조가 되어있으며, 이리저리 스크롤도 가능합니다. 이로써
도움말을 볼 수 있고, CTRL-W w를 눌러서 작업중이던 창으로 전환할 수도 있습니다.
- 특정한 섹션에서 매뉴얼 페이지를 찾고 싶다면, 섹션 번호를 먼저 넣으면 됩니다.
-예를 들어 섹션 3에서 "echo"의 매뉴얼 페이지를 찾고 싶다면: >
+ 특정한 섹션에서 매뉴얼 페이지를 찾고 싶다면, 섹션 번호를 먼저 넣으면
+됩니다. 예를 들어 섹션 3에서 "echo"의 매뉴얼 페이지를 찾고 싶다면: >

:Man 3 echo

"단어(1)"형식으로 표시되는 다른 매뉴얼 페이지를 보고 싶다면, 해당 단어로
이동해서 CTRL-]를 누르면 됩니다. ":Man" 명령어를 또 사용해도 새로운 창을
-만들지 않고 그 창에 매뉴얼 페이지를 보여줄 것입니다.
+만들지 않고 이미 만들어진 창에 매뉴얼 페이지를 보여줄 것입니다.

현재 커서가 있는 단어의 매뉴얼 페이지를 보고 싶다면 다음 명령을 사용하면
됩니다: >
@@ -280,21 +282,21 @@
==============================================================================
*12.7* 빈 칸 없애기

-줄 끝에 있는 빈칸이나 탭 등은 종종 쓸모없고 지저분하다고 여겨집니다. 모든
-줄에서 맨 끝의 공백을 지우기 위해서는 다음 명령을 사용하면 됩니다: >
+줄 끝에 있는 빈칸이나 탭 등은 종종 쓸모없고 지저분하게 보입니다. 모든 줄에서
+맨 끝의 공백을 지우기 위해서는 다음 명령을 사용하면 됩니다: >

:%s/\s\+$//

-"%" 범위가 사용되었으므로, 파일 전체에 적용됩니다. ":substitute"(치환) 명령이
-사용하는 패턴은 "\s\+$"입니다. 이 패턴은 공백(\s)이 줄의 맨 끝에($) 하나
-이상(\+) 있는 경우에 대응됩니다. 이러한 패턴을 쓰는 방법은 나중에
-|usr_27.txt|에서 보실 수 있습니다.
+"%" 범위가 사용되었으므로, 파일 전체에 적용됩니다. ":s"(치환) 명령이 사용하는
+패턴은 "\s\+$"입니다. 이 패턴은 공백(\s)이 줄의 맨 끝에($) 하나 이상(\+) 있는
+경우에 대응됩니다. 패턴을 쓰는 방법은 나중에 |usr_27.txt|에서 보실 수
+있습니다.
치환 명령의 "새로운" 문자열 부분은 다음과 같이 비어있습니다: "//". 따라서
아무 것도 새로 삽입되지 않고, 공백을 지우는 효과만 나게 됩니다.

공백이 아무 의미없이 사용되는 또 다른 예는 탭문자 앞에 공백이 있는 경우입니다.
이러한 공백을 지우더라도 실질적인 공백은 바뀌지 않습니다만, 꼭 항상 그런 것은
-아닙니다. 따라서 손으로 확인하며 지우는 것이 좋습니다. 다음 찾기 명령을
+아닙니다. 따라서 손으로 확인해가며 지우는 것이 좋습니다. 다음 찾기 명령을
사용합시다: >

/
@@ -308,11 +310,11 @@
==============================================================================
*12.8* 단어가 어디서 쓰였는 지 찾기

-만약 유닉스 사용자라면, 빔과 "grep"을 조합하여 어떤 단어가 여러 파일들의 어디에서
-쓰였는 지 찾을 수 있습니다. 예를 들어 프로그램을 짜는 중에 어떤 변수가 사용된
-모든 곳을 찾아 고치고 싶을 때 매우 유용한 기능입니다.
- "frame_counter"라는 단어가 사용된 모든 C 프로그램 파일을 고치고 싶다고 합시다.
-다음 명령을 사용하면 됩니다: >
+만약 유닉스 사용자라면, 빔과 "grep"을 조합하여 어떤 단어가 여러 파일들의
+어디에서 쓰였는 지 찾을 수 있습니다. 예를 들어 프로그램을 짜는 중에 어떤
+변수가 사용된 모든 곳을 찾아 고치고 싶을 때 매우 유용한 기능입니다.
+ "frame_counter"라는 단어가 사용된 모든 C 프로그램 파일을 고치고 싶다고
+합시다. 다음 명령을 사용하면 됩니다: >

vim `grep -l frame_counter *.c`

@@ -321,20 +323,20 @@
포함된 부분의 내용은 보여주지 않을 것입니다. 찾는 단어는
"frame_counter"이지만, 여기에는 정규표현식을 넣을 수도 있습니다. (유의사항:
"grep"에서 사용되는 빔에서 사용되는 정규표현식과 완전히 같지는 않습니다.)
- 전체 명령이 백틱(`)으로 싸여있는데, 이는 유닉스 쉘이 이 명령어를 수행한 후, 그
-결과가 명령줄에 입력된 것처럼 동작하라는 의미입니다. 여기서는 "grep" 명령이
-수행되어 파일들의 목록이 만들어진 후, 이 목록이 빔의 명령어 인자로 전달 됩니다.
-그 결과 빔은 "grep" 결과인 파일들을 열게 됩니다. ":first"나 ":next"같은
-명령으로 파일들을 바꾸어가며 편집할 수 있습니다.
+ 전체 명령이 백틱(`)으로 싸여있는데, 이는 유닉스 쉘이 이 명령어를 수행한 후,
+그 결과가 명령줄에 입력된 것처럼 동작하라는 의미입니다. 여기서는 "grep"
+명령이 수행되어 파일들의 목록이 만들어진 후, 이 목록이 빔의 명령어 인자로 전달
+됩니다. 그 결과 빔은 "grep"의 결과인 파일들을 열게 됩니다. ":first"나
+":next"같은 명령으로 파일들을 바꾸어가며 편집할 수 있습니다.


-각 줄을 찾기
-
-위 명령은 단어가 어느 파일에 포함되어있는 지만을 찾아서 알려줍니다. 따라서
-파일이 열린 후 파일 안에서 그 단어가 어디에 있는 지 또 찾아야만 합니다.
- 빔은 여러 파일들에서 문자열을 찾기 위한 명령을 내장하고 있습니다. 예를 들어
-C 프로그램 파일들에서 "error_string"을 모두 찾고 싶다면, 다음 명령어를 사용하면
-됩니다: >
+줄 단위로 찾기
+
+위 명령은 단어가 어느 파일에 포함되어있는 지 만을 찾아서 알려줍니다. 따라서
+파일이 열린 후 파일 안에서 그 단어가 어디에 있는 지 또 찾아야 합니다.
+ 빔은 여러 파일에서 문자열을 찾기 위한 명령을 내장하고 있습니다. 예를 들어
+C 프로그램 파일들에서 "error_string"을 모두 찾고 싶다면, 다음 명령어를
+사용하면 됩니다: >

:grep error_string *.c

@@ -342,9 +344,9 @@
첫번째 찾은 파일을 열고 첫번째 찾은 줄에 커서를 위치시킵니다. 다음으로 찾은 줄
(다른 파일이더라도 상관없습니다)로 이동하기 위해서는 ":cnext" 명령을 사용하면
됩니다. 이전에 찾았던 위치로 가려면 ":cprev" 명령을 사용하면 됩니다. ":clist"
-명령은 찾은 전체 결과를 보여주고 현재 어디를 편집하고 있는 지 보여줍니다.
- ":grep" 명령은 유닉스에서는 외부 명령어 "grep"을 사용하고, 윈도우에서는 "findstr"을
-사용합니다. 이 명령어는 'grepprg' 설정으로 바꿀 수 있습니다.
+명령은 전체 찾은 결과와 함께, 현재 어디를 편집하고 있는 지 보여줍니다.
+ ":grep" 명령은 유닉스에서는 외부 명령어 "grep"을 사용하고, 윈도우에서는
+"findstr"을 사용합니다. 이 명령어는 'grepprg' 설정으로 바꿀 수 있습니다.

==============================================================================


Modified: 7.0/doc/usr_22.kox
==============================================================================
--- 7.0/doc/usr_22.kox (original)
+++ 7.0/doc/usr_22.kox Sun May 4 20:17:12 2008
@@ -57,7 +57,7 @@

문법 강조를 사용하면, 각 부분이 다른 색으로 표시되어 구별하기 쉬워집니다.

-빔의 일반상태 명령들을 사용해서 내용 위를 움직이며 파일들을 편집할 수
+빔의 보통 상태 명령들을 사용해서 내용 위를 움직이며 파일들을 편집할 수
있습니다. 예를 들어, 파일명 위로 커서를 옮긴 후, <Enter>를 눌러보십시오. 그
파일을 편집하도록 바뀌었을 것입니다. 다시 탐색기로 돌아가려면 ":edit ."
명령을 사용하십시오. CTRL-O를 사용해도 됩니다.

Added: 7.0/doc/usr_24.kox
==============================================================================
--- (empty file)
+++ 7.0/doc/usr_24.kox Sun May 4 20:17:12 2008
@@ -0,0 +1,592 @@
+*usr_24.txt* Vim version 7.0 대상. 새로고침: 2006 Apr 24
+
+ VIM 사용설명서 - Bram Moolenaar 저
+ 정지용 역
+
+ 빠르게 입력하기
+
+
+빔은 문서를 작성할 때 타이핑 수를 줄이고, 실수를 막기 위한 다양한 도구를
+제공합니다. 이미 입력한 단어를 반복해서 입력하는 경우에는 입력 상태 자동
+완성을 사용하십시오. 긴 단어들은 약어를 만들어 입력하십시오. 키보드에는 없는
+문자들을 입력할 수도 있습니다.
+
+|24.1| 틀린 내용 고치기
+|24.2| 괄호 짝 찾기
+|24.3| 자동 완성
+|24.4| 반복 입력
+|24.5| 다른 줄에서 복사해오기
+|24.6| 레지스터 내용 입력하기
+|24.7| 약어
+|24.8| 특수문자 입력
+|24.9| 다이그래프(Digraph)
+|24.10| 보통 상태 명령
+
+다음 장: |usr_25.txt| 형식에 맞추어 편집하기
+이전 장: |usr_23.txt| 특별한 파일 편집하기
+ 차례: |usr_toc.txt|
+
+==============================================================================
+*24.1* 틀린 내용 고치기
+
+<BS> 키는 앞서 말했듯이, 커서 바로 앞의 글자를 지웁니다. <Del> 키는 커서가
+위치해있는(혹은, 바로 다음의) 글자를 지웁니다.
+ 만약 단어 전체를 잘못 입력했다면, CTRL-W를 사용하십시오:
+
+ The horse had fallen to the sky ~
+ CTRL-W
+ The horse had fallen to the ~
+
+내용이 완전히 꼬여서 줄 전체를 다시 입력하고 싶다면, CTRL-U로 전체를
+지우십시오. 커서 뒤의 내용과 들여쓰기는 지워지지 않습니다. 공백이 아닌 첫
+글자부터 커서까지의 내용만 지워집니다. 다음 예에서 "fallen"의 "f"에 커서를
+두고 CTRL-U를 누르면 다음과 같이 됩니다:
+
+ The horse had fallen to the ~
+ CTRL-U
+ fallen to the ~
+
+몇 단어 전에 잘못 입력한 내용이 있어서, 커서를 옮긴 후 고쳐야한다고 합시다.
+예를 들어 다음과 같이 입력했다고 합시다:
+
+ The horse had follen to the ground ~
+
+"follen"을 "fallen"으로 고쳐야합니다. 커서가 맨 뒤에있다고 할 때, 다음을
+입력하면 됩니다:
+
+ <Esc>4blraA
+
+< 입력 상태 벗어나기 <Esc>
+ 네 단어 앞으로 4b
+ 오른쪽으로 한 칸 움직여 "o" 위로 l
+ "a"로 바꿈 ra
+ 입력 상태로 돌아감 A
+
+다음 방법으로 해도 됩니다: >
+
+ <C-Left><C-Left><C-Left><C-Left><Right><Del>a<End>
+
+< 네 단어 앞으로 <C-Left><C-Left><C-Left><C-Left>
+ 오른쪽으로 한 칸 움직여 "o" 위로 <Right>
+ "o"를 지움 <Del>
+ "a"를 입력 a
+ 줄의 끝으로 이동 <End>
+
+이 방법에서는 입력 상태를 유지한 채, 특수키들을 사용해서 움직입니다. 상태가
+따로 없는 일반적인 편집기들과 마찬가지입니다. 외우기는 쉽지만, 더 오래
+걸립니다 (손을 일반키 자판에서 화살표키로 옮겨야하는 데다가, 키보드를 보지
+않고 <End> 키를 누르기는 쉽지 않습니다).
+ 이 특수키들은 입력 상태를 벗어나지 않는 매핑을 만들 때 유용합니다. 이 때는
+타이핑을 하는 데 걸리는 시간이 별로 문제되지 않을테니까요.
+ 입력 상태에서 사용할 수 있는 키들은 다음과 같습니다:
+
+ <C-Home> 파일의 시작으로
+ <PageUp> 한 화면 위로
+ <Home> 줄의 시작으로
+ <S-Left> 한 단어 왼쪽으로
+ <C-Left> 한 단어 왼쪽으로
+ <S-Right> 한 단어 오른쪽으로
+ <C-Right> 한 단어 오른쪽으로
+ <End> 줄의 끝으로
+ <PageDown> 한 화면 아래로
+ <C-End> 파일의 끝으로
+
+여기에 언급되지 않은 명령이 몇 가지 더 있는데, |ins-special-special|에서 볼 수
+있습니다.
+
+==============================================================================
+*24.2* 괄호 짝 찾기
+
+) 를 입력할 때, 대응되는 ( 를 알려줄 수 있다면 좋을 것입니다. 빔에서는 다음
+명령을 사용하면 됩니다: >
+
+ :set showmatch
+
+"(예제)"를 타이핑 할 때, ) 를 입력하는 순간, 잠깐 커서가 대응되는 ( 로
+옮겨졌다가 0.5초 쯤 후에 다시 원래 위치로 돌아옵니다.
+ 대응되는 ( 가 없는 경우에는, 경고음을 내서 어딘가에 ( 를 빼먹었거나, ) 를
+너무 많이 입력했다고 알려줍니다.
+ [] 나 {} 쌍도 대응되는 것을 보여줍니다. 대응되는 괄호가 보여지는 동안
+기다릴 필요는 없습니다. 다음 문자가 입력되자마자 커서가 원래 위치로 옮겨지고
+입력이 계속 처리됩니다.
+ 'matchtime'(대응시간) 설정으로 빔이 괄호쌍을 보여주는 시간을 조절할 수
+있습니다. 1.5초간 보여주게 하려면: >
+
+ :set matchtime=15
+
+시간은 10분의 1초 단위로 지정합니다.
+
+==============================================================================
+*24.3* 자동 완성
+
+입력 도중에 단어를 완성시킬 수 있습니다. 단어의 앞부분을 입력하다가 CTRL-P 를
+누르면 됩니다. 나머지 부분은 빔이 추측하여 채우게 됩니다.
+ 예를 들어, C 프로그래밍 중 다음과 같은 내용을 넣고 싶다고 합시다 :
+
+ total = ch_array[0] + ch_array[1] + ch_array[2]; ~
+
+먼저 다음 내용을 입력하십시오:
+
+ total = ch_array[0] + ch_ ~
+
+이 상황에서, CTRL-P 명령으로 단어를 완성시켜봅시다. 빔은 커서의 앞쪽에 위치한
+문자들로 시작하는 단어를 찾습니다. 이 경우에는 "ch_" 이므로, ch_array 라는
+단어가 해당됩니다. 따라서 CTRL-P 를 입력한 결과는 다음과 같습니다:
+
+ total = ch_array[0] + ch_array ~
+
+다음과 같이 몇 자 더 입력했다고 합시다 (맨 마지막에 스페이스가 있습니다):
+
+ total = ch_array[0] + ch_array[1] + ~
+
+CTRL-P 를 누르면 빔은 커서 앞의 단어를 완성시키기에 적절한 단어를 찾습니다.
+커서 앞에는 공백만 있을 뿐 아무 내용도 없기 때문에, 커서 이전(backward)의 첫
+번째 단어인 "ch_array"를 찾게 됩니다. CTRL-P 를 한 번 더 누르면 다음 대응되는
+단어인 "total"을 보여줍니다. CTRL-P 를 더 누르면 그 다음을 계속 찾게 됩니다.
+위 내용 밖에 없으면, 추천할 단어가 바닥났으므로 원래의 내용으로 돌아오게
+됩니다. 이 경우에는 그냥 아무것도 없는 상태가 됩니다. 네 번째 CTRL-P 로는
+추천 단어 찾기가 다시 시작되고, "ch_array"가 다시 나옵니다.
+
+단어 완성 후보를 현재 커서 위치 이후(forward)에서 먼저 찾으려면, CTRL-N 을
+사용하십시오. 파일의 끝을 만나면, 파일의 맨 처음으로 돌아가서 계속 찾기
+때문에, CTRL-N 과 CTRL-P 는 같은 단어들을 반대의 순서로 보여주게 됩니다.
+힌트: CTRL-N 은 이후(Next) 찾기이고, CTRL-P 는 이전(Previous) 찾기입니다.
+
+빔은 자동으로 단어를 완성하기 위해, 많은 곳을 찾습니다. 기본적으로 다음
+내용들을 찾습니다:
+
+ 1. 현재 파일
+ 2. 다른 창의 파일
+ 3. 다른 로딩된 파일 (숨겨진 버퍼)
+ 4. 로딩되지 않은 파일 (비활성 버퍼)
+ 5. 태그 파일
+ 6. 현재 파일에 인클루드(#include) 된 파일
+
+
+설정
+
+탐색 순서는 'complete'(자동완성) 설정으로 바꿀 수 있습니다.
+
+'ignorecase'(대소문자무시) 설정이 켜지면 찾을 때 대소문자 차이가 무시됩니다.
+
+자동 완성과 관련된 설정 중 'infercase'(대소문자추론)는 대소문자를 무시하고 단어를 찾기는
+하지만 ('ignorecase' 설정이 켜져있어야 합니다), 현재 입력한 내용의 대소문자
+여부를 유지해야할 때 유용합니다. 예를 들어 "For"를 입력하고, 빔이
+"fortunately"를 찾았을 때, "Fortunately"로 자동완성 됩니다.
+
+
+특정한 내용으로 자동완성 하기
+
+어떤 내용을 입력할 지 이미 알고 있다면, 특정한 내용의 경우는 다음 명령을
+사용하여 완성할 수도 있습니다:
+
+ CTRL-X CTRL-F 파일명
+ CTRL-X CTRL-L 줄 전체
+ CTRL-X CTRL-D 매크로 정의 (인클루드(#include) 된 파일 포함)
+ CTRL-X CTRL-I 현재 파일과 인클루드 된 파일
+ CTRL-X CTRL-K 사전에서 찾기
+ CTRL-X CTRL-T 시소러스에서 찾기
+ CTRL-X CTRL-] 태그
+ CTRL-X CTRL-V 빔 명령줄
+
+위 명령 입력 후에는 CTRL-N 으로 다음 후보로, CTRL-P 로 이전 후보로 이동할 수
+있습니다.
+ 명령에 대한 더 자세한 정보는 |ins-completion|을 참고하십시오.
+
+
+파일명 자동완성
+
+예를 들어 CTRL-X CTRL-F 를 봅시다. 이 명령은 파일명으로 완성시켜줍니다. 현재
+디렉토리를 찾아서 현재 커서 앞의 문자열과 일치하는 것을 보여줍니다.
+ 예를 들어, 현재 디렉토리에 다음과 같은 파일들이 있다고 합시다:
+
+ main.c sub_count.c sub_done.c sub_exit.c
+
+입력 상태로 들어가서 다음 내용을 입력하십시오:
+
+ 종료 코드는 다음 파일에 있습니다: sub ~
+
+이 상태에서, CTRL-X CTRL-F 를 입력하십시오. 빔이 현재 디렉토리를 찾아서,
+"sub"로 시작하는 단어로 완성시킬 것입니다. 첫번째 후보는 sub_count.c 입니다.
+이것이 아니라면, CTRL-N 으로 다음 파일로 넘어갑니다. 이번 후보는 sub_done.c
+입니다. CTRL-N 을 또 누르면 sub_exit.c 가 됩니다. 결과는 다음과 같습니다.
+
+ 종료 코드는 다음 파일에 있습니다: sub_exit.c ~
+
+파일명이 / (유닉스) 나 C:\ (MS-윈도우) 로 시작하는 경우에는 파일시스템의 모든
+파일을 찾을 수 있습니다. 예를 들어, "/u"를 입력하고 CTRL-X CTRL-F 를 하면,
+"/usr" 가 될 것입니다 (유닉스):
+
+ 파일은 다음 위치에 있습니다 /usr/ ~
+
+다시 CTRL-N 을 누르면 "/u"로 돌아갑니다. "/usr/" 상태에서 한 디렉토리 더
+안으로 들어가려면, CTRL-X CTRL-F 를 다시 누르면 됩니다:
+
+ 파일은 다음 위치에 있습니다 /usr/X11R6/ ~
+
+물론, 실제 동작은 현재 파일 시스템의 상태에 따라 다릅니다. 완성 후보들은
+알파벳 순으로 정렬됩니다.
+
+
+프로그램 소스 코드에서의 자동완성
+
+소스코드 파일은 보통 그 구조가 정해져 있으므로, 좀 더 머리를 쓰면 훨씬
+훌륭하게 자동완성을 할 수 있습니다. 빔에는 옴니(Omni) 자동완성이란 기능이
+있습니다. 다른 에디터에서는 인텔리센스(intellisense - 상표권이
+걸려있습니다)라고도 부릅니다.
+
+옴니 자동완성의 키는 CTRL-X CTRL-O 입니다. 물론 O는 옴니(Omni)의 O이므로
+외우기 쉽습니다. C 프로그램 소스를 편집하는 예를 보겠습니다:
+
+ { ~
+ struct foo *p; ~
+ p-> ~
+
+커서가 "p->" 다음에 있을 때, CTRL-X CTRL-O 를 눌러봅시다. 빔은 "struct foo"에
+속한 단어들로 후보 목록을 만듭니다. CTRL-P 를 눌렀을 때처럼 모든 단어가
+후보가 되는 게 아니라, 현재 상황에 적합한 "struct foo"의 멤버들만 후보가
+된다는 점이 다릅니다.
+
+옴니 자동완성이 동작하기 위해서는 미리 설정을 좀 해야합니다. C 코드를
+작성하는 경우, 태그파일을 만들고 'tags'(태그) 설정을 해놓아야 합니다. 자세한 설명은
+|ft-c-omni|를 참고하십시오. 다른 종류의 파일도 비슷한 일을 해야하는데,
+|compl-omni-filetypes|를 참고하십시오. 아직은 잘 알려진 몇몇 종류의
+파일에서만 동작합니다. 현재 동작 중인지 여부를 확인하려면
+'omnifunc'(옴니함수) 설정값을 확인하십시오.
+
+==============================================================================
+*24.4* 반복 입력
+
+CTRL-A 를 누르면, 지난 입력 상태 때 입력했었던 내용을 다시 입력합니다.
+ 예를 들어, 다음 내용으로 시작하는 파일이 있다고 합시다.
+
+ "file.h" ~
+ /* main 프로그램 코드 */ ~
+
+첫 번째 줄의 앞에 "#include "를 추가했습니다:
+
+ #include "file.h" ~
+ /* main 프로그램 코드 */ ~
+
+"j^" 를 입력하여 다음 줄의 맨 앞으로 이동합니다. 또 "#include" 로 시작하는
+줄을 입력하려면 :
+
+ i CTRL-A
+
+결과는 다음과 같습니다:
+
+ #include "file.h" ~
+ #include /* main 프로그램 코드 */ ~
+
+CTRL-A 를 누르면 지난 입력 상태 때 입력한 내용이 입력되므로, 위와 같이
+"#include "가 들어갔습니다. "main.h"<Enter> 를 입력하여 줄을 완성합시다:
+
+
+ #include "file.h" ~
+ #include "main.h" ~
+ /* main 프로그램 코드 */ ~
+
+CTRL-@ 명령은 CTRL-A 역할을 한 후, 입력 상태를 빠져나갑니다. 똑같은 내용을
+계속 입력해야할 때 사용하면 좋습니다.
+
+==============================================================================
+*24.5* 다른 줄에서 복사해오기
+
+CTRL-Y 명령은 커서 바로 위의 글자를 입력합니다. 앞 줄의 내용을 복사할 때
+유용합니다. 예를 들어, 다음과 같은 C 코드가 있다고 합시다:
+
+ b_array[i]->s_next = a_array[i]->s_next; ~
+
+"s_prev"만 "s_next"로 바꾸며 같은 내용을 또 입력하고 싶다고 합시다.
+새 줄을 시작하고, CTRL-Y 를 14번 눌러 "next"의 "n"앞까지 옵시다:
+
+ b_array[i]->s_next = a_array[i]->s_next; ~
+ b_array[i]->s_ ~
+
+"prev"를 직접 입력합시다:
+
+ b_array[i]->s_next = a_array[i]->s_next; ~
+ b_array[i]->s_prev ~
+
+다시 CTRL-Y 를 "next"가 나올 때까지 누릅시다:
+
+ b_array[i]->s_next = a_array[i]->s_next; ~
+ b_array[i]->s_prev = a_array[i]->s_ ~
+
+"prev;"를 입력해서 끝냅시다.
+
+반대로 CTRL-E 는 커서 밑의 문자를 CTRL-Y 와 유사한 방법으로 입력합니다.
+
+==============================================================================
+*24.6* 레지스터 내용 입력하기
+
+CTRL-R {레지스터} 명령은 레지스터의 내용을 입력합니다. 긴 단어를 입력할 때
+유용합니다. 예를 들어, 다음 내용을 입력한다고 합시다:
+
+ r = VeryLongFunction(a) + VeryLongFunction(b) + VeryLongFunction(c) ~
+
+함수명은 다른 파일에서 정의되었다고 합시다. 그 파일에서 함수명 위로 커서를
+옮긴 후, 레지스터 v로 복사해넣읍시다: >
+
+ "vyiw
+
+"v 는 레지스터 지정이고, "yiw"는 복사하기(yank)-안쪽의(inner)-단어(word) 입니다.
+내용을 입력할 파일로 가서, 줄의 앞부분을 직접 입력합시다:
+
+ r = ~
+
+이제 CTRL-R v 를 써서 함수명을 입력합니다:
+
+ r = VeryLongFunction ~
+
+함수명 사이의 내용은 직접 바로 입력하면 되고, 함수명은 CTRL-R v 를 두 번 더
+써서 입력합니다.
+ 자동완성을 써서 입력할 수도 있습니다. 하지만 같은 문자로 시작하는 단어들이
+많은 경우에는 레지스터를 쓰는 쪽이 더 효율적입니다.
+
+만약 레지스터에 <BS> 같은 특수 문자가 들어있다면, 그 문자가 키보드에서 눌린
+것처럼 해석되어 동작하게 됩니다. 이 것을 막으려면 (진짜로 문서에 <BS> 문자를
+넣으려면) CTRL-R CTRL-R {레지스터} 명령을 사용하십시오.
+
+==============================================================================
+*24.7* 약어
+
+약어(abbreviation)란 원래의 긴 단어를 간략하게 표시한 것입니다. 예를 들어,
+일반적으로 "ad"는 "advertisement"를 의미합니다. 빔에는 약어를 입력하면
+자동으로 긴 표현으로 확장해주는 기능이 있습니다.
+ "ad"를 입력하면 자동으로 "advertisement"로 확장되도록 하려면, 다음 명령을
+사용하십시오: >
+
+ :iabbrev ad advertisement
+
+이제 "ad"만 입력하면, 자동으로 "advertisement"가 확장되어 들어갑니다. 이
+확장은 단어의 일부가 될 수 없는 문자 - 예를 들어 스페이스 - 가 들어올 때
+일어납니다:
+
+ 입력된 내용 화면에 나타나는 내용
+ I saw the a I saw the a ~
+ I saw the ad I saw the ad ~
+ I saw the ad<Space> I saw the advertisement<Space> ~
+
+"ad"만 입력해서는 확장이 일어나지 않습니다. 이는 "add" 같은 단어를 입력할 수
+있도록, 다른 단어의 일부인 경우는 확장이 일어나지 않게 하기 위함입니다. 오직
+단어 통째에 대해서만 약어인지 여부를 확인합니다.
+
+
+어구의 약어인 경우
+
+약어가 단어 하나가 아니라 여러 단어로 이루어진 어구를 가리키도록 할 수도
+있습니다. 예를 들어, "JB"를 "Jack Benny"로 정의하려면 다음 명령을
+사용하십시오: >
+
+ :iabbrev JB Jack Benny
+
+저는 프로그래밍을 위해 다음과 같은 특이한 약어를 사용합니다: >
+
+ :iabbrev #b /****************************************
+ :iabbrev #e <Space>****************************************/
+
+이 약어들은 주석 상자를 만들기 위해서 씁니다. 윗 줄을 그리는 #b 로 주석
+상자를 열고, 주석 내용을 모두 쓴 다음, #e 로 아랫 줄을 그려서 주석을
+마무리하면 됩니다.
+ 특이하게 #e 약어는 스페이스로 시작하고 있습니다. 즉, 첫 두 문자가
+스페이스와 별입니다. 일반적으로 약어와 긴 표현 간의 공백은 무시됩니다.
+따라서 공백을 표시하기 위해 <, S, p, a, c, e, > 라고 명확하게 써 준 것입니다.
+
+ Note:
+ ":iabbrev" 도 매 번 입력하기는 꽤 긴 명령입니다. ":iab" 만 써도
+ 됩니다. 약어 명령의 약어인 셈이지요.
+
+
+입력 오류 자동 수정
+
+키보드를 치다보면 같은 입력 실수를 계속 하게되는 경우가 있습니다. 예를 들어,
+"the"를 쳐야하는데, "teh"라고 치는 경우가 많습니다. 이 경우 다음과 같은
+약어로 자동으로 고쳐지도록 할 수 있습니다: >
+
+ :abbreviate teh the
+
+이런 실수들을 모두 등록해 놓으면 됩니다. 만날 틀리는 단어를 발견할 때마다
+등록해주면 되겠습니다.
+
+
+약어 목록 표시하기
+
+":abbreviate" 명령은 약어의 목록을 보여줍니다:
+
+ :abbreviate
+ i #e ****************************************/
+ i #b /****************************************
+ i JB Jack Benny
+ i ad advertisement
+ ! teh the
+
+줄 맨 앞의 "i"는 입력(insert) 상태를 나타냅니다. 이 약어는 입력 상태에서만
+유효합니다. "i" 외에도 다음 문자들이 올 수 있습니다:
+
+ c 명령줄 상태 :cabbrev
+ ! 입력 상태와 명령줄 상태 :abbreviate
+
+일반적으로 명령줄 상태에서는 약어가 많이 쓰이지 않으므로, 대부분 ":iabbrev"
+명령을 사용하게 될 것입니다. 따라서 다음과 같은 명령을 사용할 때는 "ad"가
+확장되지 않습니다: >
+
+ :edit ad
+
+
+약어 삭제하기
+
+약어를 삭제하려면, ":unabbreviate" 명령을 사용합니다. 다음과 같은 약어가
+있다고 합시다 >
+
+ :abbreviate @f fresh
+
+다음 명령으로 약어를 지울 수 있습니다 >
+
+ :unabbreviate @f
+
+명령을 입력하다보면, @f가 "fresh"로 확장되었을 것입니다. 하지만, 어쨌든 빔이
+잘 인식해서 지울테니 걱정하지 않아도 됩니다 (단, "fresh"가 다른 단어의
+약어였다면 엉뚱한 것이 지워지겠지만, 이럴 일은 거의 없을 것입니다).
+ 모든 약어를 지우려면: >
+
+ :abclear
+
+":unabbreviate"와 ":abclear"의 입력 상태 한정판(":iunabbreviate"와
+":iabclear")과 명령줄 상태 한정판(":cunabbreviate"와 ":cabclear")도 있습니다.
+
+
+약어가 다시 매핑 되는 경우
+
+약어를 정의할 때 주의할 점이 있습니다: 확장된 문자열이 매핑 되지 않아야한다는
+것입니다. 예를 들어: >
+
+ :abbreviate @a adder
+ :imap dd disk-door
+
+이 상태에서 @a 를 입력하면, "adisk-doorer"가 나타날 것입니다. 물론 이 것을
+의도한 것은 아닙니다만. 이렇게 약어가 다시 매핑되는 경우를 피하려면,
+":noreabbrev" 명령을 사용하십시오. ":abbreviate"와 동일하지만, 확장된 문자열이
+다시 매핑되는 것을 막아줍니다: >
+
+ :noreabbrev @a adder
+
+다행히 약어가 확장된 결과가 다시 매핑되는 경우는 그리 많지 않습니다.
+
+==============================================================================
+*24.8* 특수문자 입력
+
+다음 문자를 문자 그대로 문서에 입력하려면, CTRL-V 명령을 사용하면 됩니다. 즉,
+다음 문자의 특별한 기능이 무시된다는 의미입니다. 예를 들어: >
+
+ CTRL-V <Esc>
+
+위 명령은 이스케이프 문자를 삽입합니다. 따라서 입력 상태에서 빠져나가지
+않습니다. (CTRL-V 다음에 스페이스를 누르지 마십시오. 읽기 쉽도록 띄어놓은 것
+뿐입니다).
+
+ Note:
+ MS-윈도우에서는 CTRL-V가 붙여넣기에 사용됩니다. 이 때는 CTRL-V 대신
+ CTRL-Q를 사용하십시오. 반대로 유닉스에서는 종종 CTRL-Q가 다른 용도로
+ 사용되므로, CTRL-Q가 동작하지 않습니다.
+
+{숫자} 에 해당하는 문자를 입력하려면, CTRL-V {숫자} 명령을 사용하십시오. 예를
+들어, 127에 해당하는 문자인 <Del> 문자(<Del> 키가 항상 <Del> 문자를 나타내지는
+않습니다!)를 입력하려면: >
+
+ CTRL-V 127
+
+이 방법으로 255까지의 문자를 입력할 수 있습니다. 숫자가 두 자리 이하일
+경우에는, 숫자가 아닌 문자를 입력하면 명령이 끝납니다. 숫자가 아닌 문자를
+입력하지 않으려면, 숫자 앞에 0을 붙여서 세 자리로 만들어주면 됩니다.
+ 다음의 명령들은 모두 <Tab> 문자와 점을 입력합니다:
+
+ CTRL-V 9.
+ CTRL-V 09.
+ CTRL-V 009.
+
+숫자를 16진수로 입력하려면, CTRL-V 다음에 "x"를 입력하면 됩니다: >
+
+ CTRL-V x7f
+
+역시 255(CTRL-V xff)까지의 문자를 입력할 수 있습니다. 숫자 앞에 "o"를 붙여서
+8진수로 입력할 수도 있습니다. 그리고, 16 비트 문자나 32비트 문자를 입력하기
+위한 방법도 있습니다 (예를 들어, 유니코드를 입력할 때 사용할 수 있습니다):
+
+ CTRL-V o123
+ CTRL-V u1234
+ CTRL-V U12345678
+
+==============================================================================
+*24.9* 다이그래프(Digraph)
+
+가끔 키보드에 없는 문자를 입력해야 할 때가 있습니다. 저작권을 나타내는 ©
+문자가 좋은 예입니다. 빔에서 이런 문자들을 입력하려면, 두 문자로 한 문자를
+표현하는 다이그래프(digraph)를 사용하면 됩니다. 예를 들어 © 를 입력하려면
+다음과 같이 세 개의 키를 눌러야 합니다: >
+
+ CTRL-K Co
+
+다이그래프로 입력할 수 있는 문자를 보려면, 다음 명령을 사용하십시오: >
+
+ :digraphs
+
+다이그래프 문자표가 나옵니다. 다음은 그 중 세 줄만 뽑아본 것입니다:
+
+ AC ~_ 159 NS | 160 !I ¡ 161 Ct ¢ 162 Pd £ 163 Cu ¤ 164 Ye ¥ 165 ~
+ BB ¦ 166 SE § 167 ': ¨ 168 Co © 169 -a ª 170 << « 171 NO ¬ 172 ~
+ -- ­ 173 Rg ® 174 'm ¯ 175 DG ° 176 +- ± 177 2S ² 178 3S ³ 179 ~
+
+예를 들어 위 표를 보고, £ 문자를 입력하려면 CTRL-K Pd 를 누르면 된다고 알 수
+있습니다. 이 문자는 10진수로 163에 해당합니다.
+ Pd 는 파운드(Pound)를 줄인 것입니다. 대부분의 다이그래프는 실제로 표시되는
+문자를 쉽게 짐작할 수 있도록 정해졌습니다. 위 표를 쭉 살펴보면 이해가 가실
+것입니다.
+ 겹치는 다이그래프가 없다면, 첫 번째와 두 번째 문자를 바꿔서 눌러도
+괜찮습니다. 즉, CTRL-K dP 에 해당하는 게 없다면, "Pd"에 해당되는 문자를
+보여줍니다. (역주: CTRL-K dP 에 해당하는 문자가 있는 경우도 있습니다.)
+
+ Note:
+ 다이그래프는 빔이 인식하는 문자셋에 따라 달라집니다.
+ MS-DOS에서의 다이그래프는 윈도우에서와 다를 수도 있습니다. 따라서
+ 현재 어떤 다이그래프를 쓸 수 있는 지 ":digraphs" 명령으로 꼭
+ 확인해야합니다.
+
+직접 다이그래프를 정의할 수도 있습니다. 예를 들어: >
+
+ :digraph a" ä
+
+위 명령은 CTRL-K a" 가 ä 문자를 입력하도록 지정합니다. 문자가 아니라 10진법
+숫자로 지정할 수도 있습니다. 똑같은 다이그래프를 정의하는 예입니다: >
+
+ :digraph a" 228
+
+다이그래프에 대한 자세한 정보는 |digraphs|를 참고하십시오.
+ 다이그래프 말고 키맵(keymap)을 사용해서 특수문자를 넣을 수도 있습니다.
+|45.5|를 참고하십시오.
+
+==============================================================================
+*24.10* 보통 상태 명령
+
+입력 상태에서 사용할 수 있는 명령은 그다지 많지 않습니다. 보통 상태에서는
+훨씬 많은 명령들을 사용할 수 있기 때문에, <Esc>를 누르고 보통 상태로
+빠져나와서 명령을 수행한 후 "i"나 "a"로 입력 상태로 돌아가는 경우가 많습니다.
+ 좀 더 빠른 방법이 있습니다. CTRL-O {명령} 으로 입력 상태에서도 모든 보통
+상태 명령을 사용할 수 있습니다. 예를 들어, 현재 줄 커서 이후의 내용을 모두
+지우려면: >
+
+ CTRL-O D
+
+이 방법으로는 단 하나의 보통 상태 명령만 사용할 수 있습니다. 명령 이외에
+레지스터나 횟수도 함께 지정할 수 있습니다. 좀 더 복잡한 명령의 예를 보면
+다음과 같습니다: >
+
+ CTRL-O "g3dw
+
+세 개의 단어를 잘라내어 g 레지스터에 담습니다.
+
+==============================================================================
+
+다음 장: |usr_25.txt| 형식에 맞추어 편집하기
+
+저작권: |manual-copyright| 참고 vim:tw=78:ts=8:ft=help:norl:

Added: 7.0/doc/usr_25.kox
==============================================================================
--- (empty file)
+++ 7.0/doc/usr_25.kox Sun May 4 20:17:12 2008
@@ -0,0 +1,591 @@
+*usr_25.txt* Vim version 7.0 대상. 새로고침: 2006 Apr 24
+
+ VIM 사용설명서 - Bram Moolenaar 저
+ 정지용 역
+
+ 형식에 맞추어 편집하기
+
+
+문서를 작성하다보면, 문장 하나에 한 줄이 넘어가는 경우가 많습니다. 이번
+장에서는 문장을 나누어 페이지 크기나 다른 형식에 맞추는 방법을 살펴보겠습니다.
+줄 단위 단락이나 표 편집을 위해 빔이 제공하는 다양한 기능도 살펴보겠습니다.
+
+|25.1| 줄 나누기
+|25.2| 정렬하기
+|25.3| 들여쓰기와 탭
+|25.4| 긴 줄 다루기
+|25.5| 표 편집하기
+
+다음 장: |usr_26.txt| 반복하기
+이전 장: |usr_24.txt| 빠르게 입력하기
+ 차례: |usr_toc.txt|
+
+==============================================================================
+*25.1* 줄 나누기
+
+빔에는 문서를 더 쉽게 다루기 위한 많은 기능이 있습니다. 기본 설정으로는
+자동으로 줄이 바뀌지 않습니다. 즉, 줄을 바꾸려면 <Enter>를 직접 입력해야
+합니다. 이 기능은 프로그램을 작성할 때와 같이 대부분의 줄 바꿈을 직접
+결정하는 경우에는 유용합니다. 하지만 문서를 써야하는데, 최대 한 줄에 70자
+까지만 쓸 수 있어서 일일이 줄 길이를 맞춰주어야하는 경우라면 불편할 것입니다.
+ 'textwidth'(내용폭) 설정을 사용하면, 빔이 자동으로 줄을 바꿔줍니다. 예를
+들어, 한 줄에 30 글자까지만 들어가도록(역주: 영어 기준으로 30글자이다. 한글은
+한 자에 두 칸을 차지하므로 한글로만 이루어지는 경우 15글자까지만
+들어가게됩니다) 폭을 제한하려면 다음 명령을 사용하십시오: >
+
+ :set textwidth=30
+
+이제 다음 내용을 입력해봅시다 (칸표시를 추가했습니다):
+
+ 1 2 3
+ 12345678901234567890123456789012345
+ 나는 한 때 프로그래밍을 가르쳤 ~
+
+위 내용 다음에 "습"을 입력하는 순간, 줄이 30자 제한을 넘어가게 됩니다. 빔은 이
+제한이 넘어가는 순간, 줄을 바꿉니다. 그 결과는 다음과 같습니다:
+
+ 1 2 3
+ 12345678901234567890123456789012345
+ 나는 한 때 프로그래밍을 ~
+ 가르쳤습 ~
+
+입력을 계속해서 문단 전체를 완성시키면 됩니다:
+
+ 1 2 3
+ 12345678901234567890123456789012345
+ 나는 한 때 프로그래밍을 ~
+ 가르쳤습니다. 한번은 내가 낸 ~
+ 숙제가 너무 어려워서 포트워스 ~
+ 경찰에게 제지당한 적도 ~
+ 있었습니다. 진짜입니다. ~
+
+직접 줄을 바꾸지 않아도, 빔이 자동으로 바꾸어줍니다.
+
+ Note:
+ 'wrap'(자동줄바꿈) 설정을 켜면 빔은 긴 줄을 여러 줄로 나누어서
+ 보여줍니다. 하지만, 실제로 문서에 줄바꿈 문자를 넣지는 않습니다.
+
+
+형식에 맞추어 바꾸기
+
+빔은 워드프로세서가 아닙니다. 워드 프로세서에서는 문단의 처음에서 몇 단어를
+지우면, 전체 줄바꿈이 자동으로 맞추어집니다. 하지만 빔은 그렇지 않습니다.
+따라서 위 예에서 "프로그래밍을" 부분을 지운다고 해도, 그 줄만 짧아질 뿐입니다:
+
+ 1 2 3
+ 12345678901234567890123456789012345
+ 나는 한 때 ~
+ 가르쳤습니다. 한번은 내가 낸 ~
+ 숙제가 너무 어려워서 포트워스 ~
+ 경찰에게 제지당한 적도 ~
+ 있었습니다. 진짜입니다. ~
+
+별로 보기 안좋습니다. 문단을 다시 깔끔하게 만들기 위해 "gq" 명령을 사용합시다.
+ 먼저, 가시 상태에서 위 부분을 선택합시다. 첫 줄로 커서를 옮긴 후, 다음
+명령을 사용합시다: >
+
+ v4jgq
+
+"v"로 가시 상태로 들어간 후, "4j"로 문단의 끝으로 커서를 옮깁니다. 그리고 "gq"
+연산자(operator)를 적용합니다. 결과는 다음과 같습니다:
+
+ 1 2 3
+ 12345678901234567890123456789012345
+ 나는 한 때 가르쳤습니다. ~
+ 한번은 내가 낸 숙제가 너무 ~
+ 어려워서 포트워스 경찰에게 ~
+ 제지당한 적도 있었습니다. ~
+ 진짜입니다. ~
+
+Note: 특정한 문서 형태는 자동으로 형식을 맞출 수도 있습니다. |auto-format|을
+참고하십시오.
+
+"gq"는 연산자이기 때문에, 적용할 부분을 다음 세 가지 방법으로 선택할 수
+있습니다: 가시 상태를 이용하는 방법, 이동을 이용하는 방법, 문자열 객체를
+이용하는 방법.
+ 위에서 본 예의 경우, 동일한 동작을 "gq4j"로 할 수도 있습니다. 더 타이핑을
+적게 할 수 있지만, 명령을 사용하려면 전체가 몇 줄인지를 알아야 합니다. 더
+편한 이동 명령은 "}"입니다. 이 명령은 문단의 마지막으로 이동하는 명령입니다.
+따라서 "gq}"는 현재 커서 위치부터 문단 마지막까지의 형식을 맞추어줍니다.
+ "gq"에 문자열 객체를 이용하려면 문단 객체가 적당합니다. 다음 명령을
+사용해보십시오: >
+
+ gqap
+
+"ap"는 "a-paragraph(문단)"을 의미합니다. 위 명령은 문단 하나의 형식을
+맞춥니다 (문단은 빈 줄로 구분합니다). 이 명령은 같은 문단에 속하기만 하면
+커서 앞의 내용에도 적용됩니다.
+ 문단들이 빈 줄로 각각 구분되어있다면, 다음 명령으로 파일 전체의 형식을 맞출
+수 있습니다: >
+
+ gggqG
+
+"gg"로 커서를 파일의 맨 앞으로 옮긴 다음, "gqG"로 파일의 마지막 줄까지 형식을
+맞춥니다.
+ 주의: 만약 문단이 빈 줄로 구분되어있지 않다면, 하나로 붙어버립니다.
+스페이스나 탭 같은 공백이 들어있는 줄들을 조심하십시오. 이런 줄들은 내용 없이
+공백만 있는 줄이지만, 빈 줄은 아닙니다.
+
+빔은 단순 텍스트 문서 이외의 형식도 지원합니다. 형식을 변경하려면
+|fo-table|을 참고하십시오. 마침표 이후의 공백 수를 바꾸려면
+'joinspaces'(붙이기공백) 설정을 변경하십시오.
+ 형식을 맞추기 위해 외부 프로그램을 사용할 수도 있습니다. 빔의 명령어들
+만으로 형식을 맞추기 어려운 경우에 유용합니다. 'formatprg'(포맷프로그램)
+설정을 참고하십시오.
+
+==============================================================================
+*25.2* 정렬하기
+
+여러 줄을 가운데 정렬 하려면, 다음 명령을 사용하십시오: >
+
+ :{범위}center [폭]
+
+{범위}는 일반적으로 명령줄에사 사용되는 범위입니다. [폭]은 가운데 정렬할 때
+사용할 줄의 폭으로, 생략할 수 있습니다. 만약 [폭]이 지정되지 않았다면,
+'textwidth' 값이 쓰입니다. (만약 'textwidth'도 0이면, 기본값인 80이
+사용됩니다.)
+ 예를 들어: >
+
+ :1,5center 40
+
+명령을 수행하면 다음과 같이 됩니다:
+
+ 나는 한 때 가르쳤습니다. ~
+ 한번은 내가 낸 숙제가 너무 ~
+ 어려워서 포트워스 경찰에게 ~
+ 제지당한 적도 있었습니다. ~
+ 진짜입니다. ~
+
+
+우측 정렬
+
+앞에서와 유사하게, ":right" 명령으로 문서를 우측 정렬할 수 있습니다: >
+
+ :1,5right 37
+
+다음과 같이 됩니다:
+
+ 나는 한 때 가르쳤습니다. ~
+ 한번은 내가 낸 숙제가 너무 ~
+ 어려워서 포트워스 경찰에게 ~
+ 제지당한 적도 있었습니다. ~
+ 진짜입니다. ~
+
+좌측 정렬
+
+마지막으로 다음 명령도 있습니다: >
+
+ :{범위}left [여백]
+
+하지만 ":center"나 ":right"와는 다르게, ":left"에는 줄의 폭을 지정하지
+않습니다. 대신, 왼쪽 여백을 지정합니다. 생략될 경우, 문서 내용이 화면 왼편에
+붙게 됩니다 (즉, 크기 0의 여백을 지정하는 것과 같습니다). 여백이 5라면, 문서
+내용이 다섯 칸 들여쓰기 됩니다. 예를 들어 다음 명령을 사용하십시오: >
+
+ :1left 5
+ :2,5left
+
+결과는 다음과 같습니다:
+
+ 나는 한 때 가르쳤습니다. ~
+ 한번은 내가 낸 숙제가 너무 ~
+ 어려워서 포트워스 경찰에게 ~
+ 제지당한 적도 있었습니다. ~
+ 진짜입니다. ~
+
+
+양쪽 맞춤
+
+빔 내부에는 양쪽 맞춤 기능이 없습니다. 하지만, 깔끔한 양쪽 맞춤 매크로
+패키지가 함께 제공됩니다 . 이 매크로를 사용하려면, 다음 명령을 사용하십시오:
+>
+
+ :runtime macros/justify.vim
+
+이 빔 스크립트 파일에는 새로운 가시 상태 명령인 "_j"가 정의되어있습니다. 문서
+내용 일부의 양쪽을 맞추려면, 가시 상태에서 영역을 선택한 후 "_j" 명령을
+실행하십시오.
+ 더 자세한 설명은 스크립트 파일을 참고하십시오. 이 파일을 보려면 다음
+파일명에 "gf" 명령을 사용하십시오:
+$VIMRUNTIME/macros/justify.vim.
+
+아니면, 외부 프로그램을 사용해서 문서 형식을 맞출 수도 있습니다. 예를 들어
+다음과 같이 하면 됩니다: >
+
+ :%!fmt
+
+==============================================================================
+*25.3* 들여쓰기와 탭
+
+들여쓰기는 문서 내용을 돋보이게 하기 위해 사용됩니다. 예를 들어, 이 문서에
+있는 예제들은 모두 여덟 개의 공백이나 탭으로 들여쓰기 되어있습니다. 각 줄을
+시작할 때 탭을 입력해서 들여쓰기를 할 수 있습니다. 다음 예를 보겠습니다:
+ 첫 번째 줄 ~
+ 두 번째 줄 ~
+
+위 예는 탭을 입력하고, 내용과 <Enter>를 입력하고, 또 탭과 내용을 입력한
+것입니다.
+ 'autoindent'(자동들여쓰기) 설정을 켜면 들여쓰기를 자동으로 넣어줍니다: >
+
+ :set autoindent
+
+새로운 줄이 나타날 때 자동으로 앞의 줄과 같은 들여쓰기가 됩니다. 앞의
+예에서라면, <Enter> 다음에 탭을 입력할 필요가 없어집니다.
+
+
+더 많이 들여 쓰기
+
+더 많이 들여 쓰려면, ">" 연산자를 사용하십시오. 보통은 현재 줄을 더 들여 쓰는
+명령인 ">>" 형태로 사용됩니다.
+ 더 들여 쓰여지는 정도는 'shiftwidth'(들여쓰기폭) 설정으로 지정됩니다.
+기본 값은 8입니다. 예를 들어 ">>" 명령으로 네 칸만 들여 쓰여지게 하려면, 다음
+명령을 사용하십시오: >
+
+ :set shiftwidth=4
+
+위 예에서 두 번째 줄에 ">>" 명령을 사용하면 다음과 같이 됩니다:
+
+ 첫 번째 줄 ~
+ 두 번째 줄 ~
+
+"4>>" 명령은 현재 줄을 포함하여 아래로 네 줄을 함께 더 들여 씁니다.
+
+
+탭
+
+4의 배수로 들여쓰기를 하려면, 'shiftwidth'를 4로 설정하면 됩니다. 하지만 탭을
+누르면 8칸씩 들여쓰기가 됩니다. 이 들여쓰기 정도를 바꾸려면,
+'softtabstop'(소프트탭크기) 설정을 변경하면 됩니다: >
+
+ :set softtabstop=4
+
+이제 <Tab> 키를 누르면 네 칸씩 들여쓰기가 됩니다. 만약 이미 앞에 공백이 네 칸
+있다면, 공백이 사라지고 탭 문자가 대신 삽입됩니다 (파일 크기에서 일곱
+글자만큼을 절약할 수 있습니다). (만약 탭 문자를 사용하지 않고, 언제나
+스페이스로만 들여쓰기를 하려면, 'expandtab'(탭확장) 설정을 사용하십시오.)
+
+ Note:
+ 'tabstop'을 4로 설정할 수도 있습니다. 하지만, 나중에 'tabstop'을 기본
+ 값인 8로 놓고 파일을 다시 열면, 모양이 흐트러져보일 것입니다. 또한,
+ 탭 크기가 8칸인 다른 프로그램이나 인쇄를 할 때도 흐트러져 보일
+ 것입니다. 따라서 'tabstop'은 항상 8로 바꾸지 않고 사용하는 것이
+ 좋습니다. 8로 쓰는 것이 표준이기 때문입니다.
+
+
+탭을 바꾸기
+
+탭 크기가 3인 채로 쓰여진 파일을 편집해야한다고 합시다. 기본 탭 크기 값인 8을
+사용해서 보면 이상하게 보일 것입니다. 'tabstop'을 3으로 설정하면 일단은
+제대로 보이겠지만, 이 파일을 편집할 때마다 매번 설정해야하는 불편함이
+있습니다.
+ 빔으로 파일 내 탭 사용형태를 바꿀 수 있습니다. 먼저, 'tabstop' 값을 바꾸어
+화면에 제대로 보이도록 설정합니다. 그리고 ":retab" 명령을 사용하면 됩니다: >
+
+ :set tabstop=3
+ :retab 8
+
+":retab" 명령은 'tabstop'을 8로 바꾸고, 그러면서도 화면에 보이는 모습이 바뀌지
+않도록 문서 내용을 적절히 바꿉니다. 공백들을 적절히 탭과 스페이스들로 바꾸는
+것입니다. 이제 파일을 저장하면, 다음에 파일을 열 때는 설정을 바꾸지 않아도
+제대로 보일 것입니다.
+ 주의: 프로그램 코드에 ":retab"을 사용하면, 문자열 상수 내의 공백도 바꿔버릴
+수 있습니다. 프로그램 코드에서는 진짜 탭 문자 대신 "\t"를 사용하는 습관을
+들입시다.
+
+==============================================================================
+*25.4* 긴 줄 다루기
+
+때때로 화면크기보다 더 폭이 넓은 파일을 편집해야할 때가 있습니다. 이런 때
+빔은 자동으로 긴 줄을 여러 줄로 나누어 화면에 표시합니다.
+ 'wrap' 설정을 끄면 파일의 각 줄이 화면에서도 한 줄로 표시됩니다. 그래서
+화면크기보다 더 긴 줄은 화면 오른쪽으로 벗어나서 보이지 않게 됩니다.
+ 화면을 벗어난 글자로 커서를 움직이면, 글자가 화면에 보이도록 문서가
+스크롤됩니다. 문서 전체 중에서 보이는 부분을 수평방향으로 움직인다고
+생각하시면 됩니다.
+ 기본 설정으로는 GUI에서 수평 스크롤 바를 보여주지 않습니다. 수평 스크롤
+바가 나타나게 하려면, 다음 명령을 사용하십시오: >
+
+ :set guioptions+=b
+
+빔 창 아래쪽에 수평 스크롤 바가 나타날 것입니다.
+
+스크롤 바가 없거나, 있더라도 사용하고 싶지 않을 때는 다음 명령들을 사용하여
+문서를 스크롤 하십시오. 문서 내 커서의 위치는 변하지 않습니다. 단, 화면
+밖으로 벗어나는 경우에는 화면에 보이는 영역으로 옮겨집니다.
+
+ zh 오른쪽으로 스크롤
+ 4zh 오른쪽으로 네 글자 스크롤
+ zH 오른쪽으로 창 폭의 절반만큼 스크롤
+ ze 커서가 화면의 오른쪽 끝에 오도록 오른쪽으로 스크롤
+ zl 왼쪽으로 스크롤
+ 4zl 왼쪽으로 네 글자 스크롤
+ zL 왼쪽으로 창 폭의 절반만큼 스크롤
+ zs 커서가 화면의 왼쪽 끝에 오도록 왼쪽으로 스크롤
+
+다음 한 줄의 예문으로 위 명령들을 사용해보겠습니다. 커서가 다음 문장 중
+"일부만"의 "일"에 있다고 합시다. "현재 창"은 현재 화면에 보이는 영역을
+나타냅니다. 아래에 있는 "창" 부분은 각각 맨 앞에 있는 명령이 실행된 후 보이는
+영역을 나타냅니다.
+
+ |<-- 현재 창 -->|
+ 긴 내용, 화면에는 그 중 일부만 보이는 상황입니다 ~
+ ze |<-- 창 -->|
+ zH |<-- 창 -->|
+ 4zh |<-- 창 -->|
+ zh |<-- 창 -->|
+ zl |<-- 창 -->|
+ 4zl |<-- 창 -->|
+ zL |<-- 창 -->|
+ zs |<-- 창 -->|
+
+
+자동 줄 바꿈을 껐을 때 움직이기
+
+'wrap' 설정을 끄면 문서가 좌우로 스크롤됩니다. 화면에 보이는 내용 안에서만
+움직이려면 다음 명령들을 쓰면 됩니다. 이 명령들은 화면에 보이지 않는 영역의
+내용을 고려하지 않으며, 이로 인해 문서가 스크롤되지 않습니다:
+
+ g0 현재 줄에서 화면에 보이는 첫 번째 문자로
+ g^ 현재 줄에서 화면에 보이는 문자 중 공백이 아닌 첫 번째
+ 문자로
+ gm 현재 줄의 가운데로
+ g$ 현재 줄에서 화면에 보이는 마지막 문자로
+
+ |<-- 창 -->|
+ 긴 내용, 일부만 화면에 표시되는 상황 ~
+ g0 g^ gm g$
+
+
+띄어쓰기 단위로 줄바꾸기 *edit-no-break*
+
+다른 프로그램에서 사용할 문서를 작성하다보면, 문단 내에서 줄을 바꿀 수 없을
+때가 있습니다. 'wrap' 설정을 끄면 현재 쓰고 있는 문장을 한 눈에 모두 볼 수
+없다는 문제가 있습니다. 반대로 'wrap' 설정을 켜면, 줄의 끝에서 단어가 두 줄로
+잘려서 읽기 힘들 때가 있습니다.
+ 이 문제를 해결하려면 'linebreak'(줄바꿈) 설정을 사용하면 됩니다. 그러면
+빔은 화면에 표시할 때 줄에서 적당한 부분을 찾아 줄바꿈을 합니다. 물론 파일
+자체의 내용은 바뀌지 않습니다.
+ 예를 들어 'linebreak' 설정을 끄면 다음과 같이 보입니다:
+
+ +---------------------------------+
+ |중소 은행용 자동 편지 작성 프로그|
+ |램을 만들었습니다. 그들은 그 중>|
+ |에서도 제일 부유한 1000명의 고객>|
+ |에게는 특별한 맞춤 편지를 보내길 |
+ |원했습니다. 프로그래머로서는 불>|
+ +---------------------------------+
+그리고: >
+
+ :set linebreak
+
+위와 같이 설정하면 다음과 같이 보입니다:
+
+ +---------------------------------+
+ |중소 은행용 자동 편지 작성 |
+ |프로그램을 만들었습니다. 그들은 |
+ |그 중에서도 제일 부유한 1000명의 |
+ |고객에게는 특별한 맞춤 편지를 |
+ |보내길 원했습니다. |
+ |프로그래머로서는 불행하게도, |
+ +---------------------------------+
+
+관련된 설정들:
+'breakat'(줄바꿈위치) 설정은 줄을 바꿀 수 있는 문자를 지정합니다.
+'showbreak'(줄바꿈표시) 설정은 문서의 한 줄이 여러 줄로 나뉘어 표시되는 경우
+자동줄바꿈이 된 줄 앞에 보여줄 문자를 지정합니다. 문단이 여러 줄로 나뉘어
+저장되지 않게 하려면 'textwidth'를 0으로 지정하십시오.
+
+
+화면에 보이는 줄 기준으로 움직이기
+
+"j", "k"는 다음이나 이전 줄로 움직이는 명령어입니다. 줄 하나가 매우 긴
+경우에는, 화면에서 여러 줄을 한 번에 움직이게 됩니다.
+ 화면에 보이는 상태를 기준으로 한 줄을 움직이려면, "gj", "gk" 명령어를
+사용하십시오. 한 줄이 화면 상에 한 줄로 표시된 경우에는 "j", "k"와 똑같이
+동작합니다. 하지만 한 줄이 여러 줄로 나뉘어져 표시된 경우에는 화면 상으로 한
+줄만큼 내려오거나 올라갑니다.
+ 키보드의 화살표 키를 눌렀을 때, 화면에 보이는 줄 단위를 기준으로 움직이고
+싶다면 다음 매핑을 사용하면 됩니다: >
+
+ :map <Up> gk
+ :map <Down> gj
+
+
+문단을 한 줄로 모두 붙이기
+
+마이크로소프트 워드 같은 프로그램으로 문서를 옮기려면, 각 문단이 한 줄이
+되도록 해야합니다. 만약 각 문단이 빈 줄로 구분되어있다면, 다음 명령으로 각
+문단을 한 줄로 붙일 수 있습니다: >
+
+ :g/./,/^$/join
+
+조금 복잡해보이는 명령입니다. 조금씩 나누어 차근차근 살펴보도록 하겠습니다:
+
+ :g/./ 문자가 하나라도 있는 모든 줄을 찾는 ":global"
+ 명령입니다.
+ ,/^$/ (빈 줄이 아닌) 현재 줄부터 시작해서 빈 줄까지의 범위를
+ 지정합니다.
+ join ":join" 명령은 지정된 범위의 줄들을 한 줄로 모두
+ 붙입니다.
+
+예를 들어 다음과 같이 30칸의 폭을 갖는 여덟 줄짜리 문서가 있다고 합시다:
+
+ +----------------------------------+
+ |중소 은행용 자동 편지 작성 |
+ |프로그램을 만들었습니다. 그들은 |
+ |특별한 맞춤 편지를 보내길 |
+ |원했습니다. |
+ | |
+ |그 중에서도 제일 부유한 1000명의 |
+ |고객에게. 프로그래머로서는 |
+ |불행하게도, |
+ +----------------------------------+
+
+위 명령을 사용하면 다음과 같이 두 줄로 바뀝니다:
+
+ +----------------------------------+
+ |중소 은행용 자동 편지 작성 프로그>|
+ |램을 만들었습니다. 그들은 특별한 |
+ |맞춤 편지를 보내길 원했습니다. |
+ |그 중에서도 제일 부유한 1000명의 >|
+ |고객에게. 프로그래머로서는 불행하|
+ |게도, |
+ +----------------------------------+
+
+단, 문단을 구분하는 빈 줄이 완전히 비어있지 않고, 스페이스나 탭 같은
+공백문자가 들어있는 경우에는 제대로 동작하지 않습니다. 그런 경우에도 제대로
+동작하게 하려면 다음과 같이 명령을 조금 바꾸면 됩니다:
+>
+ :g/\S/,/^\s*$/join
+
+하지만 이 경우에도, 파일의 맨 마지막에 빈 줄이나 공백만 들어있는 줄이 있어야
+마지막 문단이 한 줄로 모아지는 단점이 있습니다.
+
+==============================================================================
+*25.5* 표 편집하기
+
+네 개의 열을 가진 표를 편집하고 있다고 합시다:
+
+ 착한 표 1번 2번 3번 ~
+ 입력 A 0.534 ~
+ 입력 B 0.913 ~
+
+세 번째 열에 숫자를 입력해야합니다. 두 번째 줄로 가서 "A" 명령을 사용한다음,
+공백들을 입력해서 제 위치에 내용을 입력하면 됩니다.
+ 하지만 다음 설정을 사용하면 더 쉽게 할 수 있습니다: >
+
+ set virtualedit=all
+
+이제 문서 내용이 없는 곳이더라도 자유롭게 커서를 옮길 수 있습니다. 이 영역을
+"가상 영역(virtual space)"라고 합니다. 이 기능을 사용하면 표를 훨씬 쉽게
+편집할 수 있습니다.
+ 마지막 열의 열 제목을 찾아서 커서를 옮깁니다: >
+
+ /3번
+
+이제 "j"를 누르면, "입력 A"의 값을 입력해야하는 위치에 정확히 오게 됩니다.
+여기에 "0.693"을 입력하면 다음과 같이 됩니다:
+
+ 착한 표 1번 2번 3번 ~
+ 입력 A 0.534 0.693 ~
+ 입력 B 0.913 ~
+
+새로운 내용을 입력할 곳의 앞에는 빔이 자동으로 공백을 채워줍니다. 이제 "Bj"를
+입력해서 같은 열의 다음 행으로 움직입니다. "B"는 직전의 띄어쓰기 바로
+다음으로 움직이는 명령입니다. 그리고 "j"로 다음 값이 입력될 곳으로
+움직입니다.
+
+ Note:
+ 화면의 어디로든 커서를 움직일 수 있습니다. 줄의 끝 뒤로도 물론 움직일
+ 수 있습니다. 하지만, 현재 커서 위치까지 공백이 항상 바로바로 생기는
+ 것은 아니고, 그 위치에 문자가 하나라도 입력되는 순간 공백이
+ 삽입됩니다.
+
+
+열 복사하기
+
+세 번째 열을 복사해서 "1번" 열 앞에 새로운 열로 추가하고 싶다고 합시다. 다음
+일곱 단계를 따라하면 됩니다.
+1. 복사할 열의 왼쪽 위로 커서를 옮깁니다. 예를 들어 "/3번" 하면 됩니다.
+2. CTRL-V 로 블록 가시 상태로 들어갑니다.
+3. "2j"로 두 줄 아래로 내려갑니다. 이제 "가상 영역"인 "입력 B"행의 "3번"
+ 열에 위치해있게 됩니다 .
+4. 커서를 오른쪽으로 움직여서, 열 전체 및 열 사이의 구분을 위한 공백을
+ 선택합니다. "9l" 명령을 사용하면 됩니다.
+5. 선택된 영역을 "y"로 복사해 놓습니다.
+6. 커서를 새로운 열이 추가될 위치인 "1번"으로 옮깁니다.
+7. "P" 명령을 입력합니다.
+
+결과는 다음과 같습니다:
+
+ 착한 표 3번 1번 2번 3번 ~
+ 입력 A 0.693 0.534 0.693 ~
+ 입력 B 0.913 ~
+
+"1번" 열 전체가 오른쪽으로 밀려났습니다. "3번" 열의 내용이 없는 행에서도
+마찬가지로 밀려난 것을 볼 수 있습니다.
+
+다음 명령으로 커서가 가상 영역으로 움직이지 않도록 되돌립니다: >
+
+ :set virtualedit=
+
+
+가상 바꾸기 상태
+
+'virtualedit'(가상편집)를 사용할 때의 단점은, 뭔가 "느낌"이 좀 다르다는
+것입니다. 커서를 움직일 때 줄 끝을 넘어가면 탭이나 스페이스를 인식할 수
+없습니다. 이럴 땐 "가상 바꾸기 상태"를 사용할 수도 있습니다.
+ 탭과 다른 문자들이 섞여있는 표의 한 줄이 있다고 합시다. 첫번째 탭에서
+"rx"를 사용합시다:
+
+ inp 0.693 0.534 0.693 ~
+
+ |
+ rx |
+ V
+
+ inpx0.693 0.534 0.693 ~
+
+표 모양이 깨져서 엉망이 됩니다. 이런 상황을 막으려면 "gr" 명령을 쓰면
+됩니다:
+
+ inp 0.693 0.534 0.693 ~
+
+ |
+ grx |
+ V
+
+ inpx 0.693 0.534 0.693 ~
+
+"gr" 명령어를 사용하면, 새로운 문자가 똑같은 화면 영역을 차지하도록 적절히
+조정됩니다. 공백을 메우기 위해 탭과 스페이스가 적절히 삽입되는 것입니다.
+따라서 탭 문자를 "x"로 바꾸면 문서가 뒤틀리지 않도록 공백이 삽입됩니다. 위
+예에서는 탭 문자가 삽입되었습니다.
+ 하나 이상의 문자를 바꿀 때는 보통 "R" 명령을 사용하여 바꾸기 상태로
+들어갑니다(|04.9|를 참고하십시오). 이 명령도 역시 표 모양을 엉망으로 만들고
+엉뚱한 문자를 바꿔버립니다:
+
+ inp 0 0.534 0.693 ~
+
+ |
+ R0.786 |
+ V
+
+ inp 0.78634 0.693 ~
+
+"gR" 명령은 가상 바꾸기 상태를 사용합니다. 이 명령을 사용하면 다음과 같이 표
+모양을 그대로 유지시킬 수 있습니다:
+
+ inp 0 0.534 0.693 ~
+
+ |
+ gR0.786 |
+ V
+
+ inp 0.786 0.534 0.693 ~
+
+==============================================================================
+
+다음 장: |usr_26.txt| 반복하기
+
+저작권: |manual-copyright| 참고 vim:tw=78:ts=8:ft=help:norl:

Added: 7.0/doc/usr_26.kox
==============================================================================
--- (empty file)
+++ 7.0/doc/usr_26.kox Sun May 4 20:17:12 2008
@@ -0,0 +1,222 @@
+*usr_26.txt* Vim version 7.0 대상. 새로고침: 2006 Apr 24
+
+ VIM 사용설명서 - Bram Moolenaar 저
+ 정지용 역
+
+ 반복하기
+
+
+문서 편집을 하다보면 대개 틀에 박힌 작업을 반복하게 마련입니다. 똑같은 내용을
+여러 번 바꿔야하는 경우가 많습니다. 이번 장에서는 변경작업을 쉽게 반복하는
+여러 가지 방법을 살펴보겠습니다.
+
+|26.1| 가시 상태를 이용한 반복
+|26.2| 더하기 빼기
+|26.3| 여러 파일의 내용 바꾸기
+|26.4| 쉘 스크립트에서 빔 사용하기
+
+다음 장: |usr_27.txt| 찾기 명령과 패턴
+이전 장: |usr_25.txt| 형식에 맞추어 편집하기
+ 차례: |usr_toc.txt|
+
+==============================================================================
+*26.1* 가시 상태를 이용한 반복
+
+가시 상태(Visual mode)를 이용하면 여러 줄의 내용을 쉽게 이리저리 바꿀 수
+있습니다. 선택된 영역이 반전되어 표시되므로, 바꿀 영역을 제대로 지정했는 지도
+쉽게 확인할 수 있습니다. 하지만 매번 선택을 하기 위해 키를 많이 눌러야하는
+것이 단점입니다. "gv" 명령은 이전에 선택했던 영역을 다시 선택해줍니다. 같은
+영역에 대해 여러 명령들을 수행해야할 때 유용합니다.
+ 여러 줄에 걸친 내용 중에서 "2001"은 "2002"로, "2000"은 "2001"로 바꾸고
+싶다고 합시다:
+
+ 2001년의 재정 상황은 2000년보다 낫습니다. ~
+ 2000년보다 비가 더 많이 왔음에도 불구하고 ~
+ 수입은 50% 증가했습니다. ~
+ 2000 2001 ~
+ 수입 45,403 66,234 ~
+
+먼저, "2001"을 "2002"로 바꿉시다. 가시 상태에서 영역을 선택해고, 다음 명령을
+사용합니다: >
+
+ :s/2001/2002/g
+
+"gv"로 같은 영역을 다시 선택합니다. 현재 커서가 어디 있는 지는 상관 없습니다.
+그리고 ":s/2000/2001/g" 명령으로 두 번째 변경을 수행합니다.
+ 당연히 다른 명령도 계속해서 반복할 수 있겠지요.
+
+==============================================================================
+*26.2* 더하기 빼기
+
+숫자들을 이 값 저 값으로 바꾸다보면, 일정한 값을 더하거나 일정한 값을 빼는
+경우가 많습니다. 예를 들어, 위에서는 각 연도에 1 씩을 더했습니다. 이 경우
+모든 연도에 대해 일일이 바꾸기 명령을 입력할 필요없이, CTRL-A 명령을 사용하면
+됩니다.
+ 위의 예를 다시 보겠습니다. 먼저 연도를 찾습니다: >
+
+ /19[0-9][0-9]\|20[0-9][0-9]
+
+CTRL-A를 누릅니다. 연도가 1 증가했을 것입니다:
+
+ 2002년의 재정 상황은 2000년보다 낫습니다. ~
+ 2000년보다 비가 더 많이 왔음에도 불구하고 ~
+ 수입은 50% 증가했습니다. ~
+ 2000 2001 ~
+ 수입 45,403 66,234 ~
+
+"n"으로 다음 연도를 찾은 후, "."로 CTRL-A 를 반복합니다 (CTRL-A보다는 "."가
+타이핑하기 약간 더 편하겠지요). "n"과 "."를 모든 연도에 대해 반복하면 됩니다.
+ 힌트: 'hlsearch'(찾기강조) 설정을 켜면 바꾸려는 내용이 화면에 강조되어
+표시되므로, 좀 더 빨리 살펴보고 바꿀 수 있습니다.
+
+1 보다 큰 수를 더하려면 CTRL-A 명령 전에 숫자를 넣으면 됩니다. 다음과 같은
+목록이 있다고 합시다:
+
+ 1. 제 4조 ~
+ 2. 제 5조 ~
+ 3. 제 6조 ~
+
+커서를 "1."로 옮긴 후, 다음 명령을 입력합시다: >
+
+ 3 CTRL-A
+
+"1."이 "4."로 바뀝니다. 다른 숫자들에도 "."를 사용하여 반복해주면 됩니다.
+
+다른 예:
+
+ 006 철수 영희 ~
+ 007 철수 영희 ~
+
+이 숫자들에 대해 CTRL-A 명령을 사용하면 다음과 같이 됩니다:
+
+ 007 철수 영희 ~
+ 010 철수 영희 ~
+
+7에 1을 더했는데 10이라니? 이건 숫자 앞에 붙는 0 때문에 빔이 "007"을 8진법
+숫자로 이해했기 때문에 일어난 일입니다. C 프로그램에서 보통 저런 식으로
+사용하기 때문이지요. 0이 앞에 붙은 숫자를 8진법으로 해석하지 않도록 하려면
+다음 명령을 사용하십시오: >
+
+ :set nrformats-=octal
+
+CTRL-X 는 숫자를 빼는 명령어로, 같은 방법으로 동작합니다.
+
+==============================================================================
+*26.3* 여러 파일의 내용 바꾸기
+
+"x_cnt"라는 변수가 있는데, "x_counter"로 바꾸고 싶다고 합시다. 이 변수가 여러
+C 파일에서 쓰이고 있어 모든 파일에서 바꿔주어야 한다면 어떻게 해야할까요? 한
+번 알아보겠습니다.
+ 먼저 관련된 파일을 모두 인자목록에 넣습니다: >
+
+ :args *.c
+<
+위 명령은 모든 C 파일을 찾아 인자목록에 넣은 후 그 중 첫 번째 파일을 엽니다.
+이제 파일들 모두에 대해 치환 명령을 수행하면 됩니다: >
+
+ :argdo %s/\<x_cnt\>/x_counter/ge | update
+
+":argdo" 명령은 다른 명령 하나를 인자로 받습니다. 이 명령이 현재 인자 목록에
+있는 모든 파일들에 대해 실행됩니다.
+ "%s"는 치환 명령을 파일 전체에 적용하라는 명령입니다. "\<x_cnt\>"로
+"x_cnt"를 찾습니다. 단어 앞뒤의 "\<"와 "\>"는 단어 전체가 일치한 경우에만
+바꾸라는 것입니다. "px_cnt"나 "x_cnt2"같은 단어까지 바뀌는 것을 막기 위한
+것이지요.
+ 치환 명령어 뒤에는 한 줄 안에서도 여러 번 바뀌도록 "g" 를 넣어주었습니다.
+"e"는 파일에 "x_cnt"가 한 번도 나오지 않는 경우 발생하는 에러를 무시하라는
+표시입니다. "e"가 없었다면 "x_cnt"가 한번도 나오지 않는 파일이 있다면 에러를
+내고 처리를 멈추었을 것입니다.
+ "|" 구분자는 두 명령을 연결합니다. "update" 명령은 파일이 변경된 경우에만
+저장하는 명령입니다. 만약 "x_cnt"가 하나도 없어서 "x_counter"로 바뀐 곳이
+없다면 저장이 되지 않습니다.
+
+모든 창에 대해 인자로 받는 명령을 실행하는 ":windo" 라는 명령도 있습니다.
+":bufdo"는 모든 버퍼에 대해 인자로 받는 명령을 실행합니다. 하지만 버퍼에는
+생각지도 못한 파일이 들어있을 수도 있으므로 조심하여 사용하십시오. 버퍼
+목록은 ":buffers"(또는 ":ls")로 확인할 수 있습니다.
+
+==============================================================================
+*26.4* 쉘 스크립트에서 빔 사용하기
+
+수 많은 파일에서 "-이름-"이란 문자열을 "Jones"로 바꾸고, 인쇄해야 한다고
+합시다. 어떻게 해야할까요? 물론 손이 좀 고달프겠지만 일일이 명령을 입력해서
+할 수도 있습니다. 하지만 쉘 스크립트를 작성해서 처리하면 더 쉽겠지요.
+ 화면을 보면서 작업 하는 경우, 빔의 보통 상태 명령들은 매우 뛰어납니다.
+하지만 일괄작업(batch processing)의 경우에는 보통 상태 명령들이 그다지
+명확하고 깔끔하지 않습니다. 이 때는 Ex 상태 명령어를 써야합니다. Ex
+상태에서는 일괄 작업 파일에 넣기 쉬운 명령줄 인터페이스를 사용할 수 있습니다.
+("Ex 명령"은 명령줄(:) 명령의 다른 이름입니다.)
+ 앞서 든 예에서 필요한 Ex 상태 명령어는 다음과 같습니다: >
+
+ %s/-이름-/Jones/g
+ write tempfile
+ quit
+
+이 명령들을 "change.vim"이란 파일에 저장합시다. 이제 빔으로 일괄작업을
+수행하려면 다음 쉘 스크립트를 사용하면 됩니다: >
+
+ for file in *.txt; do
+ vim -e -s $file < change.vim
+ lpr -r tempfile
+ done
+
+for와 done은 쉘 스크립트에서 둘 사이에 있는 작업을 반복하기 위한 것입니다.
+둘 사이의 작업이 수행될 때, $file 변수에는 매번 다른 파일명이 들어갑니다.
+ 두 번째 줄은 빔을 $file 파일에 대해 Ex 상태로 실행시키고(-e 인자),
+"change.vim"파일의 내용을 읽어들여 명령을 수행합니다. "-s" 인자는
+조용한(silent) 상태로 실행되도록 지시합니다. 즉, ":" 같은 프롬프트를 출력하지
+말라는 의미입니다.
+ "lpr -r tempfile" 명령은 앞 줄의 결과인 "tempfile"을 인쇄한 후,
+삭제합니다(-r 인자의 기능입니다).
+
+
+표준 입력으로부터 읽기
+
+빔은 문서를 표준 입력으로부터 읽어들일 수도 있습니다. 원래 표준 입력으로부터
+읽는 내용은 명령으로 해석되므로, 대신 문서를 읽어들이라고 지정을 해주어야
+합니다. 다음과 같이 파일명이 들어갈 위치에 "-" 인자를 넣어주면 됩니다: >
+
+ ls | vim -
+
+위 명령으로 "ls" 명령의 결과를 다른 파일에 저장할 필요 없이 바로 편집할 수
+있습니다.
+ 표준 입력에서 문서를 읽어들이는 경우, 명령 스크립트 파일을 불러오기
+위해서는 "-S" 인자를 사용하면 됩니다: >
+
+ producer | vim -S change.vim -
+
+
+보통 상태 스크립트
+
+스크립트에서 보통 상태 명령을 사용하고 싶다면, 다음과 같이 하면 됩니다: >
+
+ vim -s script file.txt ...
+<
+ Note:
+ "-s"는 "-e" 와 함께 쓰이지 않으면 다른 의미를 갖게 됩니다. 여기서는
+ "script" 파일을 보통 상태 명령으로 읽어들이라는 의미입니다. "-e"와
+ 함께 쓰이는 경우에는 조용한 상태로 사용하라는 의미가 되고, 뒤에
+ 파일명이 오지 않습니다.
+
+"script" 파일 안의 명령들이 마치 직접 타이핑한 것 처럼 수행됩니다. 파일 내의
+줄바꿈은 <Enter>를 누른 것으로 해석됩니다. 보통 상태에서는 커서를 다음 줄로
+옮기는 명령이지요.
+ 스크립트를 만들기 위해서는 빈 파일을 열고 직접 명령을 써넣을 수도
+있겠습니다만, 그러려면 문서가 어떻게 처리되는지 일일이 머리로 계산해가며
+만들어야합니다. 골치아픈 일이지요. 그래서 빔은 수행하는 명령을 기록하는
+기능을 제공합니다. 다음과 같이 하면 됩니다: >
+
+ vim -w script file.txt ...
+
+입력한 모든 명령이 "script"안에 저장됩니다. 키를 몇 개 잘못 누른 게 있더라도
+일단은 계속한 다음, 나중에 스크립트 파일을 열어서 조금 고쳐주면 되겠지요.
+ "-w" 인자는 이미 존재하는 스크립트에 명령들을 덧붙입니다. 따라서 조금씩
+조금씩 기록해나갈 때 편리합니다. 만약 이미 저장되어있는 내용을 지우고
+처음부터 기록하고 싶다면, "-W" 를 사용하십시오. 이미 존재하는 파일의 내용이
+지워지고 새로 기록됩니다.
+
+==============================================================================
+
+다음 장: |usr_27.txt| 찾기 명령과 패턴
+
+저작권: |manual-copyright| 참고 vim:tw=78:ts=8:ft=help:norl:

Added: 7.0/doc/usr_27.kox
==============================================================================
--- (empty file)
+++ 7.0/doc/usr_27.kox Sun May 4 20:17:12 2008
@@ -0,0 +1,570 @@
+*usr_27.txt* Vim version 7.0 대상. 새로고침: 2006 Apr 24
+
+ VIM 사용설명서 - Bram Moolenaar 저
+ 정지용 역
+
+ 찾기 명령과 패턴
+
+
+3장에서는 몇 가지 간단한 찾기 패턴을 살펴보았습니다 |03.9|. 하지만 훨씬 더
+복잡한 찾기도 할 수 있습니다. 이번 장에서는 가장 자주 사용되는 것들을
+살펴보도록 하겠습니다. 더 자세한 세부사항은 |pattern|을 참조하십시오.
+
+|27.1| 대소문자 무시하기
+|27.2| 파일의 끝에서 처음으로 넘어가기
+|27.3| 오프셋(Offset)
+|27.4| 반복되는 문자열
+|27.5| 여럿 중 하나
+|27.6| 문자 범위
+|27.7| 문자 종류
+|27.8| 줄 바꿈 찾기
+|27.9| 예제
+
+다음 장: |usr_28.txt| 접기
+이전 장: |usr_26.txt| 반복하기
+ 차례: |usr_toc.txt|
+
+==============================================================================
+*27.1* 대소문자 무시하기
+
+기본 설정인 경우, 빔의 검색은 대소문자를 구별합니다. 따라서 "include"와
+"INCLUDE", "Include"는 모두 다른 단어입니다.
+ 이제 'ignorecase'(대소문자무시) 설정을 켜봅시다: >
+
+ :set ignorecase
+
+"include"를 다시 찾아봅시다. 이제 "Include", "INCLUDE", "InClUDe"를 모두 찾을
+수 있습니다. (어느 부분이 패턴과 일치하는 지 빠르게 확인하려면
+'hlsearch'(찾기강조) 설정을 켜십시오.)
+ 다음 명령으로 다시 설정을 끌 수 있습니다: >
+
+ :set noignorecase
+
+일단 설정을 끄지는 말고, "INCLUDE"로 찾아봅시다. "include"와 마찬가지로
+대소문자 구별없이 모두 찾을 것입니다. 이제 'smartcase'(자동대소문자) 설정을
+켜봅시다: >
+
+ :set ignorecase smartcase
+
+패턴에 한 글자라도 대문자가 있으면, 대소문자를 구별하여 찾습니다. 그러니까,
+필요도 없는데 괜히 대문자를 입력하지는 않았을 테고, 대문자인 것을 찾기 원했기
+때문에 그렇게 입력했을 거라고 추측하는 것입니다. 영리(smart)하지 않습니까!
+ 이 두 설정을 켜면, 찾기 결과는 다음과 같습니다:
+
+ 패턴 결과 ~
+ word word, Word, WORD, WoRd 등
+ Word Word
+ WORD WORD
+ WoRd WoRd
+
+
+잠깐 대소문자 구별 바꾸기
+
+딱 한 패턴에서만 대소문자를 구별하지 않고 찾고 싶다면, 패턴 앞에 "\c"를 붙이면
+됩니다. 반대로 "\C"를 앞에 붙이면 대소문자까지 일치하는 것만 찾게 됩니다.
+"\c"나 "\C"가 패턴 앞에 붙으면 'ignorecase'와 'smartcase' 설정은 무시됩니다.
+
+ 패턴 결과 ~
+ \Cword word
+ \CWord Word
+ \cword word, Word, WORD, WoRd 등
+ \cWord word, Word, WORD, WoRd 등
+
+"\c"나 "\C"를 쓸 때의 장점은 패턴에 대소문자 구별 정보가 함께 따라다닌다는
+것입니다. 따라서 찾기 히스토리에서 패턴을 가져와서 다시 사용할 때, 항상 같은
+문자열들을 찾을 수 있습니다. 'ignorecase'나 'smartcase' 설정이 바뀌었더라도
+말이지요.
+
+ Note:
+ 찾기 패턴에서 "\"의 의미는 'magic'(매직) 설정에 따라 달라집니다.
+ 이 장에서는 'magic' 설정이 켜져 있다고 가정합니다. 켜는 것이
+ 일반적이기도 하고, 추천하는 설정입니다. 'magic' 설정을 바꾼다면, 많은
+ 찾기 패턴이 동작하지 않게 될 것입니다.
+
+ Note:
+ 예상보다 찾는 데 시간이 더 걸린다면, 유닉스에서는 CTRL-C로, MS-DOS나
+ MS-윈도우에서는 CTRL-Break로 멈출 수 있습니다.
+
+==============================================================================
+*27.2* 파일의 끝에서 처음으로 넘어가기
+
+기본 설정인 경우, 주어진 문자열을 아래쪽으로 가면서 찾는 경우는 현재 커서의
+위치부터 찾게 됩니다. 파일의 끝까지 먼저 찾은 다음, 그때까지 찾은 것이
+없다면, 문서의 처음으로 넘어갑니다. 파일의 처음부터 현재 커서 위치까지를
+계속해서 찾습니다.
+ "n" 명령으로 찾기를 계속 반복하는 경우, 맨 처음 찾은 결과로 돌아오게 된다는
+것을 기억하십시오. 아무 생각 없이 "n"만 누르다보면 똑같은 결과만 계속 보면서
+끝없이 찾을 수도 있습니다. 파일이 끝났음을 알려주기 위해 빔에서는 다음
+메시지를 보여줍니다:
+
+ 끝까지 찾았음, 처음부터 계속 ~
+
+"?" 명령을 쓰면, 반대방향(문서의 처음 방향)으로 가면서 찾을 수 있습니다. 이
+때는 다음 메시지를 볼 수 있습니다:
+
+ 처음까지 찾았음, 끝에서 계속 ~
+
+아직도 맨 처음 찾은 결과로 돌아왔는 지 잘 모르겠다면, 'ruler'(자) 설정을 켜서
+확인할 수도 있습니다: >
+
+ :set ruler
+
+창의 오른쪽 아래 구석에 (상태표시줄이 있다면 상태표시줄 안에) 현재 커서의
+위치가 표시됩니다. 다음과 같이 생겼습니다:
+
+ 101,29 84% ~
+
+첫 번째 숫자가 커서의 줄번호입니다. 찾기를 시작할 때의 줄번호를 기억하면 이
+위치를 지나간 적이 있는 지 확인할 수 있습니다.
+
+
+파일의 끝을 넘어가지 않기
+
+파일의 끝에서 처음으로 넘어가지 않게 하려면 다음 명령을 사용하십시오: >
+
+ :set nowrapscan
+
+이제는 찾다가 파일의 끝에 도달한 경우 다음과 같은 에러 메시지가 나옵니다:
+
+ E385: 끝까지 맞는 문자열이 없습니다: 영원히 ~
+
+따라서 "gg" 명령으로 파일의 처음으로 간 다음, 이 메시지를 볼 때까지 계속
+찾으면 됩니다.
+ "?"를 써서 반대방향으로 찾을 때는 다음 메시지가 나옵니다:
+
+ E384: 처음까지 맞는 문자열이 없습니다: 영원히 ~
+
+==============================================================================
+*27.3* 오프셋(Offset)
+
+기본 설정인 경우, 찾기를 하면 패턴과 일치하는 문자열이 시작하는 곳에 커서가
+옵니다. 오프셋을 지정하면 커서가 다른 곳에 위치하도록 할 수 있습니다.
+아래쪽으로 가면서 찾는 명령인 "/"는 패턴 뒤에 슬래시(/)와 오프셋 값을 지정하면
+됩니다: >
+
+ /기본/2
+
+위 명령은 "기본" 패턴을 찾은 다음, 패턴에서 두 줄 아래 줄의 시작지점으로
+커서를 이동시킵니다. 이 명령을 위 문단에 사용하면, 빔은 첫 번째 줄의 "기본"을
+찾습니다. 그리고 커서가 두 줄 아래로 내려와서 "아래쪽으로" 위치에 옵니다.
+
+오프셋이 그냥 숫자이면, 찾은 곳에서 지정한 숫자만큼 아래 줄 첫 번째 글자에
+커서가 옵니다. 오프셋은 양수이거나 음수일 수 있습니다. 양수이면 커서가
+지정한 수만큼 아래로 내려오고, 음수이면 올라갑니다.
+
+
+문자 오프셋
+
+"e" 오프셋은 찾은 문자열의 끝을 기준으로 한다는 의미입니다. 즉, 찾은 문자열의
+맨 마지막 문자에 커서가 옵니다. 다음 명령을 봅시다: >
+
+ /홍길동/e
+
+위 명령은 커서를 "홍길동"의 "동"에 오도록 합니다.
+ 이 위치에서, 숫자를 더하면, 그 숫자만큼 몇 문자 앞으로 이동합니다. 예를
+들어 다음 명령은 찾은 문자열 바로 다음으로 커서를 옮깁니다: >
+
+ /홍길동/e+1
+
+양수는 커서를 오른쪽으로 옮기고, 음수는 커서를 왼쪽으로 옮깁니다. 예를 들어:
+>
+
+ /홍길동/e-1
+
+위 명령은 커서를 "홍길동"의 "길"로 옮깁니다.
+
+오프셋이 "b"로 시작하면, 커서가 패턴의 시작 위치로 움직입니다. "b"를 붙이지
+않아도 어차피 시작위치로 움직이므로 이것만으로는 쓸 데가 없습니다. 하지만
+여기에 숫자가 더해지거나 빼질 때는 그 숫자만큼 커서가 앞으로 가거나 뒤로
+옵니다. 예를 들어: >
+
+ /홍길동/b+2
+
+위 명령은 커서를 찾은 문자열의 시작 위치로 옮긴다음, 두 문자만큼 오른쪽으로
+움직입니다. 그래서 "동"에 커서가 옵니다.
+
+
+반복
+
+앞에서 사용한 찾기 패턴을 다시 사용하면서, 오프셋만 다르게 하고 싶다면, 패턴
+부분을 빼놓고 쓰면 됩니다: >
+
+ /that
+ //e
+
+위 예는 다음과 똑같습니다: >
+
+ /that/e
+
+같은 오프셋으로 반복하려면: >
+
+ /
+
+물론 "n"도 같은 결과를 보입니다. 앞에서 사용한 패턴으로 찾으면서 오프셋만
+없애고 싶다면: >
+
+ //
+
+
+파일의 앞쪽으로 가면서 찾기
+
+"?" 명령에서도 같은 방식으로 오프셋을 사용할 수 있습니다. 이번에는 패턴과
+오프셋 사이에 "/"가 아니라 "?"를 넣어서 구분해 줍니다: >
+
+ ?홍길동?e-2
+
+"b"와 "e"의 의미는 "?" 때문에 찾는 방향이 바뀌더라도 전과 마찬가지입니다.
+
+
+시작 위치
+
+찾기는 일반적으로 현재 커서 위치에서 시작합니다. 그런데 몇 줄을 이동하도록
+했을 때 문제가 되는 경우가 있습니다. 예를 들어: >
+
+ /홍길동/-2
+
+위 명령은 "홍길동"이란 단어를 찾은 다음, 두 줄 위로 올라갑니다. 이 상황에서
+또 "n"을 누르면, 빔은 현재 위치에서 찾기 시작하고 금방 찾은 "홍길동"을 다시
+찾습니다. 그리고 다시 오프셋에 따라 두 줄 위로 올라가고 결국 방금의 위치로
+되돌아오게 됩니다. 결과적으로 아무리 "n"을 눌러도 움직이지 않게 되지요.
+ 더 꼬이는 경우도 있습니다: "홍길동"이란 단어가 현재 커서의 다음 줄에 있다고
+해봅시다. 찾기를 하면 다음 줄에서 "홍길동"을 찾은 후, 두 줄 위로 올라가게
+되고 결과적으로는 한 줄 거꾸로 가게 됩니다.
+
+반면, 문자단위 오프셋을 사용하는 경우("b"나 "e"로)는 빔이 알아서 처리해줍니다.
+찾기를 현재 위치 몇 글자 앞이나 뒤에서 시작함으로써, 같은 문자열에서 빙빙 도는
+것을 막아줍니다.
+
+==============================================================================
+*27.4* 반복되는 문자열
+
+"*"은 바로 앞에 나오는 것이 몇 번이든 나와도 된다는 의미입니다.
+따라서: >
+
+ /a*
+
+는 "a", "aa", "aaa" 등에 모두 대응(match)됩니다. 그리고 "" (빈 문자열)에도
+대응됩니다. "*"의 "몇 번"에는 0번도 포함되기 때문입니다.
+ "*"는 바로 앞에 있는 것에만 적용됩니다. 따라서 "ab*"로는 "a", "ab", "abb",
+"abbb" 등을 찾을 수 있습니다. 문자열 전체를 여러 번 반복하려면, 문자열이
+하나의 그룹으로 묶여야합니다. 그룹으로 묶는 것은 앞에 "\("를, 뒤에 "\)"를
+넣으면 됩니다. 다음 명령을 봅시다: >
+
+ /\(ab\)*
+
+위 명령에는 "ab", "abab", "ababab" 등이 대응됩니다. 물론 ""도 대응됩니다.
+
+빈 문자열이 대응되는 것을 막으려면, "\+"를 사용하십시오. 바로 앞에 나오는
+것이 한 번 이상 반복된다는 의미입니다. >
+
+ /ab\+
+
+는 "ab", "abb", "abbb" 등에 대응됩니다. 하지만 뒤에 "b"가 오지 않는 "a"에는
+대응되지 않습니다.
+
+있어도 없어도 상관없는 것은 "\="를 사용하십시오. 예제: >
+
+ /folders\=
+
+위 패턴은 "folder"와 "folders"에 대응됩니다.
+
+
+특정 횟수
+
+특정 횟수만큼 반복되는 것을 나타내려면 "\{n,m}" 형태를 사용하십시오. "n"과
+"m"에는 숫자를 넣으시면 됩니다. 바로 앞에 나오는 것이 "n"에서 "m" 번 반복되는
+것이 대응됩니다. ("n"번과 "m"번인 것도 포함됩니다 |inclusive|)
+예제: >
+
+ /ab\{3,5}
+
+는 "abbb", "abbbb", "abbbbb"에 대응됩니다.
+ "n"이 생략되면, 0이 지정된 것으로 간주합니다. "m"이 생략되면 무한히 큰 값이
+지정된 것으로 간주합니다. ",m"이 생략되면, 정확히 "n"번 반복된 것만 찾습니다.
+예제:
+
+ 패턴 반복 횟수 ~
+ \{,4} 0, 1, 2, 3, 4
+ \{3,} 3, 4, 5, 등
+ \{0,1} 0 또는 1, \=와 동일
+ \{0,} 0 이상, *와 동일
+ \{1,} 1 이상, \+와 동일
+ \{3} 3
+
+
+최소한만 대응되도록 하기
+
+지금까지 말한 것들은 최대한 길게 대응되는 문자열을 찾습니다. 하지만 반대로
+최소한의 문자열만 대응되도록 하고 싶다면 "\{-n,m}"을 사용하십시오. 이 명령은
+최소한의 문자열만 대응된다는 점만 빼면, "\{n,m}"과 동일하게 동작합니다.
+ 예를 들어, 다음 명령은: >
+
+ /ab\{-1,3}
+
+"abbb"가 있으면 "ab"에만 대응됩니다. 사실, 위 패턴은 딱 하나의 b에만
+대응됩니다. 최소한만 대응시키므로 그 이상을 찾을 필요가 없기 때문입니다.
+제한 값 이상을 대응시키려면 무언가가 더 필요합니다.
+ 앞에서 설명한 "n"과 "m"을 생략하는 규칙도 동일하게 적용됩니다. 심지어는
+"n"과 "m"을 모두 생략하고 "\{-}"을 쓸 수도 있습니다. 이 패턴은 바로 앞의 것을
+0번 이상 반복한 것에 대응되는데, 최소한에만 대응됩니다. 이 패턴 자체만으로는
+항상 0번에 대응될 수 밖에 없습니다. 그래서 다른 패턴과 함께 사용되어야
+유용합니다. 다음 예를 봅시다: >
+
+ /a.\{-}b
+
+위 패턴은 "axbxb"란 문자열 안에서 "axb"에만 대응됩니다. 만약: >
+
+ /a.*b
+
+와 같은 패턴을 사용했다면, ".*"로 찾을 수 있는 최대한 긴 패턴을 찾으므로
+"axbxb" 전체가 대응되었을 것입니다.
+
+==============================================================================
+*27.5* 여럿 중 하나
+
+패턴에서 "또는"에 해당하는 것은 "\|"입니다. 예제: >
+
+ /이거\|저거
+
+위 패턴은 "이거" 또는 "저거"에 대응됩니다. 더 많은 후보를 지정할 수도
+있습니다: >
+
+ /하나\|둘\|셋
+
+은 "하나"나 "둘", "셋"에 대응됩니다.
+ 여러 번 반복되는 것을 찾으려면, 전체를 "\(", "\)" 사이에 넣어야 합니다: >
+
+ /\(이거\|저거\)\+
+
+는 "이거", "이거저거", "이거이거", "저거이거저거" 등에 대응됩니다.
+ 다른 예: >
+
+ /end\(if\|while\|for\)
+
+는 "endif", "endwhile", "endfor"에 대응됩니다.
+
+좀 더 살펴보자면, "\&"도 있습니다. 이 것은 한 위치에서 여러 패턴이 모두
+대응되어야 한다는 것입니다. 대응되는 범위는 마지막 패턴에 따라 결정됩니다.
+예제: >
+
+ /forever\&...
+
+위 패턴은 "forever"의 "for"에 대응됩니다. 하지만 예를 들어 "fortuin"의
+"for"에는 대응되지 않습니다.
+
+==============================================================================
+*27.6* 문자 범위
+
+"a"나 "b", "c"를 찾으려면, "/a\|b\|c"를 쓰면 됩니다. 하지만 "a"부터 "z"까지를
+모두 나열할 일이 있다면, 짜증이 좀 나겠지요. 하지만 다음과 같이 줄여쓸 수
+있습니다: >
+
+ /[a-z]
+
+[]안의 내용은 하나의 문자에 대응됩니다. 괄호 안에 대응시킬 문자들을 넣으면
+됩니다. 다음과 같이 여러 문자들을 넣을 수도 있습니다: >
+
+ /[0123456789abcdef]
+
+위 패턴에는 괄호 안에 있는 문자들 중 어느 것이나 다 대응됩니다. 이어져있는
+문자들은 범위로 지정할 수도 있습니다. "0-3"은 "0123"과 같고, "w-z"는 "wxyz"와
+같습니다. 따라서 위 패턴은 다음과 같이 고쳐쓸 수 있습니다: >
+
+ /[0-9a-f]
+
+"-"문자 자체를 찾기 위해서는 괄호 안의 맨 앞이나 맨 뒤에 넣으면 됩니다. 다음
+특수 기호들을 써서 [] 안에 특수문자를 더 쉽게 넣을 수 있습니다(사실 이
+기호들은 패턴 어디에서든지 쓸 수 있습니다):
+
+ \e <Esc>
+ \t <Tab>
+ \r <CR>
+ \b <BS>
+
+[] 범위 지정에는 몇 가지 특수 기능이 더 있습니다. 자세한 설명은 |/[]|를
+참고하십시오.
+
+
+뺄 것을 지정하기
+
+어떤 문자가 대응되는 것을 막으려면, 범위의 앞에 "^"를 사용하십시오. []은 해당
+문자를 제외한 모든 문자에 대응됩니다. 예제: >
+
+ /"[^"]*"
+<
+ " 따옴표
+ [^"] 따옴표가 아닌 모든 문자
+ * 최대한 많이
+ " 따옴표
+
+위 패턴은 따옴표까지 포함하여 "거시기" 나 "3!x" 등에 대응됩니다.
+
+
+많이 쓰이는 문자 범위
+
+몇 가지 문자 범위는 굉장히 자주 쓰입니다. 자주 쓰이는 문자 범위를 좀 더 쉽게
+쓸 수 있도록 빔에는 몇 가지 단축표현이 있습니다.
+예를 들어: >
+
+ /\a
+
+는 알파벳 문자를 찾습니다. 위 패턴은 "/[a-zA-Z]"와 동일합니다. 몇 가지 더
+살펴봅시다:
+
+ 단축표현 결과 동일한 표현 ~
+ \d 숫자(digit) [0-9]
+ \D 숫자가 아님 [^0-9]
+ \x 16진수 숫자 [0-9a-fA-F]
+ \X 16진수 숫자가 아님 [^0-9a-fA-F]
+ \s 공백(space) [ ] (<Tab>과 <Space>)
+ \S 공백이 아님 [^ ] (<Tab>과 <Space>이 아님)
+ \l 소문자(lowercase) [a-z]
+ \L 소문자가 아님 [^a-z]
+ \u 대문자(uppercase) [A-Z]
+ \U 대문자가 아님 [^A-Z]
+
+ Note:
+ 이 짧은 표현을 사용하면 직접 문자범위를 입력하는 것보다 훨씬 편합니다.
+ 하지만 이것들은 [] 안에서 쓸 수 없습니다. 즉, "[\d\l]"은 숫자나
+ 소문자가 아닙니다! "\(\d\|\l\)"을 사용하십시오.
+
+단축 표현 전체 목록은 |/\s|에서 볼 수 있습니다.
+
+==============================================================================
+*27.7* 문자 종류
+
+문자 범위 기능을 써서 일정 종류의 문자들을 찾을 수 있습니다. 문자
+종류(character class) 기능도 유사한 역할을 하지만, 결정적인 차이가 있습니다:
+패턴을 바꾸지 않으면서 사용 환경에 따라 문자 종류를 재정의할 수 있다는
+것입니다.
+ 예를 들어 다음 패턴을 봅시다: >
+
+ /\f\+
+
+"\f" 는 파일명 문자를 의미합니다. 따라서 위 패턴은 파일명으로 쓰일 수 있는
+문자열에 대응됩니다.
+ 하지만 어떤 문자가 파일명에 쓰일 수 있는 지 여부는 사용하는 시스템에 따라
+다릅니다. MS-윈도우에서는 경로에 백슬래시가 쓰이지만, 유닉스에서는 쓰이지
+않습니다. 이 문자는 'isfname'(파일명여부) 설정으로 지정됩니다. 유닉스에서의
+기본 값은: >
+
+ :set isfname
+ isfname=@,48-57,/,.,-,_,+,,,#,$,%,~,=
+
+하지만 다른 시스템에서는 기본값이 다릅니다. 따라서 "\f"로 파일명을 찾는
+패턴을 만들 수 있고, 사용 중인 시스템의 종류에 따라 자동으로 패턴이
+조정됩니다.
+
+ Note:
+ 사실, 유닉스에서는 공백을 포함하여 거의 모든 문자를 파일명에 쓸 수
+ 있습니다. 이론적으로는 이런 문자들도 'isfname'에 포함시키는 것이 맞을
+ 것입니다. 하지만 그러면 문서에서 파일명의 끝을 찾는 것이 사실상
+ 불가능합니다. 그래서 'isfname'의 값을 많이 쓰이는 문자들로 적당히
+ 한정하였습니다.
+
+문자 종류들은 다음과 같습니다:
+
+ 문자 종류 결과 관련 설정 ~
+ \i 이름 문자 'isident'(이름여부)
+ \I \i와 같으나 숫자 제외
+ \k 키워드 문자 'iskeyword'(키워드여부)
+ \K \k와 같으나 숫자 제외
+ \p 출력 가능한 문자 'isprint'(출력가능여부)
+ \P \p와 같으나 숫자 제외
+ \f 파일명 문자 'isfname'
+ \F \f와 같으나 숫자 제외
+
+==============================================================================
+*27.8* 줄 바꿈 찾기
+
+줄 바꿈을 포함한 패턴으로 찾을 수도 있습니다. 지금까지 살펴본 것들에는
+줄 바꿈을 지정하는 것이 없었고, 어디서 줄이 바뀌는 지는 따로 지정해야합니다.
+ 특정 위치에 줄 바꿈이 있다고 지정하려면 "\n"을 사용하십시오: >
+
+ /단어\n정보
+
+위 패턴은 "단어"로 줄이 끝나고, 다음 줄이 "정보"로 시작하는 경우에 대응됩니다.
+"단어 정보"도 찾으려면, 두 단어 사이에서 공백이나 줄 바꿈을 찾으면 됩니다. 이
+때는 "\_s"를 쓰면 됩니다: >
+
+ /단어\_s정보
+
+공백이 여러 개 나오는 경우도 찾으려면: >
+
+ /단어\_s\+정보
+
+위 패턴으로 "단어 "로 줄이 끝나고, 그 다음 줄이 " 정보"로 시작하는 경우도
+찾을 수 있습니다.
+
+"\s"는 공백에 대응되고, "\_s"는 공백이나 줄 바꿈에 대응됩니다. 비슷하게
+"\a"는 알파벳 문자에 대응되고, "\_a"는 알파벳 문자 또는 줄 바꿈에 대응됩니다.
+다른 문자 종류나 범위도 마찬가지로 "_"를 넣어서 쓸 수 있습니다.
+
+다른 것에도 앞에 "\_"를 붙여서 줄 바꿈에 대응되도록 할 수 있습니다. 예를
+들어, "\_."은 줄 바꿈을 포함한 아무 문자에나 대응됩니다.
+
+ Note:
+ "\_.*" 패턴에는 파일의 끝까지 전체 내용이 대응됩니다. 하지만 찾기
+ 명령이 매우 느려질 수 있으니 주의하십시오.
+
+또 다른 예는 "\_[]"로, 문자 범위에 줄 바꿈도 포함시키는 것입니다: >
+
+ /"\_[^"]*"
+
+위 패턴은 따옴표로 싸인 문장이 여러 줄에 나뉘어 있는 경우도 찾을 수 있습니다.
+
+==============================================================================
+*27.9* 예제
+
+몇 가지 유용한 찾기 패턴들을 모아보았습니다. 앞에서 설명한 것들이 어떻게
+조합되어 사용되는 지 살펴보시기 바랍니다.
+
+
+캘리포니아 자동차 번호판 찾기
+
+"1MGU103" 같은 번호판을 생각해 봅시다. 하나의 숫자가 있고, 세 개의 대문자와
+세 개의 숫자가 나옵니다. 바로 패턴으로 표현해보면 다음과 같습니다: >
+
+ /\d\u\u\u\d\d\d
+
+숫자와 대문자를 반복해서 쓰지 말고 숫자로 표시할 수도 있습니다: >
+
+ /\d\u\{3}\d\{3}
+
+줄인 표현이 기억나지 않는다면 [] 범위를 써도 됩니다: >
+
+ /[0-9][A-Z]\{3}[0-9]\{3}
+
+어떤 것을 사용하든 지 상관없습니다. 조금 길더라도 그냥 쉽게 머리 속에
+떠오르는 방법을 사용하는 것이 외우기도 힘든 복잡한 방법을 쓰는 것보다 훨씬
+빠릅니다. 하지만 단축표현을 외우고 있다면, 마지막 패턴은 피하는 것이
+좋습니다. 타이핑하기에도 길고, 실행 속도도 느립니다.
+
+
+이름 찾기
+
+C 프로그램에서는(물론 다른 프로그래밍 언어에서도) 변수나 함수의 이름이 알파벳
+문자로 시작하고, 그 뒤에는 알파벳 문자나 숫자가 나옵니다. 아, 밑줄도
+나올 수 있습니다. 이런 이름은 다음 패턴으로 찾을 수 있습니다: >
+
+ /\<\h\w*\>
+
+"\<"와 "\>"는 단어 전체인 경우만 찾기 위해 사용되었습니다. "\h"는
+"[A-Za-z_]"를 의미하고, "\w"는 "[0-9A-Za-z_]"를 의미합니다.
+
+ Note:
+ "\<"와 "\>"의 동작은 'iskeyword' 설정의 값에 따라 달라집니다. 예를 들어
+ "-"가 포함되어 있다면, "ident-"가 대응되지 않을 것입니다. 이런
+ 상황이라면 다음 패턴을 사용하십시오: >
+
+ /\w\@<!\h\w*\w\@!
+<
+ 위 패턴은 이름 앞 뒤에 "\w"가 오는 지를 확인하여 오지 않는 경우만
+ 대응되도록 합니다.
+ |/\@<!|와 |/\@!|를 참고하십시오.
+
+==============================================================================
+
+다음 장: |usr_28.txt| 접기
+
+저작권: |manual-copyright| 참고 vim:tw=78:ts=8:ft=help:norl:

Added: 7.0/doc/usr_28.kox
==============================================================================
--- (empty file)
+++ 7.0/doc/usr_28.kox Sun May 4 20:17:12 2008
@@ -0,0 +1,433 @@
+*usr_28.txt* Vim version 7.0 대상. 새로고침: 2006 Apr 24
+
+ VIM 사용설명서 - Bram Moolenaar 저
+ 정지용 역
+
+ 접기
+
+
+형식이 잘 갖춰진 문서는 여러 절(section)로 나뉠 수 있습니다. 또 하나의 절은
+더 작은 소 항목들로 나뉩니다. 접기(folding)는 하나의 절을 한 줄로 보여주어,
+문서 전체를 쉽게 개괄할 수 있도록 도와줍니다. 이번 장에서는 문서를 접는 여러
+방법들을 살펴보겠습니다.
+
+|28.1| 접기(folding)란?
+|28.2| 직접 접기
+|28.3| 폴드 다루기
+|28.4| 폴드 저장하고 불러오기
+|28.5| 들여쓰기에 따라 접기
+|28.6| 표식에 따라 접기
+|28.7| 문법에 따라 접기
+|28.8| 표현식에 따라 접기
+|28.9| 바뀌지 않은 부분을 접기
+|28.10| 접는 방법 선택하기
+
+다음 장: |usr_29.txt| 프로그램 코드 탐험하기
+이전 장: |usr_27.txt| 찾기 명령과 패턴
+ 차례: |usr_toc.txt|
+
+==============================================================================
+*28.1* 접기(folding)란?
+
+접기는 버퍼 중의 몇 줄을 화면에는 한 줄로 표시하는 기능입니다. 아래 그림과
+같이 종이를 접어서 중간의 내용을 건너뛰고 볼 수 있도록 말입니다.
+
+ +------------------------+
+ | 줄 1 |
+ | 줄 2 |
+ | 줄 3 |
+ |_______________________ |
+ \ \
+ \________________________\
+ / 접힌 줄들 /
+ /________________________/
+ | 줄 12 |
+ | 줄 13 |
+ | 줄 14 |
+ +------------------------+
+
+문서 내용은 바뀌지 않고 그대로 버퍼에 남아있습니다. 접은 효과로 화면에
+표시되는 모습만 바뀔 뿐입니다.
+
+접기를 잘 활용하면 문서 전체의 구조를 더 쉽고 빠르게 살펴볼 수 있습니다. 여러
+줄로 된 문서의 특정 절(section)을 화면에 모두 표시하는 대신, 여기에 그 절이
+있다고 한 줄로 줄여서 표시할 수 있으니까요.
+
+==============================================================================
+*28.2* 직접 접기
+
+한 번 해봅시다: 커서를 문단 하나로 옮기고 다음 명령을 입력해 봅시다: >
+
+ zfap
+
+문단전체가 강조된 하나의 줄로 바뀌었을 겁니다. 문서를 접어서 폴드(fold)를
+하나 만든 것이지요. |zf|는 연산자이고, |ap|는 문자열 객체를 선택하는
+명령입니다. |zf| 연산자와 이동 명령어를 섞어서 쓰면, 커서가 움직이는 영역이
+접히면서 폴드가 만들어집니다. |zf|는 가시 상태에서도 사용할 수 있습니다.
+
+접힌 부분의 내용을 다시 보려면, 폴드를 다음 명령으로 열면 됩니다: >
+
+ zo
+
+열린 폴드는 다음 명령으로 다시 닫을 수 있습니다: >
+
+ zc
+
+모든 접기 관련 명령어는 "z"로 시작합니다. 상상력을 조금 발휘해서 보면, "z"는
+접혀진 종이를 옆에서 본 모양이기도 합니다. "z" 뒤에 오는 문자는 명령은
+기억하기 쉽도록 각 동작을 나타내는 (영어)단어에서 따왔습니다:
+
+ zf 폴드(Fold) 생성
+ zo 폴드 열기(Open)
+ zc 폴드 닫기(Close)
+
+폴드 안에 폴드를 만들 수 있습니다: 폴드가 있는 문서 영역을 다시 접어서 중첩된
+폴드를 만들 수 있습니다. 예를 들어, 이번 절 안의 각 문단을 각각 접어 폴드를
+만들고, 이번 장 안의 모든 절을 또 각각 접어 폴드를 만들 수 있습니다. 한 번
+해보세요. 장 전체 폴드를 닫았다가 열어도 안에 들어있는 폴드들의 상태는 그대로
+유지됩니다. 열려있던 것은 계속 열려있고, 닫혀있던 것은 그대로 닫혀있습니다.
+
+폴드를 여러 개 만들었는데, 모두 펼쳐서 문서 전체를 보고싶다고 합시다. 폴드가
+있는 곳마다 이동하면서 "zo" 명령을 사용해도 됩니다만, 다음 명령을 쓰면 더
+빠르게 할 수 있습니다: >
+
+ zr
+
+위 명령은 접힌 정도를 줄입니다(Reduce). 반대로 하는 명령도 있습니다: >
+
+ zm
+
+이 명령은 더 많이(More) 접습니다. "zr"이나 "zm"을 반복해서 여러 번 접혀진
+부분을 차례대로 열거나 닫을 수 있습니다.
+
+몇 단계에 걸쳐서 접어놓았다면, 다음 명령으로 한 번에 모두 풀 수 있습니다: >
+
+ zR
+
+위 명령은 접힌 정도를 줄이는데(Reduce), 더 이상 접힌 것이 없을 때까지 모두
+엽니다. 반대로 모든 폴드를 닫으려면: >
+
+ zM
+
+위 명령은 더 많이(More) 많이(More) 접어서 모든 폴드를 닫습니다.
+
+|zn| 명령을 쓰면 접기 기능을 순간적으로 없앨 수 있습니다. |zN| 명령을 쓰면
+다시 폴드들이 돌아옵니다. |zi| 명령은 접기 기능이 꺼져있으면 켜고, 켜져있으면
+끕니다(toggle). 다음과 같이 쓰면 편리하겠지요:
+- 전체 파일을 살펴 보기 위해 폴드를 여기저기 만듭니다
+- 작업을 할 곳으로 이동합니다.
+- |zi|로 폴드를 없애고 문서 작업을 합니다
+- |zi|로 폴드를 다시 되살리고 여기저기를 돌아다닙니다
+
+직접(manual) 접기 기능을 더 자세히 살펴보려면: |fold-manual|
+
+==============================================================================
+*28.3* 폴드 다루기
+
+폴드가 닫혀있을 때는 마치 하나의 빈 줄인 것처럼 "j"나 "k"같은 이동 명령으로 그
+위를 돌아다닐 수 있습니다. 그래서 접혀진 문서 위를 돌아다니며 전체 문서를
+빠르게 살펴볼 수 있습니다.
+
+폴드는 마치 하나의 줄인 것처럼 복사해 두거나, 지우고 붙여넣기 할 수 있습니다.
+프로그램에서 함수들의 순서를 바꿀 때 매우 유용합니다. 먼저 적절한
+'foldmethod'(접기방법)를 선택하여 각 폴드에 함수 전체(혹은 거의 전체)가
+들어있는 지 확인합시다. "dd"로 함수를 지우고, 커서를 옮긴 다음 "p"로 붙여넣기
+합니다. 만약 폴드 앞이나 뒤에 함수 내용이 몇 줄 더 있다면, 다음과 같이 가시
+상태의 선택방법을 사용해도 됩니다:
+- 이동시킬 부분의 첫 줄로 커서를 옮깁니다
+- "V"를 눌러 가시 상태로 들어갑니다
+- 이동시킬 부분의 마지막 줄로 커서를 옮깁니다
+- "d"를 눌러 선택한 부분을 잘라냅니다
+- 커서를 붙여넣을 위치로 옮긴다음, "p"로 잘라낸 내용을 붙여넣습니다(Put).
+
+가끔은 폴드의 위치가 어디인지 보거나 기억하기 어려울 수도 있습니다. 엉뚱한
+곳에서 |zo|를 누르면서 헤맬 수도 있겠지요. 폴드가 어디에 있는 지 보려면: >
+
+ :set foldcolumn=4
+
+'foldcolumn'(폴드열)을 설정하면, 창의 왼쪽에 세로로 조그만 공간이 생기고,
+폴드들이 표시됩니다. "+"는 닫힌 폴드를 나타냅니다. 열린 폴드의 시작
+줄에는 "-"가 표시되고, 나머지 부분에는 "|"가 표시됩니다.
+
+마우스로 폴드열의 "+"를 클릭하면 닫힌 폴드를 열 수 있습니다. "-"나 그 밑의
+"|"를 클릭하면 열린 폴드가 닫힙니다.
+
+현재 커서 위치의 모든 폴드를 열려면 |zO|.
+현재 커서 위치의 모든 폴드를 닫으려면 |zC|.
+현재 커서 위치의 폴드를 하나 없애려면 |zd|.
+현재 커서 위치의 모든 폴드를 없애려면 |zD|.
+
+입력 상태에서, 현재 커서 위치의 폴드는 절대 닫히지 않습니다. 따라서 언제나
+입력하는 내용이 화면에 보입니다.
+
+여기 저기를 돌아다니거나 커서를 좌우로 움직이면 폴드가 자동으로 열립니다.
+예를 들어, "0" 명령은 커서 위치의 폴드를 엽니다('foldopen'(폴드열기)에
+"hor"(수평)이 들어있는 경우에 한합니다만, 기본 설정인 경우 들어있습니다).
+'foldopen' 설정을 바꿔서 어떤 명령을 썼을 때 폴드가 열릴 지 지정할 수
+있습니다. 커서가 위치한 곳의 폴드가 언제나 열려있도록 하려면, 다음 명령을
+사용하십시오: >
+
+ :set foldopen=all
+
+주의: 위와 같이 설정하면 닫힌 폴드 위로 움직일 수가 없게됩니다. 이 옵션을
+쓰다가 다시 기본 설정으로 돌아가려면 다음 명령을 사용하십시오: >
+
+ :set foldopen&
+
+커서가 폴드 밖으로 나가면 자동으로 폴드가 닫히도록 할 수 있습니다: >
+
+ :set foldclose=all
+
+'foldclose'(폴드닫기)를 all로 설정하면, 커서가 벗어난 폴드들에
+'foldlevel'(폴드단계)가 적용됩니다. 어떻게 동작하는 지는 한 번 써봐야 감이
+오실 것입니다. 더 많이 접으려면 |zm|을, 더 많이 펼치려면 |zr|을
+사용하십시오(r은 접힌 정도를 줄인다(reduce)는 데서 따온것입니다).
+
+폴드는 현재 창에만 적용됩니다. 따라서 같은 버퍼를 두 창에 열어놓고, 한 창은
+폴드를 쓰고 다른 창은 폴드를 쓰지 않은 채로 사용할 수 있습니다. 또는 한 창은
+모든 폴드를 닫아놓고, 다른 창은 폴드를 모두 열어놓을 수도 있습니다.
+
+==============================================================================
+*28.4* 폴드 저장하고 불러오기
+
+편집 중이던 파일을 닫고 다른 파일을 편집하면, 현재의 접기 상태가 모두
+사라집니다. 같은 파일로 다시 돌아오면, 폴드는 전에 열려있었든 닫혀있었든 모두
+기본 상태로 돌아갑니다. 만약 폴드가 직접(manual) 만들어 진 것이라면, 모든
+폴드가 사라집니다! 폴드를 저장하려면 |:mkview| 명령을 사용하십시오: >
+
+ :mkview
+
+위 명령은 설정들을 비롯하여 현재 뷰(view)에 영향을 주는 정보들을 파일에
+저장합니다. 무엇이 저장되는 지는 'viewoptions'(뷰설정)을 설정하여 바꿀 수
+있습니다. 같은 파일을 다시 편집할 때, 다음 명령으로 저장한 뷰를 불러올(load)
+수 있습니다:
+
+ :loadview
+
+파일 하나 당 뷰는 10개까지 저장할 수 있습니다. 예를 들어, 현재 상태를 세 번째
+뷰로 저장하고, 두 번째 뷰를 불러오려면: >
+
+ :mkview 3
+ :loadview 2
+
+줄을 새로 넣거나 지우면 뷰의 정보가 어긋날 수도 있습니다. 뷰가 저장될 위치를
+지정하는 'viewdir'(뷰디렉토리) 설정도 참고하십시오. 가끔은 예전에 저장한 뷰를
+지우고 싶을 수도 있으니까요.
+
+==============================================================================
+*28.5* 들여쓰기에 따라 접기
+
+|zf|로 문서의 필요한 부분을 일일이 접으려면 시간이 많이 걸립니다. 만약 문서가
+더 자세한 내용이 더 많이 들여쓰기가 되는 구조로 되어있다면, 들여쓰기(indent)에
+따라 접을 수 있습니다. 들여쓰기에 따라 접으면 같은 양만큼 들여쓰기가 된
+줄들이 묶여서 하나의 폴드가 됩니다. 더 많이 들여쓰기 된 부분은 폴드 안의
+폴드가 됩니다. 많은 프로그래밍 언어에서 적합한 접기 방법입니다.
+
+'foldmethod'(접기방법) 설정을 바꾸어 이 기능을 써봅시다: >
+
+ :set foldmethod=indent
+
+더 많이 접거나 펼치려면 |zm|, |zr| 명령을 사용하십시오. 다음 예문을 보면
+이해하기 쉬울 것입니다:
+
+들여쓰기가 안되었음
+ 한 칸 들여쓰기 되었음
+ 두 칸 들여쓰기 되었음
+ 두 칸 들여쓰기 되었음
+ 한 칸 들여쓰기 되었음
+들여쓰기가 안되었음
+ 한 칸 들여쓰기 되었음
+ 한 칸 들여쓰기 되었음
+
+들여쓰기 정도에 따라 접히는 정도가 결정됩니다. 이 정도는
+'shiftwidth'(들여쓰기폭) 설정에 따라 결정됩니다. 매 'shiftwidth' 만큼
+들여쓰기 될 때마다, 한 번씩 더 접힙니다. 여러 번 접혀서 폴드가 겹쳐진 정도를
+폴드 단계(fold level)라고 부릅니다.
+
+|zr|이나 |zm| 명령을 사용하는 것은 사실 'foldlevel' 설정의 값을 늘리거나
+줄이는 것입니다. 다음과 같이 바로 설정할 수도 있습니다: >
+
+ :set foldlevel=3
+
+위 명령은 'shiftwidth'의 세 배 이상 들여쓰기 된 부분의 폴드를 모두 닫습니다.
+폴드 단계가 낮을 수록 더 많은 폴드가 닫힙니다. 'foldlevel'이 0이면, 모든
+폴드가 닫힙니다. |zM|이 'foldlevel'을 0으로 만드는 명령입니다. 반대로 |zR|은
+'foldlevel'을 현재 파일의 가장 깊은 폴드 단계에 맞추어 줍니다.
+
+따라서, 다음 두 가지 방법으로 폴드를 열고 닫으면 됩니다:
+(A) 폴드 단계를 설정해서.
+ 빠르게 "줌 아웃"해서 전체 내용의 구조를 살펴본 후, 커서를 움직여 다시 특정
+ 부분에 "줌 인" 할 수 있습니다.
+
+(B) |zo|와 |zc| 명령으로 각각의 폴드를 열거나 닫아서.
+ 다른 폴드들은 닫아놓은 채, 원하는 폴드들만 열어서 볼 수 있습니다.
+
+물론 섞어서 쓸 수도 있습니다: |zm|을 몇 번 해서 폴드를 쭉 닫은 후, 원하는
+폴드만 |zo|로 열어서 보면 됩니다. 아니면 |zR|로 모든 폴드를 연 다음, 필요
+없는 부분만 |zc|로 닫아도 됩니다.
+
+하지만, 'foldmethod'가 "indent"(들여쓰기)일 때는 직접 폴드를 만들 수 없습니다.
+직접 폴드를 만든다면, 들여쓰기 정도와 폴드 단계와의 상관관계가 깨지기
+때문입니다.
+
+들여쓰기에 따라 접는 방법에 대하여 더 알고 싶다면: |fold-indent|
+
+==============================================================================
+*28.6* 표식에 따라 접기
+
+문서 내에 특별한 표식(Marker)을 넣어서, 접을 부분의 시작과 끝을 표시할 수
+있습니다. 어느 부분을 접을 것인지 정확하게 제어할 수 있다는 장점이 있지만,
+문서의 내용 자체가 바뀌어야한다는 단점이 있습니다.
+
+한 번 써 봅시다: >
+
+ :set foldmethod=marker
+
+다음 C 프로그램의 일부를 살펴봅시다:
+
+ /* foobar () {{{ */
+ int foobar()
+ {
+ /* 답을 반환 {{{ */
+ return 42;
+ /* }}} */
+ }
+ /* }}} */
+
+접힌 부분은 표식 앞의 내용을 보여줍니다. 폴드의 내용을 보여줄 수 있는 유용한
+기능이지요.
+
+문서 내용을 이리 저리 옮기다가 표식 짝이 틀어져서 문서가 엉뚱하게 접히면
+짜증이 좀 나겠지요. 이 문제는 표식에 숫자를 덧붙여서 해결할 수 있습니다. 예:
+
+ /* 전역 변수 {{{1 */
+ int varA, varB;
+
+ /* 함수 {{{1 */
+ /* funcA() {{{2 */
+ void funcA() {}
+
+ /* funcB() {{{2 */
+ void funcB() {}
+ /* }}}1 */
+
+번호가 매겨진 각 표식에서 해당 단계의 폴드가 시작됩니다. 만약 더 높은 단계의
+폴드가 있다면 그 위치에서 폴드가 끝납니다. 따라서 번호가 매겨져있다면 시작
+표식들만으로 폴드를 다 지정할 수도 있습니다. 다른 폴드가 시작되기 전에 폴드의
+끝을 지정하고 싶다면 끝 표식을 추가하십시오.
+
+상세설명서의 표식을 이용한 접기관련 내용은: |fold-marker|
+
+==============================================================================
+*28.7* 문법에 따라 접기
+
+빔은 각 언어별로 각각 문법 파일을 제공하고 있습니다. 문법 파일을 사용하면
+파일의 다양한 요소를 색색으로 구분하여 볼 수 있습니다. 만약 컬러가 지원되는
+터미널에서 이 도움말을 보고 있다면, 지금 보이는 색들은 "help" 문법 파일에 의해
+지정된 것입니다.
+ 문법 파일에는 "fold"(폴드) 인자를 갖는 문법 항목을 넣을 수 있습니다. 이
+항목은 폴드 영역을 지정합니다. 이 방법을 사용하려면 문법 파일을 쓰고, 필요한
+항목을 추가할 수 있어야하는데, 사실 쉽지는 않습니다. 하지만, 한 번만 설정을
+해놓으면, 자동으로 문서가 접힙니다.
+ 이 문서에서는 사용자가 빔과 함께 제공되는 문법 파일을 사용한다고
+가정하므로, 더 자세한 내용은 생략하도록 하겠습니다. 위에 설명한 방법들로
+폴드를 열거나 닫을 수 있습니다. 파일을 수정하면 자동으로 폴드가 생기거나
+사라집니다.
+
+문법에 따라 접기에 관한 더 자세한 내용은: |fold-syntax|
+
+==============================================================================
+*28.8* 표현식에 따라 접기
+
+이 기능은 들여쓰기에 따라 접기와 비슷합니다만, 들여쓰기 대신 사용자 함수를
+실행시켜서 줄의 폴드 단계를 결정합니다. 문서 내에 어디부터 어디까지가 같은
+부분인지 나타내는 표시가 있다면, 이 기능을 사용할 수 있습니다. 예를 들어,
+이메일을 보면, 줄 앞의 ">"로 이전 메일의 내용이 구분됩니다. 이 표시에 따라
+접으려면, 다음 명령을 사용하십시오: >
+
+ :set foldmethod=expr
+ :set foldexpr=strlen(substitute(substitute(getline(v:lnum),'\\s','',\"g\"),'[^>].*','',''))
+
+다음 내용으로 확인해보십시오:
+
+> 그에게서 받은 이전 메일 내용
+> 그에게서 받은 이전 메일 내용
+> > 내가 쓴 그 전전 메일 내용
+> > 내가 쓴 그 전전 메일 내용
+
+위 예에서 본 'foldexpr'(폴드표현식)에 대한 설명 (안에서 바깥 순):
+ getline(v:lnum) 현재 줄의 내용을 얻음
+ substitute(...,'\\s','','g') 공백을 모두 삭제
+ substitute(...,'[^>].*','','') 맨 앞의 '>' 뒤 내용을 모두 삭제
+ strlen(...) 남은 내용의 길이를 셈. 여기서는 '>'만
+ 남아있으므로 '>'의 수가 된다
+
+":set" 명령을 쓸 때는 공백이나 따옴표, 백슬래시 앞에 백슬래시를 써줘야된다는
+데 주의하십시오. 실제 어떤 내용이 들어갔는 지는 다음 명령으로 확인할 수
+있습니다: >
+
+ :set foldexpr
+
+복잡한 표현식을 쓸 때는, 명령줄 자동완성을 활용하십시오: >
+
+ :set foldexpr=<Tab>
+
+여기서 <Tab>은 진짜 탭 키 입니다. 기존에 설정되어 있는 값이 자동으로
+채워집니다. 이제 필요한 부분만 적절히 고치면 되겠지요.
+
+만약 표현식이 너무나 복잡하다면, 정리해서 함수로 만들고, 'foldexpr'에서는 이
+함수만 불러서 처리하는 것이 좋습니다.
+
+상세 설명서에서 표현식에 관한 내용을 보려면: |fold-expr|
+
+==============================================================================
+*28.9* 바뀌지 않은 부분을 접기
+
+이 기능은 같은 창에서 'diff' 설정을 켰을 때 유용합니다. |vimdiff| 프로그램이
+하는 것처럼 말이지요. 예: >
+
+ setlocal diff foldmethod=diff scrollbind nowrap foldlevel=1
+
+한 파일의 여러 버전을 여러 창에서 비교해서 볼 때 위 명령을 모든 창에서
+실행시키십시오. 각 창의 동일한 부분은 접혀서 사라지고, 차이가 있는 부분만
+알기 쉽게 표시됩니다.
+
+더 자세한 내용은 |fold-diff|를 참고하십시오.
+
+==============================================================================
+*28.10* 접는 방법 선택하기
+
+너무 다양한 방법이 있어서 접는 방법을 고르기 어려우시다고요? 아쉽지만, 완벽한
+방법은 없고 각 상황에 맞게 골라서 써야합니다. 다만 몇 가지 조언을 해드리지요.
+
+현재 편집하는 언어의 문법 파일에 접기에 관한 설정이 되어있다면, 문법에 따라
+접는 것이 대개 제일 좋습니다. 만약 없다면, 직접 하나 만들어 봐도 되겠지요.
+찾기 패턴에 관한 지식이 필요합니다. 쉽지는 않지만, 한 번 잘 동작하게
+만들어놓으면 일일이 폴드를 만드는 수고를 덜 수 있겠지요.
+
+문서가 일정한 형식이나 틀이 없이 쓰여진 것이라면, 직접 폴드를 만드는 수 밖에
+없습니다. 이 때는 |:mkview|를 이용하여 폴드를 저장하거나 불러오십시오.
+
+표식을 사용하려면 파일을 수정해야합니다. 다른 사람들과 함께 작업하거나,
+회사의 공통 편집 규칙을 지키려면 사용할 수 없을 수도 있겠지요.
+ 표식을 사용할 때의 장점은 정확하게 원하는 위치를 접을 수 있다는 것입니다.
+문서의 내용을 이리 저리 옮길 때 몇 줄을 빼먹는다든지 하는 실수를 줄일 수
+있겠지요. 폴드의 내용에 관한 설명을 간략하게 적을 수도 있습니다.
+
+들여쓰기에 따라 접기는 많은 파일 형식에서 쓸 수는 있지만, 언제나 깔끔하게 잘
+되지는 않습니다. 다른 방법을 사용할 수 없을 때에 한하여 사용하십시오. 하지만
+전체 문서의 윤곽을 잡을 때는 매우 유용합니다. 각 들여쓰기 단계에 맞추어
+'shiftwidth'를 설정하십시오.
+
+표현식에 따라 접기는 거의 대부분의 형식이 있는 문서에 사용할 수 있습니다.
+지정하기도 그렇게 어렵지 않습니다. 특히 폴드의 시작과 끝을 쉽게 구분할 수 있을
+땐 말이지요.
+ 표현식에 따라 접었는데, 실제로 원했던 결과와 조금 차이가 있을 때는 직접
+접기로 바꾸면 됩니다. 이 때는 이미 정의된 폴드들이 사라지지 않습니다. 따라서
+원하는 대로 더 접거나 펼치면 됩니다.
+
+==============================================================================
+
+다음 장: |usr_29.txt| 프로그램 코드 탐험하기
+
+저작권: |manual-copyright| 참고 vim:tw=78:ts=8:ft=help:norl:

Added: 7.0/doc/usr_29.kox
==============================================================================
--- (empty file)
+++ 7.0/doc/usr_29.kox Sun May 4 20:17:12 2008
@@ -0,0 +1,622 @@
+*usr_29.txt* Vim version 7.0 대상. 새로고침: 2006 Apr 24
+
+ VIM 사용설명서 - Bram Moolenaar 저
+ 정지용 역
+
+ 프로그램 코드 탐험하기
+
+
+빔은 컴퓨터 프로그래머가 만들었습니다. 따라서 프로그램 작성에 도움이 되는
+기능들이 많은 것도 당연하겠지요. 어떤 변수나 함수가 정의되고 사용된 위치들을
+돌아다녀보십시오. 변수나 함수의 선언을 별도의 창에서 미리 살펴보십시오. 다음
+장에는 더 많은 내용이 기다리고 있습니다.
+
+|29.1| 태그 사용하기
+|29.2| 미리보기 창
+|29.3| 프로그램 코드 돌아다니기
+|29.4| 전역 이름 찾기
+|29.5| 지역 이름 찾기
+
+다음 장: |usr_30.txt| 프로그램 편집하기
+이전 장: |usr_28.txt| 접기
+ 차례: |usr_toc.txt|
+
+==============================================================================
+*29.1* 태그 사용하기
+
+태그(tag)가 무엇일까요? 빔에서 태그는 어떤 이름이 정의된 위치입니다. 예를
+들면 C나 C++ 프로그램에서 함수의 정의 같은 것입니다. 태그 목록은 태그 파일에
+저장됩니다. 빔은 이 태그 파일을 이용하여 현재 어디에 있든지, 해당 이름이
+정의된 위치로 이동시켜줍니다.
+ 현재 디렉토리의 모든 C 파일에 대한 태그 파일을 생성하려면, 쉘에서 다음
+명령을 사용하십시오: >
+
+ ctags *.c
+
+"ctags"는 별도의 프로그램입니다. 대부분의 유닉스 시스템에는 기본으로
+설치됩니다. 만약 설치되어있지 않다면 다음 URL에서 Exuberant ctags를 다운
+받으십시오:
+
+ http://ctags.sf.net ~
+
+이제 빔에서 어떤 함수의 정의로 가고 싶다면, 다음 명령으로 이동할 수 있습니다:
+>
+
+ :tag startlist
+
+위 명령은 "startlist" 함수를 찾을 것입니다. "startlist"가 다른 파일에
+있더라도 말이지요.
+ CTRL-] 명령을 사용하면 현재 커서 위치에 있는 단어의 태그로 이동합니다.
+이 기능을 잘 이용하면 이리 저리 얽힌 C 코드를 훨씬 쉽게 돌아다닐 수 있습니다.
+예를 들어, "write_block"이란 함수를 보고 있는데, 이 함수가 "write_line"이란
+함수를 호출하고 있다고 합시다. "write_line"이 어떤 일을 하는 함수일까요?
+커서를 "write_line"으로 옮기고 CTRL-]를 누르면, 함수가 정의된 곳으로 이동할 수
+있습니다.
+ "write_line" 함수는 "write_char"함수를 부릅니다. 이 함수가 어떤 일을 하는
+지 또 알아봐야겠지요. 커서를 "write_char"를 호출하는 부분으로 옮긴 후,
+CTRL-]를 누릅시다. 이제 "write_char" 함수의 정의를 볼 수 있을 것입니다.
+
+ +-------------------------------------+
+ |void write_block(char **s; int cnt) |
+ |{ |
+ | int i; |
+ | for (i = 0; i < cnt; ++i) |
+ | write_line(s[i]); |
+ |} | |
+ +-----------|-------------------------+
+ |
+ CTRL-] |
+ | +----------------------------+
+ +--> |void write_line(char *s) |
+ |{ |
+ | while (*s != 0) |
+ | write_char(*s++); |
+ |} | |
+ +--------|-------------------+
+ |
+ CTRL-] |
+ | +------------------------------------+
+ +--> |void write_char(char c) |
+ |{ |
+ | putchar((int)(unsigned char)c); |
+ |} |
+ +------------------------------------+
+
+":tags" 명령은 지금까지 거쳐온 태그들의 목록을 보여줍니다.
+
+ :tags
+ # TO tag FROM line in file/text ~
+ 1 1 write_line 8 write_block.c ~
+ 2 1 write_char 7 write_line.c ~
+ > ~
+>
+이제 돌아가봅시다. CTRL-T 명령으로 이전 태그로 돌아갑니다. 위의 예에서는
+"write_line" 함수의 "write_char" 호출 부분으로 돌아갑니다.
+ 몇 개의 태그를 돌아갈 것인지 숫자를 지정할 수도 있습니다. 쭉 앞으로 갔다가
+뒤로 돌아와 보았습니다. 다시 앞으로 가봅시다. 다음 명령으로 태그 목록의 제일
+최신 태그로 이동합시다: >
+
+ :tag
+
+명령 앞에 숫자를 붙여서 이동할 태그수를 지정할 수 있습니다. 예제: ":3tag".
+CTRL-T 앞에도 숫자를 붙일 수 있습니다.
+ 이 명령들은 함수 호출 단계를 CTRL-]로 따라갔다가 CTRL-T로 다시 돌아올 수
+있게 해줍니다. 현재 위치를 보려면 ":tags" 명령을 사용하십시오.
+
+
+창 나누기
+
+":tag" 명령은 현재 창에 열려있는 파일을 닫고 해당 태그가 포함된 파일을 엽니다.
+하지만 현재 파일과 새 파일을 동시에 보고 싶다면 어떻게 해야할까요? ":tag"
+명령 앞에 ":split" 명령을 사용해서 창을 나누면 됩니다. 다음과 같이 두 명령을
+줄여서 쓸 수 있습니다: >
+ :stag tagname
+
+현재 창을 나누면서 현재 커서가 위치한 태그로 이동하려면 다음 명령을
+사용하십시오: >
+
+ CTRL-W ]
+
+명령 전에 숫자를 넣으면 새 창은 그 숫자만큼의 높이가 됩니다.
+
+
+더 많은 태그 파일들
+
+파일이 여러 디렉토리에 들어있다면, 각 디렉토리마다 태그 파일을 만들면 됩니다.
+빔으로는 원래 하나의 디렉토리 안에 있는 태그 파일만 접근할 수 있습니다.
+ 더 많은 태그 파일을 이용해서 찾으려면, 'tags'(태그) 설정에 모든 관련 태그
+파일을 설정하면 됩니다. 예: >
+
+ :set tags=./tags,./../tags,./*/tags
+
+위와 같이 설정하면, 현재 파일과 같은 디렉토리의 태그파일과 한 단계 위
+디렉토리, 하위 디렉토리들의 태그파일들이 모두 사용됩니다.
+ 이 정도만 해도 꽤 많지만, 더 많이 지정해야할 수도 있습니다. 예를 들어,
+"~/proj/src" 안의 파일을 편집하면, "~/proj/sub/tags" 파일을 찾을 수 없습니다.
+이런 경우 모든 하위 디렉토리-하위 디렉토리들의 하위 디렉토리를 포함하여-를 찾는
+방법이 있습니다. 예: >
+
+ :set tags=~/proj/**/tags
+
+
+하나의 태그 파일
+
+위에서와 같이 빔이 여기저기서 태그 파일들을 읽어들이면, 하드디스크 긁는 소리가
+좀 거슬릴 겁니다. 물론 더 느릴테고요. 이 때는 하나의 커다란 태그파일을
+만들어서 사용하는 것이 낫습니다. 태그파일 생성은 시간이 좀 걸릴 수도
+있겠지만, 밤동안에 하면 됩니다.
+ 이렇게 하려면 위에서 말한 Exuberant ctags 프로그램이 필요합니다. 이
+프로그램은 디렉토리 구조 전체를 찾도록 하는 인자가 있습니다: >
+
+ cd ~/proj
+ ctags -R .
+
+이 방법의 또다른 장점은 Exuberant ctags가 여러가지 파일형식을 인식한다는
+것입니다. C나 C++ 프로그램 뿐 아니라, Eiffel, 심지어는 빔 스크립트의
+태그까지 만들어줍니다. 이 기능에 대한 설명은 ctags 문서를 참고하십시오.
+ 이제 위에서 만든 하나의 태그파일이 어디에 있는 지 빔에 지정하기만 하면
+됩니다: >
+
+ :set tags=~/proj/tags
+
+
+여러 곳에 정의되어있을 때
+
+함수 하나가 여러 번 정의되어있다면(혹은 하나의 메소드(method)가 여러
+클래스(class)에 정의되어있다면), "tag" 명령은 그 중 첫번째로 이동합니다. 만약
+현재 파일에 태그가 있다면 이 태그가 먼저 사용됩니다.
+ 같은 단어에 대응되는 다음 태그로 가려면: >
+
+ :tnext
+
+위 명령을 반복하여 여러 태그들을 볼 수 있습니다. 만약 후보가 여럿이라면, 어느
+태그로 갈 것인지 다음 명령으로 선택할 수도 있습니다: >
+
+ :tselect tagname
+
+빔은 다음과 같이 선택 후보들을 보여줍니다:
+
+ # pri kind tag 파일 ~
+ 1 F f mch_init os_amiga.c ~
+ mch_init() ~
+ 2 F f mch_init os_mac.c ~
+ mch_init() ~
+ 3 F f mch_init os_msdos.c ~
+ mch_init(void) ~
+ 4 F f mch_init os_riscos.c ~
+ mch_init() ~
+ 고를 숫자 입력 (<CR>은 중지): ~
+
+이제 이동하려는 태그의 번호(맨 앞의 숫자)를 넣으면 됩니다. 각 태그가 어느
+곳을 가리키는 지를 알 수 있도록 여러 정보를 함께 보여줍니다.
+
+여러 태그들 사이를 이동하려면 다음 명령들을 사용하면 됩니다:
+
+ :tfirst 첫 번째 태그로 가기
+ :[숫자]tprevious [숫자] 만큼 앞 태그로 가기
+ :[숫자]tnext [숫자] 만큼 뒤 태그로 가기
+ :tlast 마지막 태그로 가기
+
+[숫자]가 생략된 경우에는 1이 사용됩니다.
+
+
+태그 이름 추정하기
+
+태그 이름이 길 때는 명령줄 자동완성을 사용하면 편리합니다. 처음 몇 글자만
+입력하고 <Tab>을 누르십시오: >
+
+ :tag write_<Tab>
+
+첫 번째 후보가 완성될 것입니다. 만약 원하는 태그 이름이 아니라면, <Tab>을 또
+눌러서 다음으로 넘어가십시오.
+ 함수명의 일부만 생각날 수도 있습니다. 같은 문자열로 시작하지만 끝부분이
+다른 태그 이름이 많을 수도 있습니다. 이 땐 찾을 태그 이름의 패턴을 지정할
+수도 있습니다.
+ "block"이 포함된 태그를 찾고 싶다고 합시다. 다음과 같이 입력하십시오: >
+
+ :tag /block
+
+이제 <Tab>을 눌러서 명령줄 자동완성을 사용합시다. "block"이 포함된 모든
+태그를 찾고 첫 번째 후보를 사용할 것입니다.
+ 태그 이름 앞의 "/"는 태그 이름이 아니라 패턴이라는 것을 의미합니다. 모든
+찾기 패턴을 여기에 사용할 수 있습니다. 예를 들어, "write_"로 시작하는 태그를
+찾고 싶다고 합시다: >
+
+ :tselect /^write_
+
+"^"는 태그가 "write_"로 시작해야함을 의미합니다. "^"가 없다면 태그 이름
+중간에 "write_"가 있는 태그도 찾을 것입니다. 유사하게 "$"가 패턴 끝에 오면
+패턴이 태그의 끝에 나와야 한다는 의미입니다.
+
+
+태그를 이용한 브라우저
+
+CTRL-] 으로 커서 위치의 이름이 정의된 곳으로 이동할 수 있다는 점을 이용하면,
+이런 이름들을 한 곳에 모아놓고 목차로 사용할 수도 있습니다. 다음 예를
+살펴보겠습니다.
+ 먼저 다음과 같이 이름의 목록을 만듭니다 (Exuberant ctags가 필요합니다): >
+
+ ctags --c-types=f -f functions *.c
+
+이제 인자 없이 빔을 실행시킨 다음, 창을 세로로 나눠서 이 파일을 빔으로 엽니다:
+>
+
+ vim
+ :vsplit functions
+
+새로 열린 창에는 함수들의 목록이 있을 것입니다. 그 외에도 몇 가지가 있겠지만,
+무시하면 됩니다. ":setlocal ts=99"을 하면 좀 깨끗하게 보일 겁니다.
+ 이 창에서 다음과 같은 매핑을 정의합시다: >
+
+ :nnoremap <buffer> <CR> 0ye<C-W>w:tag <C-R>"<CR>
+
+커서를 이동하고 싶은 함수가 있는 줄로 옮깁시다. 그리고 <Enter>를 누르면,
+다른 창으로 이동해서 선택된 함수를 찾아갈 것입니다.
+
+
+관련된 기능들
+
+'ignorecase'(대소문자무시)를 켜면, 태그 이름을 찾을 때 대소문자를 무시합니다.
+
+'tagsearch'(태그찾기) 설정에 태그파일이 정렬되어있는 지 여부를 지정합니다.
+기본 값은 태그파일이 정렬되어있다고 가정하는 것으로, 이 경우 태그를 매우
+빠르게 찾습니다. 하지만 태그 파일이 정렬되어있지 않다면, 제대로 동작하지 않게
+됩니다.
+
+'taglength'(태그길이) 설정은 태그에서 실제로 사용할 부분의 길이를 문자수
+단위로 나타냅니다.
+
+SNiFF+ 프로그램을 사용할 때, 빔 인터페이스를 사용할 수 있습니다 |sniff|.
+SNiFF+은 상용 프로그램입니다.
+
+Cscope은 자유롭게 사용할 수 있는 프로그램(프리웨어)입니다. 어떤 이름이 정의된
+위치 뿐 아니라, 사용된 위치들까지 함께 찾아줍니다. |cscope|를 참고하십시오.
+
+==============================================================================
+*29.2* 미리보기 창
+
+어떤 함수를 사용하는 코드를 짤 때, 인자를 정확하게 사용하는 게 중요하겠지요.
+인자로 어떤 값들을 넘겨야하는 지 확인하기 위해서는 함수가 어떻게 정의되었는 지
+살펴 볼 필요가 있습니다. 태그 기능은 이 때도 유용합니다. 함수의 정의를 다른
+창에 보여줄 수도 있는데, 이 때 사용되는 것이 미리보기 창(preview window)
+입니다.
+ "write_char" 함수를 미리보기 창에 표시하려면: >
+
+ :ptag write_char
+
+빔은 새 창을 열고, "write_char" 태그를 찾아 보여줄 것입니다. 그리고 원래의
+위치로 돌아갑니다. 따라서 CTRL-W 명령으로 창을 옮겨다닐 필요 없이 계속해서
+프로그램을 입력할 수 있습니다.
+ 만약 함수 이름이 문서 내용 중에 나온다면, 다음 명령으로 함수의 정의를
+미리보기 창에서 볼 수 있습니다: >
+
+ CTRL-W }
+
+현재 커서가 위치한 곳의 단어가 정의된 곳을 자동으로 찾아서 보여주는 스크립트도
+있습니다. |CursorHold-example|을 참고하십시오.
+
+미리보기 창을 닫으려면 다음 명령을 사용하십시오: >
+
+ :pclose
+
+특정 파일을 미리보기 창에서 편집하려면, ":pedit"를 사용하십시오. 다음과 같이
+헤더파일을 편집하는 경우에 사용하면 유용합니다: >
+
+ :pedit defs.h
+
+마지막으로, ":psearch"는 현재 파일 및 인클루드된 파일에서 단어를 찾고 찾은
+단어를 미리보기 창에 표시해줍니다. 이 기능은 태그파일이 따로 없는 라이브러리
+함수를 사용할 때에 유용합니다. 예를 들어: >
+
+ :psearch popen
+
+위 명령을 사용하면 "stdio.h" 파일을 미리보기 창에서 열고 popen()함수의
+프로토타입을 보여줄 것입니다:
+
+ FILE *popen __P((const char *, const char *)); ~
+
+'previewheight'(미리보기높이) 설정으로 미리보기 창의 기본 높이를 지정할 수
+있습니다.
+
+==============================================================================
+*29.3* 프로그램 코드 돌아다니기
+
+프로그램은 그 형식이 정해져있으므로, 빔으로 그 안의 내용을 인식할 수 있습니다.
+내용에 따라 이동할 수 있는 명령어도 몇 가지 있습니다.
+ C 프로그램에서 종종 다음과 같은 형태를 볼 수 있습니다:
+
+ #ifdef USE_POPEN ~
+ fd = popen("ls", "r") ~
+ #else ~
+ fd = fopen("tmp", "w") ~
+ #endif ~
+
+하지만 훨씬 길 수도 있고, 중첩되어있을 수도 있습니다. 커서를 "#ifdef"에 놓고,
+%를 눌러봅시다. 커서가 "#else"로 이동했을 것입니다. %를 다시 한 번 누르면
+"#endif"로 갑니다. 또 한 번 누르면 처음의 "#ifdef"로 다시 돌아갑니다.
+ 조건문이 중첩되어있는 경우에도, 쌍을 이루는 지시자로 잘 이동합니다.
+"#endif"를 빼먹지는 않았는지 확인할 때 유용하겠지요.
+ 만약 "#if" - "#endif" 사이에 있다면, 다음 명령으로 조건부 영역이 시작되는
+곳으로 이동할 수 있습니다: >
+
+ [#
+
+"#if"나 "#ifdef" 뒤에 있는 것이 아니라면 삑 소리가 나며 동작하지 않을
+것입니다. 다음 "#else"나 "#endif"로 이동하려면: >
+
+ ]#
+
+이 두 가지 명령은 이동하면서 만나는 "#if" - "#endif" 블록은 모두 무시합니다.
+예를 들어:
+
+ #if defined(HAS_INC_H) ~
+ a = a + inc(); ~
+ # ifdef USE_THEME ~
+ a += 3; ~
+ # endif ~
+ set_width(a); ~
+
+커서가 마지막 줄에 있을 때, "[#"를 하면, 첫 번째 줄로 이동합니다. 중간에 있는
+"#ifdef" - "#endif" 영역은 무시하면서 말이지요.
+
+
+코드 블록을 돌아다니기
+
+C의 코드 블록은 {}로 구분됩니다. 블록 하나는 매우 길 수도 있지요. 바깥
+블록의 시작위치로 가려면 "[[" 명령을 사용하십시오. 끝 위치로 가려면 "]["
+명령을 사용하십시오. 단, 이 명령은 "{"와 "}"가 줄의 맨 앞인 첫 번째 열에 있는
+경우에만 동작합니다.
+ "[{" 명령은 현재 블록의 시작위치로 이동합니다. 쌍을 이루는 {} 는 모두
+무시하고 지나갑니다. "]}"은 끝 위치로 이동합니다.
+ 정리해봅시다:
+
+ function(int a)
+ +-> {
+ | if (a)
+ | +-> {
+ [[ | | for (;;) --+
+ | | +-> { |
+ | [{ | | foo(32); | --+
+ | | [{ | if (bar(a)) --+ | ]} |
+ +-- | +-- break; | ]} | |
+ | } <-+ | | ][
+ +-- foobar(a) | |
+ } <-+ |
+ } <-+
+
+C++ 나 Java에서는, 맨 바깥의 {}가 클래스(class)의 블록입니다. 실제
+메소드(method)의 블록은 그 안 쪽의 {}가 됩니다. 클래스의 안에서 위쪽에 있는
+메소드의 시작 위치는 "[m"으로 찾을 수 있습니다. "]m"은 이후의 메소드 끝을
+찾습니다.
+
+그리고, "[]"는 파일의 앞부분으로 움직이며 함수의 끝을 찾고, "]]"는 파일의
+뒷부분으로 움직이며 다음 함수의 시작을 찾습니다. 함수의 끝인 지는, 줄의 맨
+앞 첫번째 열에 "}"가 있는 지 여부로 결정됩니다.
+
+ int func1(void)
+ {
+ return 1;
+ +----------> }
+ |
+ [] | int func2(void)
+ | +-> {
+ | [[ | if (flag)
+ 시작위치 +-- +-- return flag;
+ | ][ | return 2;
+ | +-> }
+ ]] |
+ | int func3(void)
+ +----------> {
+ return 3;
+ }
+
+대응되는 (), {}, [] 쌍 사이를 이동할 때는 "%"를 사용하면 삶이 한결
+산뜻해집니다. 대응되는 쌍이 몇 줄 떨어져있어도 잘 동작합니다.
+
+
+괄호 안에서 이동하기
+
+"[(", "])"명령도 "[{", "]}"와 {} 쌍 대신 () 쌍을 찾는 다는 점만 다를 뿐,
+동일하게 동작합니다.
+>
+ [(
+< <--------------------------------
+ <-------
+ if (a == b && (c == d || (e > f)) && x > y) ~
+ -------------->
+ --------------------------------> >
+ ])
+
+
+주석 안에서 이동하기
+
+주석의 시작 부분으로 이동하려면 "[/"를 사용하십시오. 아래쪽으로 이동하면서
+주석의 끝을 찾으려면 "]/"를 사용하십시오. 단, /* - */ 형태의 주석에서만
+동작합니다.
+
+ +-> +-> /*
+ | [/ | * 멋진 삶에 대한 --+
+ [/ | +-- * 주석 | ]/
+ | */ <-+
+ |
+ +-- foo = bar * 3; --+
+ | ]/
+ /* 짧은 주석 */ <-+
+
+==============================================================================
+*29.4* 전역 이름 찾기
+
+C 프로그램을 작성 중에 어떤 변수가 "int"인지, "unsigned"인지 헷갈린다고
+합시다. 빠르게 확인할 수 있는 방법은 "[I" 명령을 사용하는 것입니다.
+ 커서가 "column"이란 단어에 있다고 합시다. 다음 명령을 입력하십시오: >
+
+ [I
+
+빔이 해당 되는 줄을 찾아서 보여줄 것입니다. 현재 파일이 아니어도, 인클루드 된
+파일도 모두 찾아줍니다 (물론 인클루드된 파일에 인클루드된 것도). 그러면 다음과
+같이 보입니다:
+
+ structs.h ~
+ 1: 29 unsigned column; /* 열 번호 */ ~
+
+태그나 미리보기창에 비해, 인클루드된 파일들까지 알아서 다 찾아준 다는 장점이
+있습니다. 대부분의 경우 정확한 선언 위치를 찾을 수 있습니다. 태그 파일이 최신이
+아니어서 틀린 정보를 갖고 있거나, 인클루드 된 파일들에 대한 태그 파일이 아예
+없더라도 말이지요.
+ 하지만, "[I"가 동작하기 위해서는 몇 가지가 제대로 설정되어야합니다.
+무엇보다, 'include'(인클루드) 설정에 어떻게 파일이 인클루드 되는 지
+지정되어야합니다. 기본값은 C와 C++에서 동작하도록 되어있습니다. 다른
+언어에서 사용하려면 적절히 바꿔주어야합니다.
+
+
+인클루드할 파일 위치 지정
+
+ 빔은 인클루드할 파일을 'path'(경로) 설정에 지정된 위치에서 찾습니다. 만약
+인클루드할 파일이 들어있는 디렉토리가 빠져있다면, 이 파일은 찾을 수 없습니다.
+어떤 파일을 찾을 수 없는 지는 다음 명령으로 확인할 수 있습니다: >
+
+ :checkpath
+
+위 명령은 찾을 수 없는 인클루드할 파일을 보여줍니다. 또한, 찾은 인클루드할
+파일이 인클루드 하는 파일 중 찾을 수 없는 파일도 보여줍니다. 결과는 다음과
+같습니다:
+
+ --- Included files not found in path --- ~
+ <io.h> ~
+ vim.h --> ~
+ <functions.h> ~
+ <clib/exec_protos.h> ~
+
+"io.h" 파일은 현재의 파일에서 인클루드했고, 찾을 수 없었습니다. "vim.h"는
+찾았고, ":checkpath"가 이 파일에서 인클루드하고 있는 파일들을 계속해서
+검사했습니다. "functions.h"와 "clib/exec_protos.h" 파일은 "vim.h"가
+인클루드했는데, 찾을 수 없었습니다.
+
+ Note:
+ 빔은 컴파일러가 아닙니다. 그래서 "#ifdef"를 해석하지 못합니다.
+ 즉, "#include"가 "#if NEVER" 다음에 나왔더라도 동작하는 "#include"로
+ 생각하고 파일을 찾습니다.
+
+파일을 못 찾을 때는, 파일이 있는 디렉토리를 'path' 설정에 추가하면 됩니다.
+아마도 Makefile을 찾아보면 어떤 디렉토리를 추가해야하는 지 알 수 있을
+것입니다. "-I"가 있는 줄을 찾아보십시오. 예를 들어, "-I/usr/local/X11"과 같은
+부분이 있다면, 다음 명령으로 이 디렉토리를 추가하면 됩니다: >
+
+ :set path+=/usr/local/X11
+
+하위 디렉토리가 많이 있다면, "*" 와일드카드를 사용해도 됩니다. 예제: >
+
+ :set path+=/usr/*/include
+
+위 명령으로 "/usr/local/include"나 "/usr/X11/include"에 있는 파일을 모두 찾을
+수 있게 됩니다.
+
+여러 단계로 하위 디렉토리가 뻗어있는 프로젝트에서 작업할 때는, "**" 가
+유용합니다. 하위 디렉토리를 계속 내려가면서 모두 찾아줍니다. 예제: >
+
+ :set path+=/projects/invent/**/include
+
+위 명령은 다음 디렉토리들의 파일들을 찾습니다:
+
+ /projects/invent/include ~
+ /projects/invent/main/include ~
+ /projects/invent/main/os/include ~
+ 등등
+
+이 외에도 'path' 설정 도움말을 보면, 더 다양한 방법들을 알 수 있습니다.
+ 실제로 어떤 파일들을 찾았는지 확인하려면, 다음 명령을 사용하십시오: >
+
+ :checkpath!
+
+인클루드한 파일과 이 파일들이 또 인클루드 한 파일들 등등의 (매우 긴) 목록을 볼
+수 있습니다. 목록을 짧게 만들기 위해, 빔은 이전에 나열했던 파일에 대해서는
+"(Already listed)"(전에 나왔음)라고 표시하고 이 파일이 인클루드하는 파일은
+다시 보여주지 않습니다.
+
+
+찾은 내용으로 이동하기
+
+"[I" 명령은 한 줄의 내용만 보여주는 목록을 만듭니다. 첫 번째 결과에 대해 좀
+더 자세히 살펴보려면, 다음 명령으로 직접 그 위치로 이동하면 됩니다: >
+
+ [<Tab>
+
+CTRL-I는 <Tab>과 동일하므로 "[ CTRL-I"를 사용해도 됩니다.
+
+"[I"가 보여주는 목록에는 각 줄마다 앞에 숫자가 붙어있습니다. 첫 번째가 아닌
+다른 결과로 이동하려면, 앞에 숫자를 붙여주면 됩니다: >
+
+ 3[<Tab>
+
+위 명령을 사용하면 목록의 세 번째 결과로 이동합니다. 이동하기 전 위치로
+돌아오려면 CTRL-O 를 사용하면 된다는 점, 잊지마세요.
+
+
+관련 명령
+
+ [i 첫 번째 결과만 보임
+ ]I 현재 위치 이후에서만 찾음
+ ]i 현재 위치 이후의 결과 중 첫 번째 결과만 보임
+
+
+매크로로 정의된 이름 찾기
+
+"[I"는 모든 이름을 찾습니다. "#define"으로 정의된 매크로만 찾으려면, 다음
+명령을 사용하십시오: >
+
+ [D
+
+이 명령도 인클루드한 파일들까지 찾습니다. 'define'(디파인) 설정으로 "[D"로
+찾을 매크로가 어떤 형식인지 지정할 수 있습니다. 이 설정을 바꾸어서 C나 C++이
+아닌 언어에서도 동작하도록 할 수 있겠지요.
+ "[D"와 관련된 다음 명령들도 있습니다:
+
+ [d 첫 번째 결과만 보임
+ ]D 현재 위치 이후에서만 찾음
+ ]d 현재 위치 이후의 결과 중 첫 번째 결과만 보임
+
+==============================================================================
+*29.5* 지역 이름 찾기
+
+"[I" 명령은 인클루드한 파일까지 모두 찾습니다. 커서 위치의 단어가 처음 사용된
+위치를 현재 파일 내에서만 찾고 이동하려면: >
+
+ gD
+
+힌트: gD는 Goto(이동) Definition(정의)를 의미합니다. 이 명령은 지역적으로(C
+언어에서라면 "스태틱(static)"으로) 선언된 변수나 함수를 찾을 때 유용합니다.
+다음 예에서 커서가 "counter"에 있다고 합시다:
+
+ +-> static int counter = 0;
+ |
+ | int get_counter(void)
+ gD | {
+ | ++counter;
+ +-- return counter;
+ }
+
+찾는 범위를 현재 함수로 좁히고 더 찾지 않게 하려면, 다음 명령을 사용하십시오:
+>
+
+ gd
+
+위 명령을 사용하면 현재 함수의 시작위치로 이동해서 현재 커서가 있는 단어가
+처음으로 나타나는 위치를 찾습니다. 사실, 위쪽으로 이동하면서 줄의 맨 처음
+첫 번째 열에 "{"이 나오는 곳을 찾고, 그 위에 빈 줄이 나타날 때까지 더
+올라갑니다. 그리고 그 위치부터 아래로 내려가면서 이름을 찾는 것입니다. 예를
+들어 (커서는 "idx"에 있다고 합시다):
+
+ int find_entry(char *name)
+ {
+ +-> int idx;
+ |
+ gd | for (idx = 0; idx < table_len; ++idx)
+ | if (strcmp(table[idx].name, name) == 0)
+ +-- return idx;
+ }
+
+==============================================================================
+
+다음 장: |usr_30.txt| 프로그램 편집하기
+
+저작권: |manual-copyright| 참고 vim:tw=78:ts=8:ft=help:norl:

Modified: 7.0/doc/usr_toc.kox
==============================================================================
--- 7.0/doc/usr_toc.kox (original)
+++ 7.0/doc/usr_toc.kox Sun May 4 20:17:12 2008
@@ -28,7 +28,7 @@
|usr_22.txt| 편집할 파일 찾기
|usr_23.txt| 특별한 파일 편집하기
|usr_24.txt| 빠르게 입력하기
-|usr_25.txt| 예쁘게 편집하기
+|usr_25.txt| 형식에 맞추어 편집하기
|usr_26.txt| 반복하기
|usr_27.txt| 찾기 명령과 패턴
|usr_28.txt| 접기