1.컨트롤의 명령

가.명령

명령이란 각종 편집 동작을 유발시키는 지시어이다. 삽입, 삭제, 이동, 선택, 스크롤, 복사 등의 편집 동작들이 모두 명령들이며 이외에 문서나 창을 관리하는 동작도 명령이 될 수 있다. 이런 동작들은 통상 사용자가 키보드나 마우스로 편집기를 직접 조작하여 실행되는 것이 보통이지만 프로그램 내부에서 필요에 의해 명령을 발생시키고 처리할 수도 있다. 편집기에 명령을 처리할 수 있는 기능을 작성해 놓으면 사용자의 개입없이 자동화된 처리를 할 수 있으며 그 대표적인 예가 바로 매크로이다.

매크로는 명령의 집합으로 정의되어 반복적인 작업을 할 때 키동작을 기억해 놓고 한꺼번에 여러 개의 명령을 여러 번 실행하는 장치이다. 편집 동작은 단순 반복적인 경우가 많은데 이런 지루한 작업을 사용자 대신 수행하는 것이 바로 매크로이다. 매크로는 반복적인 처리에 사용되기도 하지만 여러 개의 단순한 명령을 조합하여 새로운 복잡한 명령을 정의하는 수단이기도 하다. 예를 들어 두 칸 앞으로 가서 글자 지우기, 앞뒤 글자 바꾸기, 현재 문단의 사본을 아래쪽 문단에 작성하기 등의 가능해진다.

다소 고급 기능이다 보니 사용법을 익혀야 쓸 수 있고 초보자들이 쓰기에는 조금 어렵기는 하지만 제대로 활용하면 짧은 시간에 대량의 편집을 정확하게 할 수 있는 강력한 기능이다. 매크로는 최소한 두 개 이상의 명령이 모여야 실용적인 가치가 있다. 매크로에 포함된 명령들을 기억하는 방식은 다음 두 가지가 있다.

■ 문자열 : 명령을 문자열로 표기한다. 바로 읽고 편집할 수 있어 편리하지만 실행할 때마다 문자열을 해석해야 하므로 속도가 느리고 용량이 크다. 또한 문자열 입력 과정에서 오타가 발생할 가능성이 높으므로 섬세한 에러 처리도 필요하다.

■ 부호화 : 각 명령에 고유한 코드를 할당하고 이런 코드의 집합을 기억하는 방식이다. 이진 포맷이며 메타 파일 형식과 비슷하다고 생각하면 된다. 직접 편집은 불가능하지만 작성할 때 바로 해석되므로 에러 처리가 용이하고 실행 속도가 빠르다.

둘 다 나름대로의 장단점이 있는데 당근은 문자열 방식을 채택하기로 한다. 속도가 느리고 용량이 크기는 하지만 요즘의 하드웨어 환경에서는 성능보다 사용자의 편의성이 더 중요하므로 친근한 포맷인 문자열 방식을 채택했다. 명령은 한글로 정의할 수도 있으나 국제화 시대에 맞춰 간단한 영문 단어로 명령을 구성한다. 매크로 구문은 각 명령마다 조금씩 다른데 대체로 동사+목적어+회수의 형태를 가진다. 다음은 ApiEdit가 정의하는 명령 목록이다.

동작	목적어	설명
move	left right up down home end pgup pgdn wleft wright wordhome wordend dochome docend paren last nextpara prevpara parahome paraend	이동
movesel	left right up down home end pgup pgdn wleft wright wordhome worded dochome docend paren last nextpara prevpara parahome paraend	현재 위치에서 ~까지 선택
insert	"문자열"
delete
bs	char word
select	word line para doc
copy
copyapp
cut
cutapp
paste
convert	upper lower reversecase upperfirst uppersent totab tospace removespace indent unindent comment uncomment
copychar	up down
scroll	up down pgup pgdn halfup halfdown left right pageleft pageright
setmark	unname 1~0	토글 방식
gomark	next prior 1~0	북마크 이동
find	"문자열"	현재 위치에서 아래로. 실패시 매크로 종료
replace	"문자열1" "문자열2"
focus	next prev

여러 가지 테스트를 통해 필수적인 명령 목록을 만든 것인데 앞으로 더 많은 명령들이 추가될 것이다. 이 명령들이 매크로에 기록되며 매크로내의 명령은 순서대로 실행된다. 각 명령은 개행 코드 또는 세미콜론으로 구분되며 한 매크로에 포함될 수 있는 명령의 개수에는 제한이 없다.

관리의 편의상 명령을 구성하는 동사, 목적어들은 열거형으로 정의한다. 명령을 실행할 때마다 문자열 파싱을 할 수는 없으므로 한 번 분석한 명령은 열거형으로 관리하는 것이 효율적이다. 명령 구문 자체는 ApiEdit 컨트롤과 직접적인 연관이 없으므로 일반 함수들이 관리한다. 즉 ApiEdit 컨트롤 자체는 명령의 편집이나 관리에 관여하지 않고 함수들이 시키는 동작만 해석하여 처리한다. AeUtil.h에 열거형을 다음과 같이 선언한다.

enum {AEC_MOVE, AEC_MOVESEL, AEC_INSERT, AEC_DELETE, AEC_BS, AEC_SELECT,

AEC_COPY, AEC_COPYAPP, AEC_CUT, AEC_CUTAPP, AEC_PASTE, AEC_CONVERT, AEC_COPYCHAR,

AEC_SCROLL, AEC_SETMARK, AEC_GOMARK, AEC_FIND,AEC_REPLACE,AEC_FOCUS};

enum {AECM_LEFT, AECM_RIGHT, AECM_UP, AECM_DOWN, AECM_HOME, AECM_END, AECM_PGUP,

AECM_PGDN, AECM_WLEFT, AECM_WRIGHT, AECM_WORDHOME, AECM_WORDEND, AECM_DOCHOME,

AECM_DOCEND, AECM_PAREN,AECM_LAST, AECM_NEXTPARA, AECM_PREVPARA, AECM_PARAHOME,

AECM_PARAEND};

enum {AECS_WORD, AECS_LINE, AECS_PARA, AECS_DOC};

enum {AECC_UPPER, AECC_LOWER, AECC_REVERSECASE, AECC_UPPERFIRST, AECC_UPPSERSENT,

AECC_TOTAB, AECC_TOSAPCE, AECC_REMOVESPACE, AECC_INDENT, AECC_UNINDENT,

AECC_COMMENT, AECC_UNCOMMENT};

enum {AECS_UP, AECS_DOWN, AECS_PGUP, AECS_PGDN, AECS_HALFUP, AECS_HALFDOWN,

AECS_LEFT, AECS_RIGHT, AECS_PAGELEFT, AECS_PAGERIGHT};

AEC_로 시작되는 것은 명령이고 나머지는 명령의 목적이다. 열거형의 이름을 직관적으로 작성해 놓았으므로 이름을 보면 어떤 명령인지를 쉽게 알 수 있다. 예를 들어 AECM_DOCHOME은 이동 명령 중 문서의 처음으로 가라는 뜻이다.

나.명령 지원

ApiEdit가 매크로를 지원하려면 사용자의 직접적인 조작외에도 외부에서 주어진 명령에 의해 움직일 수 있어야 한다. 명령 지원을 위해 다음 네 개의 멤버 함수를 추가한다.

class CApiEditText : public CWindow

{

....

virtual void ProcessKey(UINT vk,BOOL bControl,BOOL bShift);

virtual void Select(int n);

virtual void Move(int n, BOOL bSelect);

virtual void Scroll(int nLine, int nCode=0);

파생 클래스에서 이 함수를 호출할 수도 있으므로 가상 함수로 선언했다. 이 함수들은 키 입력, 선택, 이동, 스크롤 등의 동작을 처리하는데 원래 이 코드들은 사용자의 키 조작에 의해서만 호출되었다. 그러나 이제는 명령에 의해서도 호출될 수 있으므로 좀 더 범용적인 동작을 지원하기 위해 함수로 분리했다.

예를 들어 키보드 입력을 처리하는 OnKey 함수는 쉬프트, 컨트롤 키의 상태를 실시간으로 조사하여 선택, 단어 단위 이동을 한다. 그러나 명령은 이 키의 상태를 참조하는 것이 아니라 목적어를 참조하므로 목적어대로 동작하는 함수가 필요한 것이다. ProcessKey 함수는 기존 OnKey의 동작을 수행하되 키보드가 아닌 인수의 지시를 따른다는 점이 다르다. ProcessKey 함수는 다음과 같이 작성한다.

void CApiEditText::ProcessKey(UINT vk,BOOL bControl,BOOL bShift)

{

int r,c;

int oldr;

int OldOff;

int toff;

switch (vk) {

....

}

}

switch (vk)이하의 코드는 OnKey에 있는 switch 블럭을 그대로 가져온 것이다. 실제 처리 코드가 ProcessKey로 옮겨졌으므로 OnKey는 다음과 같이 수정된다.

void CApiEditText::OnKey(HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags)

{

BOOL bShift, bControl;

bShift=((GetKeyState(VK_SHIFT) & 0x8000) != 0);

....

if (vk>='0' && vk<='9' && bControl) {

if (bShift) {

ToggleBookmark(-1,vk-'0');

} else {

GotoBookmark(vk-'0');

}

}

ProcessKey(vk,bControl,bShift);

if (bShift && !bColumnMode) {

ignoreVirt--;

}

if (bShift && bColumnMode && SelStart != SelEnd) {

SelExtraX=ExtraX;

}

}

bDragSel 모드와 북마크 단축키 처리, 열모드 처리 등은 그대로 두고 키를 직접 처리하는 모든 코드는 ProcessKey로 이동되었다. 지역 변수는 두 함수가 적당히 나누어 가져야 한다. ProcessKey는 인수로 전달된 bShift, bControl의 지시대로 이동 및 선택 동작을 처리하며 bUseLineEnd, bLineEnd, ExtraX 등은 전역 설정 상태의 영향을 받는다.

이렇게 되면 OnKey 함수는 자신의 코드 일부를 졸병 함수에게 나누어 주기만 했을 뿐 기능상의 변화가 없다. 그러나 실무 동작을 처리하는 함수를 하나 더 분리해 놓으면 매크로도 이 동작이 필요할 때 함수를 호출할 수 있어 활용성이 더 높아진다.

만약 이렇게 함수를 분리하지 않는다면 이동하면서 선택할 때 쉬프트 키가 눌러진 것처럼 OnKey 함수를 속여야 하는데 생각처럼 쉽지가 않다. 함수로 분리되어 있으면 bShift를 FALSE로 하여 ProcessKey 함수만 호출하면 된다. 프로그래밍에서는 함수를 잘 분리하는 기술이 아주 중요하다.

Move, Select 함수를 만든 이유도 ProcessKey 함수를 만든 이유와 비슷한데 사용자의 조작없이도 이동이나 선택 명령을 처리해야 하고 또한 키보드로 직접 처리할 수 없는 명령들도 실행해야 한다. Move는 인수로 전달된 n에 따라 이동 및 선택 대상이 달라지는데 이 값은 매크로 명령어의 목적어와 일치시켜 두었다. bSelect가 TRUE이면 이동한 곳까지 선택을 확장한다.

void CApiEditText::Move(int n, BOOL bSelect)

{

int pr, pc;

int toff;

GetParaFromOff(off,pr,pc);

switch (n) {

case AECM_LAST:

toff=pFrame->LastEditOff;

break;

case AECM_WORDHOME:

toff=off;

if (toff == 0)

break;

// 단어 끝 구분자에 있는 경우를 위해 일단 한칸 앞으로 이동.

for (toff--;;toff--) {

if (IsDelimiter(toff) || toff==0)

break;

}

if (toff !=0)

toff++;

break;

case AECM_WORDEND:

for (toff=off;;toff++) {

if (IsDelimiter(toff))

break;

}

break;

case AECM_NEXTPARA:

pr++;

toff=GetOffFromPara(pr,0);

if (toff==-1) {

return;

}

break;

case AECM_PREVPARA:

pr--;

toff=GetOffFromPara(pr,0);

if (toff==-1) {

return;

}

break;

case AECM_PARAHOME:

toff=pLine[GetParaFirstLine(pr)].Start;

break;

case AECM_PARAEND:

GetParaFromOff(off,pr,pc);

toff=pLine[GetParaLastLine(pr)].End;

break;

default:

return;

}

if (bSelect) {

ExpandSelection(off,toff);

off=toff;

} else {

off=toff;

ClearSelection();

}

SetCaret();

}

void CApiEditText::Select(int n)

{

int r,c;

int pr,pc;

switch (n) {

case AECS_WORD:

GetNowWord(off,SelStart,SelEnd);

SetSelect(SelStart,SelEnd,FALSE);

break;

case AECS_LINE:

GetRCFromOff(off,r,c);

SelStart=pLine[r].Start;

SelEnd=pFrame->IncludeEnter(pLine[r].End);

SetSelect(SelStart,SelEnd,FALSE);

break;

case AECS_PARA:

GetParaFromOff(off,pr,pc);

SelStart=pLine[GetParaFirstLine(pr)].Start;

SelEnd=pFrame->IncludeEnter(pLine[GetParaLastLine(pr)].End);

SetSelect(SelStart,SelEnd,FALSE);

break;

case AECS_DOC:

SendMessage(hWnd,WM_COMMAND,MAKEWPARAM(IDM_AE_SELALL,0),0);

break;

default:

return;

}

}

문단이나 줄을 선택할 때는 뒷부분의 개행 코드도 포함해야 하므로 IncludeEnter 함수를 호출한다. Scroll 함수는 nLine만큼 스크롤하되 nCode가 0이 아닐 때는 nCode가 지시하는만큼 스크롤 줄 수를 직접 계산한다. nCode가 1, -1일 때는 페이지 단위로 아래, 위로 스크롤하는 것이고 2, -2일 때는 반 페이지 단위로 아래, 위로 스크롤 하는 것이다.

페이지 단위로 스크롤 하려면 frt와 LineHeight로부터 스크롤할 줄 수를 계산해야 하는데 이 멤버들은 숨겨져 있으므로 외부에서는 한 페이지가 몇 줄인지 계산할 수 없다. 그래서 nCode로 스크롤할 논리적인 분량을 전달하면 뷰가 직접 스크롤할 양을 계산한다. Scroll 함수는 nLine으로 지정한 절대 줄 수만큼 또는 nCode로 지정한 논리적인 양만큼 스크롤한다.

void CApiEditText::Scroll(int nLine, int nCode/*=0*/)

{

int yInc;

int LinePerPage;

RECT srt;

if (nCode) {

switch (nCode) {

case 1:

SendMessage(hWnd,WM_VSCROLL,MAKELONG(SB_PAGEDOWN,0),0);

return;

case -1:

SendMessage(hWnd,WM_VSCROLL,MAKELONG(SB_PAGEUP,0),0);

return;

case 2:

nLine=frt.bottom/LineHeight/2;

break;

case -2:

nLine=-frt.bottom/LineHeight/2;

break;

}

}

LinePerPage=(frt.bottom/LineHeight)*LineHeight;

yInc=LineHeight*nLine;

yInc=max(-yPos, min(yInc, yMax-yPos-LinePerPage));

yInc=yInc-(yInc % LineHeight);

yPos=yPos+yInc;

srt=frt;

srt.left=0;

ScrollWindow(hWnd, 0, -yInc, &srt, &srt);

if (IsWindowEnabled(hVertScroll)) {

SetScrollPos(hVertScroll, SB_CTL, yPos, TRUE);

}

SetCaret(FALSE,FALSE);

}

명령에 의해 이동하는 Move 함수가 만들어졌고 이 함수의 목적어 중에 최후 편집 위치로 이동하는 AECM_LAST가 있으므로 GotoLastEditOff 함수는 사실상 Move(AECM_LAST ,FALSE)와 동일하다. 그래서 다음과 같이 수정한다.

void CApiEditText::GotoLastEditOff()

{

Move(AECM_LAST,FALSE);

}

물론 원래 코드도 잘 동작하므로 그대로 두어도 상관없지만 일관성을 위해 수정했다. Move 명령에 최후 편집 위치로 이동 코드가 작성되었으므로 사실 GotoLastEditOff 함수 자체가 불필요하지만 인터페이스 유지를 위해 이 함수는 그대로 두기로 한다. 별 실용성은 없지만 Move(AECM_LAST,TRUE) 명령은 현재 위치에서 최후 편집 위치까지 선택하라는 새로운 명령이 된다.

다.헥사 뷰 수정

명령을 처리하기 위해 기본 뷰의 키보드 처리, 이동, 선택 동작을 함수로 분리했다. 헥사 뷰는 이 동작들이 기본 뷰와는 다소 다르므로 ProcessKey, Move, Select 함수들을 재정의해야 한다. 단, Scroll 함수는 재사용할 수 있으므로 그대로 상속받으면 된다.

class CApiEditHexa : public CApiEditText

{

....

void ProcessKey(UINT vk,BOOL bControl,BOOL bShift);

void Select(int n);

void Move(int n, BOOL bSelect);

};

기본 뷰에서와 마찬가지로 OnKey 함수의 switch문과 지역 변수만 ProcessKey 함수로 가져온다. 헥사뷰에서의 키입력 처리는 텍스트 뷰와는 상당히 다르다.

void CApiEditHexa::ProcessKey(UINT vk,BOOL bControl,BOOL bShift)

{

int r,c;

int oldr;

int OldOff;

switch (vk) {

....

}

}

void CApiEditHexa::OnKey(HWND hWnd, UINT vk, BOOL fDown, int cRepeat, UINT flags)

{

BOOL bShift, bControl;

bShift=((GetKeyState(VK_SHIFT) & 0x8000) != 0);

....

bFindSelect=FALSE;

ProcessKey(vk,bControl,bShift);

}

Move와 Select 함수도 재정의하되 이 함수들은 기본 뷰의 코드를 대부분 재사용할 수 있으므로 길이가 훨씬 더 짧다. 대부분의 처리를 기본 뷰로 넘기기만 하면 된다.

void CApiEditHexa::Move(int n, BOOL bSelect)

{

switch (n) {

case AECM_LAST:

case AECM_WORDHOME:

case AECM_WORDEND:

CApiEditText::Move(n,bSelect);

break;

case AECM_NEXTPARA:

case AECM_PREVPARA:

case AECM_PARAHOME:

case AECM_PARAEND:

break;

}

}

void CApiEditHexa::Select(int n)

{

switch (n) {

case AECS_WORD:

case AECS_DOC:

CApiEditText::Select(n);

break;

case AECS_LINE:

case AECS_PARA:

break;

}

}

헥사 뷰는 최후 편집 위치나 단어의 개념은 있지만 문단의 개념이 없으므로 이 명령들은 실행하지 말아야 한다. 헥사 뷰는 pLine을 참조하는 모든 명령을 무시해야 한다. 여기까지 작성한 후 실행해 보면 아직까지 달라진 것은 아무 것도 없으며 이전 버전과 완전히 동일하게 동작한다. 그러나 내부 구조는 많이 수정되었는데 명령을 실행할 수 있는 함수군을 보유하게 되었다.

라.명령의 정의

앞에서 도표로 작성했던 명령들은 코드에서 구조체로 표현되며 명령의 집합은 구조체 배열로 작성된다. 사용자가 명령의 목록을 외우지는 못하므로 대화상자에 목록을 표시해야 하므로 문자열 형태로 된 명령 목록이 필요하다. 다음 두 구조체를 AeUtil.h에 선언한다.

struct SMacVerb

{

TCHAR *Name;

TCHAR *Desc;

DWORD Flag;

};

struct SMacObject

{

TCHAR *Name;

TCHAR *Desc;

};

extern SMacVerb arComVerb[];

extern SMacObject arComObject[];

extern int arObjOfVerb[];

SMacVerb는 매크로 명령 하나에 대한 정보이다. Name은 명령의 이름, Desc는 명령에 대한 간단한 설명이며 Flag는 명령의 속성이다. Falg는 두 개의 비트로 구성된다. b0는 명령을 반복적으로 실행할 수 있는가를 지정하며 이 플래그에 따라 카운트값을 가지는가 아닌가를 결정한다. 이동이나 삭제 등은 반복적으로 실행할 수 있지만 복사나 삽입은 반복적으로 실행할 수 없다. b1은 목적어가 있는지를 지정하는데 이 값이 0이면 목적어가 없는 단독 명령이다.

SMacObject는 명령의 목적어에 대한 정보이다. Name은 목적어의 이름이고 Desc는 목적어에 대한 간단한 설명이다. 이 두 구조체의 배열로 명령어와 목적어 목록을 작성하며 이 목록은 외부에서도 자주 참조되므로 미리 extern 선언해 두었다. AeUtil.cpp에는 구조체 배열을 다음과 같이 초기화한다.

// 동사 배열

// Flag의 b0=반복 가능성, b1=목적어 유무(문자열 목적어는 제외)

SMacVerb arComVerb[]={

{"move","이동",0x03},

{"movesel","선택이동",0x03},

{"insert","삽입",0x00},

{"delete","삭제",0x01},

{"bs","앞문자 삭제",0x03},

{"select","선택",0x02},

{"copy","복사",0x00},

{"copyapp","복사해서 추가",0x00},

{"cut","잘라내기",0x00},

{"cutapp","잘라서 추가",0x00},

{"paste","붙여넣기",0x01},

{"convert","변환",0x03},

{"copychar","위아래 문자 반복",0x03},

{"scroll","스크롤",0x03},

{"setmark","책갈피 설정",0x02},

{"gomark","책갈피 이동",0x02},

{"find","찾기",0x00},

{"replace","바꾸기",0x00},

{"focus","뷰 전환",0x03},

{"","",0x00}

};

// 목적어 배열

SMacObject arComObject[]={

{"left","왼쪽"}, // move:0

{"right","오른쪽"},

{"up","위로"},

{"down","아래로"},

{"home","줄 처음으로"},

{"end","줄 끝으로"},

{"pgup","페이지 위로"},

{"pgdn","페이지 아래로"},

{"wleft","이전 단어로"},

{"wright","이후 단어"},

{"wordhome","단어 처음으로"},

{"wordend","단어 끝으로"},

{"dochome","문서 처음"},

{"docend","문서 끝"},

{"paren","대응되는 괄호"},

{"last","마지막 편집 위치"},

{"nextpara","다음 문단"},

{"prevpara","이전 문단"},

{"parahome","문단 처음"},

{"paraend","문단 끝"},

{NULL,NULL},

{"char","문자"}, // bs:21

{"word","단어"},

{NULL,NULL},

{"word","단어"}, // select:24

{"line","줄"},

{"para","문단"},

{"doc","문서"},

{NULL,NULL},

{"upper","대문자로"}, // convert:29

{"lower","소문자로"},

{"reversecase","대소 반대로"},

{"upperfirst","첫글자만 대문자로"},

{"uppersent","문장 처음만 대문자로"},

{"totab","공백을 탭으로"},

{"tospace","탭을 공백으로"},

{"removespace","불필요한 공백 제거"},

{"indent","들여쓰기"},

{"unindent","내어쓰기"},

{"comment","주석으로"},

{"uncomment","주석제거"},

{NULL,NULL},

{"up","윗줄 문자"}, // copychar:42

{"down","아래줄 문자"},

{NULL,NULL},

{"up","위"}, // scroll:45

{"down","아래"},

{"pgup","페이지 위"},

{"pgdn","페이지 아래"},

{"halfup","반 페이지 위"},

{"halfdown","반 페이지 아래"},

{"left","왼쪽"},

{"right","오른쪽"},

{"pageleft","페이지 왼쪽"},

{"pageright","페이지 오른쪽"},

{NULL,NULL},

{"unname","이름없는 북마크"}, // setmark:56

{"0","0번 북마크"},

{"1","1번 북마크"},

{"2","2번 북마크"},

{"3","3번 북마크"},

{"4","4번 북마크"},

{"5","5번 북마크"},

{"6","6번 북마크"},

{"7","7번 북마크"},

{"8","8번 북마크"},

{"9","9번 북마크"},

{NULL,NULL},

{"next","다음 북마크"}, // gomark:68

{"prev","이전 북마크"},

{"0","0번 북마크"},

{"1","1번 북마크"},

{"2","2번 북마크"},

{"3","3번 북마크"},

{"4","4번 북마크"},

{"5","5번 북마크"},

{"6","6번 북마크"},

{"7","7번 북마크"},

{"8","8번 북마크"},

{"9","9번 북마크"},

{"next","다음 보기"}, // focus:80

{"prev","이전 보기"},

{NULL,NULL}

};

// 각 동사별 목적어 배열상의 시작 첨자

int arObjOfVerb[]={0,0,-1,-1,21,24,-1,-1,-1,-1,-1,29,42,45,56,68,-1,-1,80};

arComVerb는 명령을 구성하는 동사의 목록이고 arComObject는 목적어의 목록이다. 동사별로 목적어의 목록과 개수가 다르므로 모든 목적어를 하나의 배열에 작성하고 각 동사별 목적어의 시작 인덱스를 arObjOfVerb 배열에 따로 작성했다. 예를 들어 이동과 선택이동 동사의 목적어는 0부터 시작하고 삽입, 삭제는 목적어가 없으며 앞문자 삭제의 목적어는 21부터이다.

특정 동사의 목적어 시작 위치는 arObjOfVerb에서 구할 수 있고 arComObject 배열에서 이 위치 이후 이름이 NULL이 아닌 요소를 모두 읽으면 목적어 목록을 구할 수 있다. 조금 복잡해 보이기는 한데 메모리를 아끼기 위해 이런 방법을 사용한다. AeUtil.h에서 extern 선언을 해 두었으므로 호스트에서 이 배열을 곧바로 참조할 수 있다.

마.명령 관리 함수

매크로는 문자열 포맷으로 작성되는데 문자열은 부호화된 코드에 비해 다루기가 굉장히 까다롭다. 명령이나 목적으로 추출하기 위해서는 문자열 비교를 해야 한다. 게다가 사용자가 정확하게 명령을 작성한다면 간단해지겠지만 공백이나 따옴표 등의 구두점을 임의대로 작성할 수 있어 이런 에러 처리까지 하자면 무척 복잡해진다. 그래서 매크로 구문 해석을 위한 도우미 함수들을 작성하고 이 함수들로 매크로를 해석한다. 다음 함수의 원형을 AeUtil.h에 선언한다.

void SkipSpace(const TCHAR *&pc);

BOOL SkipString(const TCHAR *&pc);

void AeEscapeChar(const TCHAR *&s,TCHAR *&d);

int GetComVerb(const TCHAR *&szCom,SMacVerb *arVerb);

int GetComObject(int Verb,const TCHAR *&szCom,SMacObject *arObject,int *arObj);

void GetComString(const TCHAR *&szCom,TCHAR *&str,BOOL bEscape=TRUE);

int GetComNumber(const TCHAR *szCom,int Min);

이 함수들은 일반적인 문자열을 다루기 때문에 멤버 함수가 아니라 일반 함수이다. FindString 함수 다음에 원형을 선언하면 된다. 함수의 본체는 물론 AeUtil.cpp에 작성한다. 다음 두 함수는 문자열 처리를 위한 유틸리티 함수이다.

// 공백을 건너뛴다.

void SkipSpace(const TCHAR *&pc)

{

for (;*pc;pc++) {

if (*pc!=' ' && *pc!='\t')

break;

}

}

// 문자열을 만나면 문자열 끝까지 건너뜀. pc는 닫는 따옴표에 위치함.

// 닫는 따옴표가 없으면 FALSE를 리턴한다.

BOOL SkipString(const TCHAR *&pc)

{

if (*pc=='\"') {

for (pc++;;pc++) {

if (*pc==NULL) {

return FALSE;

}

if (*pc=='\"' && *(pc-1)!='\\') {

break;

}

}

}

return TRUE;

}

SkipSpace 함수는 공백을 건너 뛴다. "move right"라고 항상 똑바로 써 주면 이런 처리가 필요없으나 "move right" 요렇게 쓰는 사람도 있고 동사와 목적어 사이에 탭을 쓰는 사람도 있기 때문에 이 함수가 필요하다. SkipString 함수는 문자열을 건너 뛴다. 여는 따옴표 위치에서 이 함수를 호출하면 닫는 따옴표 위치를 찾는다. 굉장히 간단할 것 같지만 닫는 따옴표가 없을 수도 있고 문자열 내의 확장열을 고려해야 하기 때문에 계산이 필요하다.

확장열이란 문자열내에 포함되는 일종의 특수 문자인데 C언어의 확장열과 개념적으로 동일하다. 따옴표안에 따옴표나 개행코드를 담을 수 없기 때문에 확장열이 필요하다. 확장열은 \로 시작하며 다음과 같은 종류가 있다. 대체로 C언어의 확장열과 유사하게 정의했다.

확장열	문자
\n	개행 코드이다. \r\n으로 확장된다.
\t	탭이다. \t로 확장된다.
\x	16진 문자 코드. 뒤에 반드시 두자리의 16진수가 와야 한다.
\i	10진 문자 코드, 뒤에 반드시 세자리의 255이하의 10진수가 와야 한다.
\"	따옴표 문자로 확장된다. 닫는 따옴표로 인정되지 않는다.
\\	역슬레쉬 문자 자체이다.

\r이나 기타 \a, \b같이 지원되지 않는 확장열들은 무시된다. \x 다음에 반드시 두 자리의 16진수가 와야 하는 제약이 좀 마음에 안 들 수도 있다. \x0라고 하면 그냥 널 문자를 표현할 수 있다면 좋겠지만 반드시 \x00로 써야 한다. 이런 제약이 없다면 \xbapple같은 검색식의 경우 16진수 0xba 다음의 pple를 의미하는 것인지 아니면 0xb 다음의 apple을 말하는 껏인지 구분되지 않는 문제가 있다. 그래서 두자리까지 무조건 읽는다. AeEscapeChar 함수는 따옴표나 \r, \t 등의 확장열을 실제 문자로 대체한다.

// 문자 하나를 이스케이프한다. 위치 이동까지 해 준다.

void AeEscapeChar(const TCHAR *&s,TCHAR *&d)

{

TCHAR high,low,third;

int code;

if (*s=='\\') {

s++;

switch (*s) {

case '\\':

*d++='\\';

break;

// 제일 끝에 \하나만 있는 경우. \문자로 인정하고 s를 증가시키지 않고 리턴

case NULL:

*d++='\\';

return;

case 'n':

case 'N':

*d++='\r';

*d++='\n';

break;

case 't':

case 'T':

*d++='\t';

break;

// 찾기에서는 꼭 할 필요가 없다. 바로 "를 쓸 수도 있다.

case '\"':

*d++='\"';

break;

// 16진 코드 처리

case 'x':

case 'X':

s++;

if (*s==NULL) return;

high=*s;

s++;

if (*s==NULL) return;

if (IsCharLower(high)) high-=0x20;

if (high >= '0' && high <= '9') {

high=high-'0';

} else if (high >= 'A' && high <= 'F') {

high=high-'A'+10;

} else {

break;

}

low=*s;

if (IsCharLower(low)) low-=0x20;

if (low >= '0' && low <= '9') {

low=low-'0';

} else if (low >= 'A' && low <= 'F') {

low=low-'A'+10;

} else {

break;

}

*d++=(high << 4 | low);

break;

// 10진 코드 처리

case 'i':

case 'I':

s++;

if (*s==NULL) return;

high=*s;

s++;

if (*s==NULL) return;

if (high >= '0' && high <= '9') {

high=high-'0';

} else {

s++;

break;

}

low=*s;

s++;

if (*s==NULL) return;

if (low >= '0' && low <= '9') {

low=low-'0';

} else {

break;

}

third=*s;

if (third >= '0' && third <= '9') {

third=third-'0';

} else {

break;

}

code=high*100+low*10+third;

if (code < 256) {

*d++=code;

}

break;

// 확장열이 아닌 문자는 무시함. 예를 들어 혼자 오는 \r등.

default:

break;

}

} else {

*d++=*s;

}

s++;

}

대소문자는 구분하지 않으며 에러가 있을 경우 무시한다. 예를 들어 \xgg나 \a, \i567 이런 것은 통째로 없는 것으로 취급한다. 끝에 \혼자만 있으면 \문자로 인정한다. \x 다음에 두 자리 숫자가 없거나 \i다음에 세 자리 숫자가 없으면 무시한다. 다음 두 함수는 동사와 목적으로 찾는다. 찾은 후 포인터는 항상 그 다음 위치로 이동시키는 특성이 있다.

// 동사를 찾아준다. 에러일 경우 -1을 리턴한다. 동사 다음으로 포인터를 옮겨 준다.

int GetComVerb(const TCHAR *&szCom,SMacVerb *arVerb)

{

TCHAR szVerb[32];

TCHAR *p;

int idx;

// 동사 부분만 따로 분리한다.

lstrcpyn(szVerb,szCom,32);

for (p=szVerb;*p!=NULL;p++) {

if (*p==' ') {

*p=NULL;

break;

}

}

for (idx=0;;idx++) {

if (lstrlen(arVerb[idx].Name) == 0) {

idx=-1;

break;

}

if (strcmpi(arVerb[idx].Name,szVerb)==0) {

break;

}

}

szCom += lstrlen(szVerb);

SkipSpace(szCom);

return idx;

}

// 목적어를 찾아준다. 에러일 경우 -1을 리턴한다. 목적어가 있는 동사만 이 함수를 호출하므로 -1을 리턴해도 별 상관없다.

// 목적어 다음으로 포인터를 옮겨 준다.

int GetComObject(int Verb,const TCHAR *&szCom,SMacObject *arObject,int *arObj)

{

TCHAR szObject[32];

TCHAR *p;

int stidx;

int idx;

// 목적어 배열에서 시작 인덱스 찾음. 시작이 -1이면 목적어가 없는 동사임

stidx=arObj[Verb];

if (stidx==-1) {

return -1;

}

// 목적어 부분만 따로 분리한다. 공백이나 탭을 만나면 목적어의 끝

lstrcpyn(szObject,szCom,32);

for (p=szObject;*p!=NULL;p++) {

if (*p==' ' || *p=='\t') {

*p=NULL;

break;

}

}

for (idx=stidx;arObject[idx].Name!=NULL;idx++) {

if (strcmpi(arObject[idx].Name,szObject)==0) {

break;

}

}

if (arObject[idx].Name==NULL) {

idx=-1;

} else {

idx-=stidx;

}

// 목적어 다음으로 포인터를 옮겨준다.

szCom += lstrlen(szObject);

SkipSpace(szCom);

return idx;

}

다음 함수는 문자열을 추출한다. 문자열의 길이를 미리 알 수 없기 때문에 이 함수에서 문자열 저장을 위한 버퍼를 할당하고 호출원에서 해제해야 한다. 문자열내의 확장열을 지원한다.

// 따옴표 다음에 있는 문자열을 추출해 준다. 메모리를 여기서 할당하고 호출원에서 해제한다.

// 문자열 다음으로 포인터를 옮겨준다.

void GetComString(const TCHAR *&szCom,TCHAR *&str,BOOL bEscape/*=TRUE*/)

{

int len;

const TCHAR *pc;

TCHAR *p;

// 추출될 최대 문자열의 길이만큼 할당

len=lstrlen(szCom);

str=(TCHAR *)malloc(len);

// 따옴표 다음 문자부터 복사를 시작한다. 확장열 처리

for (pc=szCom+1,p=str;;) {

// 닫는 따옴표가 없다는 뜻임. 에러로 처리된다.

if (*pc==NULL) {

free(str);

str=NULL;

break;

}

// 닫는 따옴표. 문자열의 끝

if (*pc=='\"') {

*p=0;

break;

}

if (bEscape) {

AeEscapeChar(pc,p);

// 확장열을 확장하지 않을 때. 모든 문자를 그대로 조사하되 단, 위 루프에서 \"를 인식하지 않도록

// 이 확장열만 따로 복사해준다.

} else {

if (*pc=='\\' && *(pc+1)=='\"') {

*p++=*pc++;

*p++=*pc++;

} else {

*p++=*pc++;

}

}

}

// 문자열 다음으로 포인터를 보낸다.

szCom = pc+1;

SkipSpace(szCom);

}

// szCom 문자열에서 숫자를 읽어준다. 최소한의 값을 지정할 수 있다.

int GetComNumber(const TCHAR *szCom,int Min)

{

return max(Min,atoi(szCom));

}

확장열은 에러 발생 가능성이 높으로 에러를 잘 처리해야 한다. 이 함수들은 매크로 구문을 해석할 때 사용된다.

바.문자열 관리 함수

당근은 여러 객체에 문자열로 이름을 주기 때문에 문자열에 대한 예외 처리가 필요하다. 예를 들어 매크로 이름이 제대로 입력되었는지 검사할 때 이 문자열이 비어 있는지 아닌지 봐야 한다. 길이를 점검하는 것만으로는 부정확하다. 공백이나 탭은 아무리 많이 들어가 있어도 이름으로 인정되지 않기 때문이다.

또한 문자열을 정규화할 필요도 있다. "move right"와 " move right", "move right "는 공백 구성만 제외하고는 완전히 같다. 하지만 문자열을 비교하는 strcmp 함수는 다른 것으로 판별한다. 그래서 앞뒤의 불필요한 공백은 제거하고 중간의 공백이나 탭은 하나로 정규화할 필요가 있다. 마치 웹 브라우저가 HTML 문서의 불필요한 공백을 모두 제거하는 것과 같다. 다음 두 함수를 Util.cpp에 추가하고 헤더 파일에 원형도 선언한다.

BOOL IsStrEmpty(TCHAR *str)

{

int len,i;

BOOL bEmpty=TRUE;

len=lstrlen(str);

// 길이가 0이면 비어있다.

if (len == 0) {

return TRUE;

}

// 공백이나 탭 문자 외에 다른 문자가 있으면 비어있지 않다.

for (i=0;i<len;i++) {

if ((str[i]!=' ') && (str[i]!='\t')) {

bEmpty=FALSE;

break;

}

}

return bEmpty;

}

void StringNormalize(TCHAR *src, TCHAR *dest)

{

TCHAR *s,*d;

TCHAR *dest2;

s=src;

if (dest==NULL) {

d=dest2=(TCHAR *)malloc(lstrlen(src)+1);

} else {

d=dest;

}

SkipSpace(const_cast<const TCHAR *&>(s));

// 중간의 공백 정리

for (;*s;) {

if (*s==' ' || *s=='\t') {

*d++=' ';

SkipSpace(const_cast<const TCHAR *&>(s));

} else {

*d++=*s++;

}

}

*d=0;

// 끝 공백 하나가 있으면 제거

if (d > dest && d[-1]==' ') {

d[-1]=0;

}

if (dest==NULL) {

lstrcpy(src,dest2);

free(dest2);

}

}

IsStrEmpty 함수는 str 문자열이 비어 있는지 아닌지를 점검한다. 코드는 읽으면 바로 해석될 정도로 쉽다. 길이가 0이면 이 문자열은 더 볼 것도 없이 빈 것이다. 그렇지 않을 경우 문자열 전체를 순회하며 공백이나 탭이 아닌 문자가 있는지 점검하는데 최소한 하나 이상의 문자가 있어야 비어 있지 않다. 만약 문자열 전체가 탭이나 공백으로만 구성되어 있다면 이 문자열은 실제 내용이 없는 빈 문자열이다.

StringNormalize 함수는 문자열을 정규화한다. 앞쪽의 공백을 제거하고 중간의 공백은 스페이스 하나로 정리하고 뒤쪽의 공백도 제거한다. dest는 반드시 src와 같거나 더 길어야 한다. 아니면 아예 NULL로 주어 src에 변환 결과를 돌려 받을 수도 있다. 그래서 src는 상수성을 가지지 않으며 SkipSpace로 src의 포인터를 전달할 때는 상수 캐스팅을 해야 한다. 이 캐스팅인 비주얼 C++ 6.0에서는 필요치 않지만 훨씬 더 엄격한 타입체크를 하는 VC 8.0에서는 필요하다.

문자열 정규화를 위해 AeUtil.cpp에 정의되어 있는 SkipSpace 함수를 호출하는데 당근은 ApiEdit에 종속적이므로 이렇게 해도 상관없다. 물론 그 반대여서는 안된다. 만약 StringNormalize 함수를 다른 프로젝트에 쓰고 싶다면 SkipString 함수도 같이 가지고 가야 한다. 빈 문자열 점검과 정규화 함수는 이후 매크로 이름 등의 유효성을 점검할 때 사용된다. 이 함수들이 완성된 김에 1.0의 사소한 버그 몇 개도 수정하자. 프로젝트의 이름을 입력받는 부분에 이 함수들을 적용해야 하는데 Project.cpp의 원래 코드를 보면 문제가 있다.

BOOL CALLBACK DgNewProjectProc(HWND hDlg,UINT iMessage,WPARAM wParam,LPARAM lParam)

{

....

case IDOK:

....

GetDlgItemText(hDlg,IDC_PRJNEWNAME,Header.Name,32);

if (lstrlen(Header.Name)==0) {

MessageBox(hDlg,"프로젝트의 이름은 반드시 입력해야 합니다","알림",MB_OK);

return TRUE;

}

프로젝트 이름의 길이가 0이면 무효라고 판단하고 경고 메시지를 출력한다. 이름이 없으면 구분이 되지 않기 때문에 반드시 이름을 입력하도록 강제하는 것이다. 그렇다면 공백 하나만 입력하면 유효하다고 판단하는데 이것도 사실 문제가 있는 것이다. 다음과 같이 수정한다.

case IDOK:

....

GetDlgItemText(hDlg,IDC_PRJNEWNAME,Header.Name,32);

if (IsStrEmpty(Header.Name)) {

MessageBox(hDlg,"프로젝트의 이름은 반드시 입력해야 합니다","알림",MB_OK);

return TRUE;

}

StringNormalize(Header.Name,NULL);

공백으로만 구성된 이름은 프로젝트 이름으로 인정하지 않아야 한다. 여기에 정규화까지 하여 프로젝트 이름이 일정한 형식을 가지게 했다. Inertnet.cpp에 있는 FTP 서버의 등록 정보도 마찬가지로 수정해야 한다.

BOOL CALLBACK DGFtpConfigProc(HWND hDlg,UINT iMessage,WPARAM wParam,LPARAM lParam)

{

static int idx;

TCHAR szTemp[256];

switch(iMessage) {

case WM_INITDIALOG:

....

case WM_COMMAND:

switch (LOWORD(wParam)) {

case IDOK:

GetDlgItemText(hDlg,IDC_FTPNAME,szTemp,32);

if (IsStrEmpty(szTemp)) {

MessageBox(hDlg,"접속명을 입력해 주십시오","알림",MB_OK);

return TRUE;

}

GetDlgItemText(hDlg,IDC_FTPADDR,szTemp,256);

if (IsStrEmpty(szTemp)) {

MessageBox(hDlg,"서버의 주소를 입력해 주십시오","알림",MB_OK);

return TRUE;

}

GetDlgItemText(hDlg,IDC_FTPUSER,szTemp,32);

if (IsStrEmpty(szTemp)) {

MessageBox(hDlg,"사용자 ID를 입력해 주십시오","알림",MB_OK);

return TRUE;

}

GetDlgItemText(hDlg,IDC_FTPPASS,szTemp,32);

if (IsStrEmpty(szTemp)) {

MessageBox(hDlg,"비밀번호를 입력해 주십시오","알림",MB_OK);

return TRUE;

}

GetDlgItemText(hDlg,IDC_FTPPORT,szTemp,32);

if (IsStrEmpty(szTemp)) {

MessageBox(hDlg,"접속 포트 번호를 입력해 주십시오","알림",MB_OK);

return TRUE;

}

if (idx==-1) {

for (idx=0;;idx++) {

if (lstrlen(Option.arFtp[idx].Name)==0)

break;

}

}

GetDlgItemText(hDlg,IDC_FTPNAME,Option.arFtp[idx].Name,32);

StringNormalize(Option.arFtp[idx].Name,NULL);

GetDlgItemText(hDlg,IDC_FTPADDR,Option.arFtp[idx].Addr,256);

GetDlgItemText(hDlg,IDC_FTPUSER,Option.arFtp[idx].User,32);

GetDlgItemText(hDlg,IDC_FTPPASS,Option.arFtp[idx].Pass,32);

Option.arFtp[idx].Port=GetDlgItemInt(hDlg,IDC_FTPPORT,NULL,FALSE);

EndDialog(hDlg,IDOK);

return TRUE;

case IDCANCEL:

EndDialog(hDlg,IDCANCEL);

return TRUE;

}

return FALSE;

}

return FALSE;

}

에디트 컨트롤에 입력된 정보의 길이만으로 정보의 유효성을 점검하지 않고 IsStrEmpty 함수로 제대로 점검했다. 접속명에 대해서는 정규화까지 했다. 이런 에러 처리는 어떻게 보면 굉장히 사소한 문제일 수도 있지만 좀 더 완전한 프로그램이 되기 위해서는 무시할 수 없는 부분이다.

사.명령 실행

그럼 이제 관련 함수들이 완비되었으므로 매크로를 실행하는 함수를 만들어 보자. 문자열로 된 매크로만 전달하면 매크로에 포함된 명령들을 추출하여 편집 동작을 순서대로 실행해야 한다. 그렇다면 매크로를 실행하는 주체는 과연 누구일까? 매크로는 호스트가 실행할 수도 있고 컨트롤이 실행할 수도 있는데 당근은 컨트롤이 실행하는 것이 여러 가지 면에서 더 효율적이다.

호스트가 ApiEdit의 편집 명령을 일일이 호출하여 매크로를 실행하는 것도 하나의 방법이기는 하지만 이렇게 되면 매크로는 ApiEdit 기능 목록에서 제외되어 버리므로 좋지 않다. 또한 매크로내의 편집 명령들이 그룹을 구성해야 하기 때문에 호스트가 이 작업을 하기에는 적절하지 않다. ApiEdit에 매크로를 실행하는 두 개의 멤버 함수를 선언한다.

class CApiEdit : public CWindow

{

....

int DoCommand(const TCHAR *szCom);

void ExecMacro(const TCHAR *szMacro);

매크로는 명령들의 집합으로 구성된다. DoCommand 함수는 명령 하나만 실행하는 함수이며 ExecMacro는 매크로 전체를 실행하는 명령이다. ExecMacro가 매크로의 명령을 분리하여 DoCommand 함수를 차례대로 호출하는 구조이다. DoCommand는 모든 매크로 명령을 실행해야 하므로 덩치가 굉장히 크다. 각 명령에 대해 또 목적어에 대해 분기하는 거대한 switch 문으로 구성된다.

// 명령 실행. NULL 또는 개행을 만날 때까지를 하나의 명령으로 본다.

// 0: 정상 실행

// -1:동사 없음

// -2:지원되지 않는 목적어

// -3:닫는 따옴표 없음

int CApiEdit::DoCommand(const TCHAR *szCom)

{

int comlen;

const TCHAR *pc, *ps, *p;

TCHAR *Com, *pCom;

int Verb, Object;

TCHAR *str,*str2;

BOOL bShift;

int Result=0;

int Count, nCount;

DWORD tFlag;

CApiEditText *pView;

// 항상 활성뷰에 대해 동작해야 한다.

pView=GetActiveView();

// 선행 공백은 무시한다.

ps=szCom;

SkipSpace(ps);

// 주석이면 명령 전체를 무시한다.

if (*ps=='/' && *(ps+1)=='/') {

return 0;

}

// 명령어의 길이를 구한다. 널, 개행, 세미콜론이 문장의 끝이다.

for (pc=ps;;pc++) {

if (*pc==NULL || *pc=='\r' || *pc==';') {

break;

}

if (SkipString(pc)==FALSE) {

return -3;

}

}

comlen=pc-ps;

// szCom의 모든 문자는 소문자로, 단 따옴표 안은 제외. 닫는 따옴표가 있는지는 이미 체크했음

Com=(TCHAR *)malloc(comlen+1);

lstrcpyn(Com,ps,comlen+1);

for (pCom=Com;*pCom;pCom++) {

SkipString(const_cast<const TCHAR *&>(pCom));

if (IsCharUpper(*pCom)) {

*pCom+=0x20;

}

}

// 동사를 먼저 찾는다.

p=Com;

Verb=GetComVerb(p,arComVerb);

if (Verb==-1) {

Result=-1;

goto End;

}

switch (Verb) {

case AEC_MOVE:

case AEC_MOVESEL:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

if (Verb==AEC_MOVE) {

bShift=FALSE;

} else {

bShift=TRUE;

}

Count=GetComNumber(p,1);

for (nCount=0;nCount<Count;nCount++) {

switch (Object) {

default:

case -1:

Result=-2;

goto End;

case AECM_LEFT:

pView->ProcessKey(VK_LEFT,FALSE,bShift);

break;

case AECM_RIGHT:

pView->ProcessKey(VK_RIGHT,FALSE,bShift);

break;

case AECM_UP:

pView->ProcessKey(VK_UP,FALSE,bShift);

break;

case AECM_DOWN:

pView->ProcessKey(VK_DOWN,FALSE,bShift);

break;

case AECM_HOME:

pView->ProcessKey(VK_HOME,FALSE,bShift);

break;

case AECM_END:

pView->ProcessKey(VK_END,FALSE,bShift);

break;

case AECM_PGUP:

pView->ProcessKey(VK_PRIOR,FALSE,bShift);

break;

case AECM_PGDN:

pView->ProcessKey(VK_NEXT,FALSE,bShift);

break;

case AECM_WLEFT:

pView->ProcessKey(VK_LEFT,TRUE,bShift);

break;

case AECM_WRIGHT:

pView->ProcessKey(VK_RIGHT,TRUE,bShift);

break;

case AECM_WORDHOME:

case AECM_WORDEND:

case AECM_LAST:

case AECM_NEXTPARA:

case AECM_PREVPARA:

case AECM_PARAHOME:

case AECM_PARAEND:

pView->Move(Object,bShift);

break;

pView->Move(2,bShift);

break;

case AECM_DOCHOME:

pView->ProcessKey(VK_HOME,TRUE,bShift);

break;

case AECM_DOCEND:

pView->ProcessKey(VK_END,TRUE,bShift);

break;

case AECM_PAREN:

pView->FindParen(bShift);

break;

}

}

break;

case AEC_INSERT:

GetComString(p,str);

if (str) {

Count=GetComNumber(p,1);

for (nCount=0;nCount<Count;nCount++) {

pView->InsertText(str);

}

free(str);

} else {

Result=-3;

goto End;

}

break;

case AEC_DELETE:

Count=GetComNumber(p,1);

for (nCount=0;nCount<Count;nCount++) {

pView->ProcessKey(VK_DELETE,FALSE,FALSE);

}

break;

case AEC_BS:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

Count=GetComNumber(p,1);

switch (Object) {

default:

case -1:

Result=-2;

goto End;

case 0:

for (nCount=0;nCount<Count;nCount++) {

pView->ProcessKey(VK_BACK,FALSE,FALSE);

}

break;

case 1:

for (nCount=0;nCount<Count;nCount++) {

pView->ProcessKey(VK_BACK,TRUE,FALSE);

}

break;

}

break;

case AEC_SELECT:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

switch (Object) {

default:

case -1:

Result=-2;

goto End;

case AECS_WORD:

case AECS_LINE:

case AECS_PARA:

case AECS_DOC:

pView->Select(Object);

break;

}

break;

case AEC_COPY:

SendMessage(pView->hWnd,WM_COMMAND,MAKEWPARAM(IDM_AE_COPY,0),0);

break;

case AEC_COPYAPP:

SendMessage(pView->hWnd,WM_COMMAND,MAKEWPARAM(IDM_AE_COPYAPPEND,0),0);

break;

case AEC_CUT:

SendMessage(pView->hWnd,WM_COMMAND,MAKEWPARAM(IDM_AE_CUT,0),0);

break;

case AEC_CUTAPP:

SendMessage(pView->hWnd,WM_COMMAND,MAKEWPARAM(IDM_AE_CUTAPPEND,0),0);

break;

case AEC_PASTE:

Count=GetComNumber(p,1);

for (nCount=0;nCount<Count;nCount++) {

SendMessage(pView->hWnd,WM_COMMAND,MAKEWPARAM(IDM_AE_PASTE,0),0);

}

break;

case AEC_CONVERT:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

switch (Object) {

default:

case -1:

Result=-2;

goto End;

case AECC_UPPER:

pView->ChangeCase(0);

break;

case AECC_LOWER:

pView->ChangeCase(1);

break;

case AECC_REVERSECASE:

pView->ChangeCase(2);

break;

case AECC_UPPERFIRST:

pView->ChangeCase(3);

break;

case AECC_UPPSERSENT:

pView->ChangeCase(4);

break;

case AECC_TOTAB:

pView->ConvertSpaceTab(FALSE);

break;

case AECC_TOSAPCE:

pView->ConvertSpaceTab(TRUE);

break;

case AECC_REMOVESPACE:

pView->RemoveExtraSpace();

break;

case AECC_INDENT:

pView->BlockIndent(FALSE);

break;

case AECC_UNINDENT:

pView->BlockIndent(TRUE);

break;

case AECC_COMMENT:

pView->InsertComment(FALSE);

break;

case AECC_UNCOMMENT:

pView->InsertComment(TRUE);

break;

}

break;

case AEC_COPYCHAR:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

Count=GetComNumber(p,1);

for (nCount=0;nCount<Count;nCount++) {

switch (Object) {

default:

case -1:

Result=-2;

goto End;

case 0:

pView->CopyChar(0);

break;

case 1:

pView->CopyChar(1);

break;

}

}

break;

case AEC_SCROLL:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

Count=GetComNumber(p,1);

for (nCount=0;nCount<Count;nCount++) {

switch (Object) {

default:

case -1:

Result=-2;

goto End;

case AECS_UP:

pView->Scroll(-1);

break;

case AECS_DOWN:

pView->Scroll(1);

break;

case AECS_PGUP:

pView->Scroll(0,-1);

break;

case AECS_PGDN:

pView->Scroll(0,1);

break;

case AECS_HALFUP:

pView->Scroll(0,-2);

break;

case AECS_HALFDOWN:

pView->Scroll(0,2);

break;

case AECS_LEFT:

if (pView->GetWrap()==0) {

SendMessage(pView->hWnd,WM_HSCROLL,MAKELONG(SB_LINEUP,0),0);

}

break;

case AECS_RIGHT:

if (pView->GetWrap()==0) {

SendMessage(pView->hWnd,WM_HSCROLL,MAKELONG(SB_LINEDOWN,0),0);

}

break;

case AECS_PAGELEFT:

if (pView->GetWrap()==0) {

SendMessage(pView->hWnd,WM_HSCROLL,MAKELONG(SB_PAGEUP,0),0);

}

break;

case AECS_PAGERIGHT:

if (pView->GetWrap()==0) {

SendMessage(pView->hWnd,WM_HSCROLL,MAKELONG(SB_PAGEDOWN,0),0);

}

break;

}

}

break;

case AEC_SETMARK:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

if (Object == 0) {

pView->ToggleBookmark(-1,100);

} else {

pView->ToggleBookmark(-1,Object-1);

}

break;

case AEC_GOMARK:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

switch (Object) {

case 0:

pView->GotoBookmark(10);

break;

case 1:

pView->GotoBookmark(11);

break;

default:

pView->GotoBookmark(Object-2);

}

break;

case AEC_FIND:

GetComString(p,str);

if (str) {

tFlag=AE_FIND_WRAP;

if (strstr(p,"nowrap")) {

tFlag=tFlag & ~AE_FIND_WRAP;

}

if (strstr(p,"up")) {

tFlag=tFlag | AE_FIND_UP;

}

if (strstr(p,"word")) {

tFlag=tFlag | AE_FIND_WHOLEWORD;

}

if (strstr(p,"case")) {

tFlag=tFlag | AE_FIND_MATCHCASE;

}

pView->FindText(-1,str,tFlag);

free(str);

} else {

Result=-3;

goto End;

}

break;

case AEC_REPLACE:

GetComString(p,str);

if (str==NULL) {

Result=-3;

goto End;

}

GetComString(p,str2);

if (str2==NULL) {

free(str);

Result=-3;

goto End;

}

tFlag=AE_FIND_WRAP;

if (strstr(p,"nowrap")) {

tFlag=tFlag & ~AE_FIND_WRAP;

}

if (strstr(p,"up")) {

tFlag=tFlag | AE_FIND_UP;

}

if (strstr(p,"word")) {

tFlag=tFlag | AE_FIND_WHOLEWORD;

}

if (strstr(p,"case")) {

tFlag=tFlag | AE_FIND_MATCHCASE;

}

// 0(없음), 2(교체 완료)인 경우는 다시 호출할 필요가 없음. 1(검색만)인 경우는 다시 한번 더 호출한다.

if (pView->ReplaceText(-1,str,tFlag,str2)==1) {

pView->ReplaceText(-1,str,tFlag,str2);

}

free(str);

free(str2);

break;

case AEC_FOCUS:

Object=GetComObject(Verb,p,arComObject,arObjOfVerb);

switch (Object) {

default:

case 0:

ChangeActiveView(GetActiveView(),1);

goto End;

case 1:

ChangeActiveView(GetActiveView(),1);

break;

}

break;

}

End:

free(Com);

return Result;

}

각각의 case가 고유의 명령과 목적어를 처리하는 구조이므로 길이가 길어도 소스를 읽기는 쉽다. 인수로 전달된 명령을 일차로 해석하고 필요할 경우 목적어까지 해석하여 활성 뷰에게 전달하기만 하면 된다. ApiEdit에 관련 명령을 실행할 수 있는 함수 집합들이 잘 구비되어 있으므로 DoCommand 함수는 함수를 호출하거나 메시지를 보내는 것으로 명령을 간단히 실행할 수 있다.

find 명령의 경우 현재는 단순한 이동 명령이라고 볼 수 있다. 검색 결과에 따른 에러 처리를 하면 활용성이 더 높아지지만 그렇게 하려면 명령이 결과를 리턴해야 하며 리턴값을 받을 수 있는 변수의 개념이 필요하다. 변수값을 비교하려면 비교 연산자가 필요하고 조건문이 있어야 하며 변수를 가공할 수 있는 함수의 개념, 반복문 등의 필요해 진다. 결국 간단한 매크로 수준에서는 불가능하며 다음 버전에서나 시도해 볼 것이다.

DoCommand 함수는 인수로 전달된 문자열에서 동사와 목적어를 분리해 관련 명령을 실행하고 리턴하므로 단 하나의 명령만 실행할 수 있다. 명령의 집합인 매크로를 실행하는 함수는 ExecMacro인데 매크로 실행의 주체라고 할 수 있다. 매크로에 포함되는 명령이 복잡해서 대단히 거대할 것 같지만 관련 서브 루틴이 잘 작성되어 있으므로 생각보다 길지 않다.

void CApiEdit::ExecMacro(const TCHAR *szMacro)

{

const TCHAR *pc;

int Result,ParentResult;

StartUndoGroup(21);

for (pc=szMacro;;) {

if (*pc==NULL) {

break;

}

// 명령 실행.

Result=DoCommand(pc);

// 구문상의 에러이면 매크로 종료

if (Result < -1) {

break;

}

// 동사가 없으면 일단 부모에게 먼저 물어본다.

if (Result==-1) {

ParentResult=SendMessage(GetParent(hWnd),UserBase+2,0,(LPARAM)pc);

// 부모가 처리해 주지 않으면 매크로 종료.

// 0인 경우 : 정상 실행, 또는 무시된 상황 => 계속 실행한다.

if (ParentResult < 0) {

break;

}

}

// 다음 명령 찾음

for (;;pc++) {

// 개행 코드를 찾았으면 다음 줄로

if (*pc=='\r') {

pc+=2;

break;

}

if (*pc==';') {

pc++;

break;

}

// NULL을 찾았으면 그냥 나감. 바깥 루프 선두에서 탈출함

if (*pc==NULL) {

break;

}

// 문자열 건너 뜀. 이 시점에서는 이미 실행된 명령을 건너뛰는 중이므로 닫는 따옴표가 반드시 있음

// 만약 없었다면 앞쪽 DoCommand에서 이미 에러를 리턴했고 매크로 종료되었음

SkipString(pc);

}

}

EndUndoGroup();

}

명령 집합에서 명령을 추출하여 순서대로 실행하기만 하면 된다. 매크로내의 명령들은 개행 코드나 세미콜론으로 구분되므로 구분자를 건너뛰면서 명령들을 추출하여 DoCommand를 호출한다. DoCommand 함수는 명령 실행 결과를 리턴하는데 리턴값의 의미는 주석에 잘 기록되어 있다. 만약 동사없음 이외의 구문 에러가 발생했다면 이때는 매크로 실행 전체를 종료한다.

리턴값이 -1이면 컨트롤이 직접 이해하지 못하는 동사라는 뜻인데 이때는 부모 윈도우에게 UserBase+2를 보내 처리를 의뢰한다. 함수를 부르지 못하고 메시지를 보내는 이유는 컨트롤의 독립성 확보를 위해서인데 호스트가 이 메시지를 무시하건 제대로 처리해 주건 상관없이 컨트롤을 실행되어야 한다. 함수를 호출하는 구조라면 호스트는 반드시 컨트롤의 매크로 호출을 처리하는 함수를 제공해야 하는 강제 의무를 부여받게 된다. 이 점에 대해서는 앞에서도 설명한 적이 있다.

UserBase+2가 0을 리턴한 경우는 실행에 성공했거나 또는 이 메시지를 처리하지 않고 무시하는 경우 두 가지가 있다. ApiEdit는 호스트가 무시했더라도 성공으로 간주하는데 즉, 호스트가 처리하지 않는 명령은 그냥 무시하는 것이다. ApiEdit의 매크로는 텍스트 편집에 관련된 명령으로 구성되지만 호스트의 매크로는 이보다 훨씬 더 확장된 의미를 가질 수도 있다. 예를 들어 문서 외부에서 처리해야 하는 일도 명령으로 정의할 수 있다. 호스트의 명령은 잠시 후에 작성할 것이다.

매크로를 실행할 수 있는 함수들이 완성되었는데 아직 매크로를 작성하는 UI는 만들어지지 않았다. 그래서 테스트를 위해 매크로를 실행하는 임시적인 단축키를 만들고 여기에 간단한 매크로를 작성해 보자. ProcessKey에서 VK_F4, VK_F5 등의 키에서 간단한 매크로로 ExecMacro함수를 호출해 보자.

void CApiEditText::ProcessKey(UINT vk,BOOL bControl,BOOL bShift)

{

...

switch (vk) {

case VK_F4:

pFrame->ExecMacro("movesel left;cut;move right;paste;move left");

break;

case VK_F5:

pFrame->ExecMacro("move wordhome;insert \"<\";move wordend;insert \">\";move wright");

break;

매크로의 내용은 어렵지 않게 해석된다. F4는 왼쪽으로 한칸 선택이동한 후 잘라내고 오른쪽으로 이동하여 붙이고 다시 왼쪽으로 이동함으로써 앞뒤 글자를 교체한다. 실제 키보드로 이 동작을 연속적으로 해 보면 문자 교환이라는 것을 쉽게 알 수 있다. F5는 현재 단어를 < >괄호로 감싸고 다음 단어로 이동한다.

보다시피 매크로를 사용하면 두 개 이상의 명령을 한꺼번에 실행할 수 있다. 위 매크로 구문은 비교적 간단한 편인데 좀 더 복잡하게 작성하면 얼마든지 실용적으로 응용할 수 있는 곳이 많다. 테스트가 끝났으면 이 코드는 삭제하자. 잠시 후 매크로 작성 대화상자를 만들면 얼마든지 복잡한 매크로를 직접 만들 수 있다.