꿈꾸는..

http://home.dasomnetwork.com/~leedw/pub/vim/Joinc_vim.htm

vi 편집기란?  
파일을 생성하거나 편집하는데 사용하는 프로그램을 에디터(editor)라고 합니다.
유닉스에서 사용하는 에디터 중 vi 에디터 텍스트 편집기로 가장 대표적인 프로그램은 vi 에디터 입니다. vi 편집기는 Visual Editor로서, 모든 유닉스 시스템에 있으며 따라서 vi 편집기를 사용할 수 있다는 것은 어떤 유닉스 시스템에서도 문서 작업을 할 수 있다는 것을 의미합니다.

예를 들어 전자우편을 작성하거나, 프로그램을 작성하는 일, 또는 기타문서를 작성할 때에 편집기는 필수적인 연장(tool)입니다.



- vi 에디터 구성과 방법  
vi는 입력 모드와 명령어 모드 그리고 라인 모드의 세 가지 형태로 구성되어 있습니다.입력모드는 일반적은 텍스트 에디터와 같이 원하는 문자를 입력할 수 있는 상태를 말하고, 명령어 모드는 입력한 내용을 편집하기 위해서 다양한 편집 관련 명령어를 사용 할 수 있는 상태를 의미 한다.

따라서 입력 모드에서는 문자의 입력만이 가능하며 문단의 재구성과 삽입, 삭제 등의 편집 기능은 오직 명령어 모드에서만 사용할 수 있습니다.

vi를 실행한 직후에는 명령어 모드에 위치하게 되며 i(insert)나 a(append), o(open)를 입력하게나 <Insert> 키를 이용해서 입력 모드로 전환할 수 있다.

입력 모드에서 명령어 모드로 복귀할 때는 <Esc>키만을 사용합니다.입력     모드로 전화 i 또는 a 또는 o 또는 <Inset> 명령어 모드로 전환 <Esc>vi는 입력 모드와 명령어 모드 이외에 라인 모드를 추가로 갖고 있는데, 이는 셸 명령어나 외부 프로그램들을 에디터의 내부에서 직접 실행 시킬 수 있는 모드입니다.

라인 모드는 vi의 본체인 ex가 실행되는 상테이므로 보다 원초적인 텍스트 조작이 가능해진다. 또한 라인 모드는 셸과 직접 연결되어 파이프를 구성하기 때문에 작업 중인텍스느에 대해서 다양한 작업을 연결시킬 수 있다.

다른 모드와는 달리 라인 모드는 화면의 마지막 줄에 라인 모드임을 알리는 콜론(:)과 함께 입력한 내용이 출력되어 진행 중인 내용을 확인을 할 수 있도록 되어 있다. 라인 모드는 명령어 모드에서만 전환될 수 있으며, 입력 모드에서 직접 라인 모드로 들어올 수 없다.

따라서 vi 에디터는 실행 직후에 위치한 명령어 모드에서 입력 모드 그리고 라인 모드의 세 가지 모드를 상호 전환시키면서 작업을 진행하는 방식으로 사용된다.

그림 삽입.

라인 모드에서 :을 먼저 입역한 뒤에 원하는 명령어를 입력하는 방식으로 vi 명령어 이외의 셸 명령어와 외부 명령어들을 실행시킬 수 있다.


1.시작    
vi file  vi를 시작하여 지정한 파일 편집  
vi -R file  읽기 전용(read- only) 편집기로서 vi를 시작하여 지정한 파일 편집
view file  읽기 전용(read- only) 편집기로서 vi를 시작하여 지정한 파일 편집  


2.종료    
:wq  데이터를 저장하고 종료  
:q!  데이터를 저장하지 않고 종료  


3. 디스플레이 제어하기    
^L  현재 화면을 다시 디스플레이하기  
:set number  내부 줄 번호 디스플레이  
:set nonumber  배부 줄 번호 디스플레이 않기  



4. 마지막으로 지운 것 복사하기    
p  마지막으로 지워진 것을 커서의 뒤/아래에 삽입  
P  마지막으로 지워진 것을 커서의 앞/위에 삽입  
xp  두 문자를 바꿈  
deep  두 단어를 바꿈  
ddp  두 줄을 바꿈  



5. 패턴 검색    
/rexp  지정된 정규 표현식에 대해 앞으로 이동  
/  이전의 패턴에 대해 앞으로 검색을 반복  
?rexp  지정된 정규 표현식에 대해 뒤로 이동  
?  이전의 패턴에 대해 뒤로 검색을 반복  
n  /나 ?명령에 대해 같은 방향으로 반복  
N  /나 ?명령에 대해 반대 방향으로 반복  


6. 약어의 사용    
:ab short long  short를 long에 대한 약어로 변경  
:ab  현재 약어 목록을 표시  
:una short  약어 short를 표시  


7. 줄 길이의 조정    
r<Return>  문자를 뉴라인으로 변경  
J  줄의 결합  
:set wm=n  오른쪽으로 n문자 위치에서 자동적으로 줄 나눔  

8. 커서 이동    
h<Left>  커서를 한 칸 왼쪽으로 이동  
j<Down>  커서를 한 줄 아래로 이동  
k<Up>  커서를 한 줄 위로 이동  
l<Right>  커서를 한 칸 오른쪽으로 이동  
<Backspace>  커서를 한 칸 왼쪽으로 이동  
<Space>  커서를 한 칸 오른쪽으로 이동  
-  커서를 이전 줄의 처음으로 이동  
+  커서를 다음 줄의 처음으로 이동  
<Return>  커서를 다음 줄의 처음으로 이동  
0  커서를 현재 줄의 맨 앞으로 이동  
$  커서를 현재 줄의 맨 끝으로 이동  
^  커서를 현재 줄의 첫글자(공백이나 탭이 아닌)로 이동  
w  커서를 다음 단어의 첫 글자로 이동  
e  커서를 다음 단어의 끝 글자로 이동  
b  커서를 이전 단어의 첫 글자로 이동  
W  w와 같음(문장 부호 무시)  
E  e와 같음(문장 부호 무시)  
B  b와 같음(문장 부호 무시)  
(  다음 문장의 처음으로 이동  
)  이전 문장의 처음으로 이동  
{  다음 문단의 처음으로 이동  
}  이전 문단의 처음으로 이동  
H  커서를 화면 맨 위로 이동  
M  커서를 중간으로 이동  
L  커서를 맨 아래로 이동  


9. 편집 버퍼를 통한 이동    
^F  한 화면 아래로 이동  
^B  한 화면 위로 이동  
n^F  n화면 아래로 이동  
n^B  n화면 위로 이동  
^D  반 화면 아래로 이동  
^U  반 화면 위로 이동  
n^D  n줄만큼 아래로 이동  
n^U  n줄만큼 위로 이동  


10. 셸 명령 실행    
:!command  vi를 중단하고 지정한 셸 명령을 실행  
:!!  vi를 중단하고 이전의 셸 명령을 실행  
:sh  vi를 중단하고 셸을 실행  
:!csh  vi를 중단하고 새로운 C-셸을 실행  



11. 패턴에 의한 치환    
:s/pattern/replace/  현재 줄의 치환  
:lines/pattern/replace/  지정한 줄의 치환  
:line,lines/pattern/replace/  지정한 범위의 치환  
:%s/pattern/replace/  모든 줄의 치환  


12. 데이터 읽기  
:liner file  file의 내용을 지정한 줄 다음에 삽입  
:r file  file의 내용을 현재의 줄 다음에 삽입  
:liner !command  command의 결과를 지정한 줄 다음에 삽입  
:r !command  command의 결과를 현재의 줄 다음에 삽입  
:r !look pattern  지정한 pattern으로 시작된 단어 삽입  


13. 정규 표현식을 사용하기 위한 특수 기호    
.
뉴라인을 제외한 모든 단일 문자와 대응

*
영 또는 그 이상의 선행 문자와 대응

^
줄의 시작과 대응

$
줄의 끝과 대응

\<
단어의 시작과 대응

\>
단어의 끝과 대응

[ ]
묶여진 문자중의 하나와 대응

[^ ]
묶여진 문자를 제외한 아무것하고나 대응

\
이어지는 기호를 문자 그대로 해석


14. 줄 번호    
nG  줄번호 n으로 건너뛰기  
1G  편집 버퍼의 첫 줄로 건너뛰기  
G  편집 버퍼의 마지막 줄로 건너뛰기  
:map g lG  g가 lG와 같도록 매크로 정의  

15. 삽입    
i  입력 모드로 전환, 커서 위치 앞에서 삽입  
a  입력 모드로 전환, 커서 위치 뒤에서 삽입  
I  입력 모드로 전환, 현재 줄의 앞에 삽입  
A  입력 모드로 전환, 현재 줄의 끝에 삽입  
o  입력 모드로 전환, 현재 줄의 아래에 전개  
O  입력 모드로 전환, 현재 줄의 위에 전개  

16. 편집하고 있는 파일을 바꾸기    
:e file  지정한 파일의 편집  
:e! file  지정한 파일의 편집, 자동 점검의 생략  

17. 내용 고치기    
r  단지 한 글자만 변경(입력 모드로 바뀌지 않음)  
R  입력하는 대로 겹쳐 써서 변경  
s  삽입에 의해 한 단어의 변경  
C  커서의 위치로부터 줄 끝까지 삽입에 의한 변경  
cc  전체 줄을 삽입에 의한 변경  
S  전체 줄을 삽입에 의한 변경  
cmove  커서부터 move까지 삽입에 의해 변경  
~  대,소문자 바꾸기  


18. 고치기의 취소 또는 반복    
u  편집 버퍼를 수정했던 마지막 명령을 취소  
U  현재 줄을 저장  
.  편집 버퍼를 수정했던 마지막 명령 반복  

19. 문자 삭제    
x  커서가 있는 문자 삭제  
X  커서의 왼쪽 문자 삭제  
D  커서부터 줄의 끝까지 삭제  
dd  현재 줄의 전체 삭제  
dmove  커서부터 move까지 삭제  
dG  커서부터 편집 버퍼의 끝까지 삭제  
d1G  커서부터 편집 버퍼의 맨 앞까지 삭제  
:lined  지정한 줄의 삭제  
:line, lined  지정한 범위의 삭제  

20. 여러 줄의 복사와 이동    
:linecotarget  지정한 줄을 복사하여 target 줄 밑에 삽입  
:line, linecotarget  지정한 범위를 복사하여 target 줄 밑에 삽입  
:linemtarget  지정한 줄로 이동하여 target 줄 밑에 삽입  
:line, linemtarget  지정한 범위로 이동하여target 줄 밑에 삽입  

21. 데이터를 처리하기 위한 셸 명령의 사용    
n!!command  n번 줄에서 command의 실행  
!move command  커서부터 move까지 command 실행  
!move fmt  커서부터 move까지 줄들을 형식 맞추기  

22. 데이터 저장하기  
:w  원래의 파일로 데이터를 저장  
:w file  지정한 파일로 데이터를 저장  
:w>> file  지정한 파일에 데이터를 추가  

...

리눅스를 연구하며 썼던 글

...

#include <stdio.h>

#define MEM_MAX_COUNT 5  // 동적 메모리 할당 시도 횟수
#define NO_SIZE                10
#define NAME_SIZE        20

#define FIND 0
#define NOT_FIND 1

typedef struct single
{
        char s_no[NO_SIZE];
        char s_name[NAME_SIZE];

        struct single *prev;
        struct single *next;
}SINGLE;

SINGLE *head, *tail;

void myflush(void)
{
        while(getchar()!='\n');
}

// 동적 메모리를 할당해주는 함수
int memory_alloc(SINGLE **ip, int size)
{
        register tag ;

        tag = 0 ;

        // 메모리 동적할당
        while( !(*ip = (SINGLE*)malloc(sizeof(SINGLE)*size)) ) { //free(ip)
                //메모리가 부족하다..
                puts("메모리 부족하다") ;

                if( tag ++ > MEM_MAX_COUNT/*5*/ ) {
                        return -1 ;
                // exit(-1) ;
                }
                sleep(1) ;
        }
        return 0;
}

// 숫자를 입력 받는 함수
int get_decimal(void)
{
        int id;
        char *str;
        int i;

        id=1;
        do
        {
                gets(str);

                        for(i=0; i<strlen(str); i++)
                        {
                                if( !(isdigit(str[i]))  && str[i]!='-' )
                                {
                                        printf("정수가 아니니 다시 입력하세요.\n");
                                        id = 1;
                                        break;
                                }
                                else id=0;
                        }        

                        // 만약에 입력 스트링이 정수라면 int형으로 변환
                        if(id==0)
                        {
                                return atoi(str);
                        }
        }
        while(id);
}

// 초기화 하는 함수
int init(void)
{

        head = (SINGLE *) malloc(sizeof(SINGLE));
        if (head == NULL) return -1;
        tail = (SINGLE *) malloc(sizeof(SINGLE));
        if( tail == NULL)
        {
                free(head);
                return -1;
        }


//        if ( memory_alloc( (SINGLE **)&head, 1 ) == -1 ) return -1;
//        if ( memory_alloc( (SINGLE **)&tail, 1 ) == -1 )
//        {
//                free(head);
//                return -1;
//        }

        // head, tail 링크연결
        head->prev = head;
        head->next = tail;
        tail->prev = head;
        tail->next = tail;
        return 0;
}

int menu(void)
{
        int i;

        printf("\n\n");        
        printf("=======이중 링크드 리스트=======\n");        
        printf("1.  Insert  [ i)head  ii)tail ] \n");
        printf("2.  Display [ i)head  ii)tail ] \n");
        printf("3.  Save                        \n");
        printf("4.  Open                        \n");
        printf("5.  Sort    [ i)no    ii)name ] \n");
        printf("6.  Search  [ i)no    ii)name ] \n");
        printf("7.  Exit                        \n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int insert_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Insert=============\n");
        printf("1.  head\n");
        printf("2.  tail\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int display_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Display=============\n");
        printf("1.  head\n");
        printf("2.  tail\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int sort_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Sort=============\n");
        printf("1.  no\n");
        printf("2.  name\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

int search_menu(void)
{
        int i;

        printf("\n\n");        
        printf("===============Search=============\n");
        printf("1.  no\n");
        printf("2.  name\n");
        printf("3.  중지\n");
        printf("select ?");
        scanf("%i", &i);
        myflush();
        return i;
}

// 헤드 삽입하는 함수
int head_insert(void)
{
        SINGLE *temp;
        temp = (SINGLE *) malloc(sizeof(SINGLE));
        if(temp==NULL) return -1;

//        if ( memory_alloc( (SINGLE **)&temp, 1 ) == -1 ) return -1;

        // 데이타 입력
        printf("s_no :");
        gets(temp->s_no);
        printf("s_name :");
        gets(temp->s_name);

        // 링크 연결
        temp->prev = head->next->prev;
        temp->next = head->next;
        head->next->prev = temp;
        head->next = temp;

        return 0;
}

// 테일 삽입하는 함수
int tail_insert(void)
{
        SINGLE *temp;
        temp = (SINGLE *) malloc(sizeof(SINGLE));
        if(temp==NULL) return -1;

//        if ( memory_alloc( (SINGLE **)&temp, 1 ) == -1 ) return -1;

        // 데이타 입력
        printf("s_no :");
        gets(temp->s_no);
        printf("s_name :");
        gets(temp->s_name);

        // 링크 연결
        temp->prev = tail->prev;
        temp->next = tail->prev->next;
        tail->prev->next = temp;
        tail->prev = temp;
        return 0;
}

// 헤드 출력하는 함수
void head_display(void)
{
        SINGLE *temp;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        temp = head->next;

        while(temp!=tail)
        {
                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                temp=temp->next;
        }
}

// 테일 출력하는 함수
void tail_display(void)
{
        SINGLE *temp;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        temp = tail->prev;

        while(temp!=head)
        {
                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                temp=temp->prev;
        }
}

void no_sort(void)
{
        SINGLE *temp;
        SINGLE *sort_ind;
        SINGLE *i1;
        SINGLE *i2;

        temp=head->next;
        sort_ind=tail;

        while(sort_ind!=head->next)
        {
                temp=head->next;
                while(temp->sort_ind->prev)
                {
                        if(atoi(temp->s_no) > atoi(temp->next->s_no) )
                        {
                                i1=temp; i2=temp->next;

                                i1->prev->next=i2;
                                i2->next->prev=i1;
                                i2->prev=i1->prev;
                                i1->prev=i2
                        
                        }
                        else temp=temp->next;
                }
                sort_ind=sort_ind->prev;
        }
        printf("no sort\n");
}

void name_sort(void)
{
        printf("name sort\n");



}

int find_no_element(char ch)
{
        SINGLE *temp;
        int i;
        int find;
        char no[NO_SIZE];

        temp = head->next;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        find = NOT_FIND;
        while(temp!=tail)
        {
                for(i=0; i<strlen(temp->s_no); i++)
                {
                        strcpy( no, temp->s_no);
                        if( no[i] == ch)
                        {
                                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                                find = FIND;
                                break;
                        }
                }
                temp=temp->next;
        }
        if( find == NOT_FIND ) printf("못찾았습니다.\n");
}

void no_search(void)
{
        int i;
        char ch;

        printf("no search\n");

        printf("번호를 입력하세요:");
        scanf("%c", &ch);
        myflush();
/*
        printf("번호를 입력하세요:");
        i = get_decimal();
*/
        find_no_element(ch);
}

int find_name_element(char ch)
{
        SINGLE *temp;
        int i;
        int find;
        char name[NAME_SIZE];

        temp = head->next;

        printf("===================================\n");
        printf("=       s-no              s-name  =\n");
        printf("===================================\n");

        find = NOT_FIND;
        while(temp!=tail)
        {
                for(i=0; i<strlen(temp->s_name); i++)
                {
                        strcpy( name, temp->s_name);
                        if( name[i] == ch)
                        {
                                printf(" %10s %20s \n", temp->s_no, temp->s_name);
                                find = FIND;
                                break;
                        }
                }
                temp=temp->next;
        }
        if( find == NOT_FIND ) printf("못찾았습니다.\n");
}

void name_search(void)
{
        // 단어 입력 받는 버퍼
        char ch;

        printf("name search\n");

        printf("문자를 입력하세요:");
        scanf("%c", &ch);
        myflush();

        find_name_element(ch);
}

void insert(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = insert_menu() )
                {
                        case 1:         head_insert();        break;
                        case 2:                tail_insert();        break;
                        case 3:                return;
                        default :                                break;
                }
        }
}

void display(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = display_menu() )
                {
                        case 1:         head_display();        
                                                printf("===========end of display==========\n");
                                                break;
                        case 2:                tail_display();        
                                                printf("===========end of display==========\n");
                                                break;
                        case 3:                return;
                        default :        break;
                }
        }
}

int save(void)
{
        FILE  *fp;
        SINGLE  *temp;
        char a,*file_name;

        printf("\n\n");        
        printf("=============파일저장===========\n");
        
        printf("default[SINGLE.DAT] 다른 파일명을 원하십니까?(y/n)");
        scanf("%c",&a);
        myflush();
        if( a== 'y')
        {
                printf("파일명을 입력해주십시오.");
                scanf("%s",file_name);
                fp = fopen(file_name,"w+t");
        }
        else
        {
                fp = fopen("SINGLE.DAT","w+t");
        }

        if(fp == NULL) exit(-1);

        if(feof(fp)!=0) printf("쓰기전 파일이 비어있습니다.\n");
        if(feof(fp)==0) printf("쓰기전 파일이 비어있지 않습니다.\n");

        //헤드에는 데이타가 없다.
        temp = head->next;

        if(temp == tail) printf("링크가 비어있습니다.\n");

    while(temp != tail)
        {
                // 링크 사이즈는 빼준다. 이중링크이므로 2번 빼준다.        
            fwrite(temp, sizeof(SINGLE)-sizeof(SINGLE*)-sizeof(SINGLE*), 1, fp);
                printf("파일에 링크를 삽입했습니다.\n");


            // 다음 데이타가 있는 곳
            temp= temp->next;
    }

        if(feof(fp)!=0) printf("쓰기후 파일이 비어있습니다.\n");
        if(feof(fp)==0) printf("쓰기후 파일이 비어있지 않습니다.\n");

        // 파일 저장과 닫기
        fclose(fp);
        return 0;
}

int open(void)
{
        FILE  *fp;
        SINGLE  *temp;

        SINGLE *buf;
        char *file_name;

        printf("\n\n");        
        printf("=============파일입력===========\n");

        // 이중링크가 비어있는지 검사
        if( head->next != tail )
        {
                printf("입력 전 링크가 비어있지 않습니다.\n");
                // 이중링크가 비어있지 않다면 기존에 있는 링크 모두 삭제
                while(head->next != tail)
                {
                    // 다음 데이타가 있는 곳
                        temp = head->next;  // 잊지말것 temp는 4byte pointer!!!
                    head->next = temp->next;
                        temp->next->prev = head;
                        free(temp);
            }
                printf("기존의 링크를 모두 지웠습니다.\n");
                head_display();
                printf("===========end of display==========\n");
        }
        if( head->next == tail )
        {
                printf("입력 전 링크가 비어있습니다.\n");
                printf("open할 파일이름을 입력해 주세요:");
                scanf("%s",file_name);

                fp = fopen(file_name,"rt");
                if(fp == NULL) exit(-1);
                else printf("파일 읽기 성공\n");

                while(1)
                {
                        buf = (SINGLE *) malloc(sizeof(SINGLE));
                        if (buf == NULL)
                        {
                                printf("메모리할당실패");
                                // 파일 저장과 닫기
                                fclose(fp);
                                return -1;
                        }
//                        if ( memory_alloc( (SINGLE **)&buf, 1 ) == -1 )
//                        {
//                                printf("메모리할당실패");
//                                return -1;
//                        }


                        // 파일에서 데이터를 읽어 온다.
                        fread(buf,sizeof(SINGLE)-sizeof(SINGLE*)-sizeof(SINGLE*), 1, fp);        // 1개

                        // 파일의 끝이면 종료
                        if(feof(fp)!=0) break;

                        // 링크 연결 tail에 삽입하는 방법!!!
                        buf->prev = tail->prev;
                        buf->next = tail->prev->next;
                        tail->prev->next = buf;
                        tail->prev = buf;

                        printf("링크 삽입\n");
                }
//                // buf가 함수의 리턴과 함께 더이상 쓰이지 않으므로
//                free(buf);
                // 파일 저장과 닫기
                fclose(fp);
        }
        if( head->next == tail ) printf("입력 후 링크가 비어있습니다.\n");
        if( head->next != tail ) printf("입력 후 링크가 비어있지 않습니다.\n");


}

void sort(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = sort_menu() )
                {
                        case 1:         no_sort();                break;
                        case 2:                name_sort();        break;
                        case 3:                return;
                        default :                                break;
                }
        }
}

void search(void)
{
        int i;

        while(1) // 무한 루프
        {
                switch(        i = search_menu() )
                {
                        case 1:         no_search();        break;
                        case 2:                name_search();        break;
                        case 3:                return;
                        default :                                break;
                }
        }
}

main()
{
        int i;
        
        if( init() != 0 )
        {
                printf("초기화 실패\n");
                exit(-1);
        }

        while(1) // 무한 루프
        {
                switch(        i = menu() )
                {
                        case 1:         insert();        break;
                        case 2:                display();        break;
                        case 3:         save();                break;
                        case 4:                open();                break;
                        case 5:                sort();                break;
                        case 6:                search();        break;
                        case 7:                exit(0);        break;
                        default :                                break;
                }
        }
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define HEAD_DIR        1
#define TAIL_DIR        2

char fname[255]={"SAM_DATA.dat"};

typedef struct single
{
        char s_no[10];
        char s_name[20];
        struct single *prev;
        struct single *next;
}SINGLE;

SINGLE *head, *tail, *current;

void goodbye();
int Readstdin(char *target, int size);
int ReadstdinDecimal();

int init(void);
int insert_elem(SINGLE *temp, const unsigned short direction);
int get_input(SINGLE *target);
void show_elem(SINGLE *target);
void switch_elem(SINGLE *t1, SINGLE *t2);
void freeData();
int IsBig(SINGLE *src, SINGLE *target);// if src > target then return 1 else 0

void Insert();
void Search();
void Sort();

int RecordFile();
int ReadFromFile();

void PrintAll();

// input, output, end
int main()
{
        short end=0;
        int sel;

        init();        
        while(1)
        {
        printf("\n\n");
        printf("####### LINKED LIST SAMPLE PROGRAM ######\n\n");
        printf("#  1. Insert                            #\n");
        printf("#  2. Search                            #\n");
        printf("#  3. Print(All Data)                   #\n");
        printf("#  4. Record to File                    #\n");
        printf("#  5. Read from File                    #\n");
        printf("#  6. Sort                              #\n");
        printf("#  7. Quit                              #\n");
        printf("#########################################\n");
                printf("# Select menu : ");
                //scanf("%d",&sel);
                sel=ReadstdinDecimal();
                if(sel < 1 || sel > 7) continue;
                switch(sel)
                {
                        case 1:
                                Insert();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 2:
                                Search();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 3:
                                PrintAll();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 4:
                                RecordFile();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 5:
                                ReadFromFile();
                                printf("Press any key to continue.....");
                                getchar();
                                break;
                        case 6:
                                Sort();
                                printf("Press any key continue.....");
                                getchar();
                                break;
                        case 7:
                                end=1;
                                goodbye();
                                break;
                }
                if(1==end)break;
        }
        freeData();
        return 1;
}

void goodbye()
{
        printf("###################################\n");
        printf("#           GoodBye!!             #\n");
        printf("###################################\n");
}

int init(void)
{
        if(NULL == (head=(SINGLE *)malloc(sizeof(SINGLE))) )
        {
                printf("Memory allocation error\n");
                return -1;
        }
        if(NULL == (tail=(SINGLE *)malloc(sizeof(SINGLE))) )
        {
                free(head);
                printf("Memory allocation error\n");
                return -1;
        }
        head->next=tail;
        head->prev=head;
        tail->next=tail;
        tail->prev=head;
        return 1;
}
int insert_elem(SINGLE *data, const unsigned short direction)
{
        SINGLE *temp;
        if(temp == NULL)
        {
                printf("Invalid argument (NULL indicator) \n");
                return -1;
        }
        
        if(HEAD_DIR == direction)
        {
                temp=head->next;

                data->next=head->next;
                head->next=data;
                data->prev=head;
                temp->prev=data;
        }
        else if(TAIL_DIR == direction)
        {
                /*
                data->prev=tail->prev;
                data->next=tail;
                tail->prev->next=data;
                tail->prev=data;
                */
                temp=tail->prev;

                tail->prev=data;
                data->prev=temp;
                temp->next=data;
                data->next=tail;
        }

        return 1;
}
int get_input(SINGLE *target)
{
        int ret=1;

        printf("##### DATA INSERT ####\n");
        do
        {
                printf("# s_no: ");
                Readstdin(target->s_no, sizeof(target->s_no));
        }while(0==strlen(target->s_no));
        //scanf("%s", target->s_no);
        do
        {
                printf("# s_name : ");
                Readstdin(target->s_name, sizeof(target->s_name));
        }while(0==strlen(target->s_name));
        
        //scanf("%s", target->s_name);

        return ret;
}
void show_elem(SINGLE *target)
{
        printf("# s_no : %s\n", target->s_no);
        printf("# S_name : %s\n", target->s_name);
        printf("##############################\n");
}
void switch_elem(SINGLE *t1, SINGLE *t2)
{
        t1->prev->next=t2;
        t2->next->prev=t1;
        t2->prev=t1->prev;
        t1->prev=t2;
        t1->next=t2->next;
        t2->next=t1;
}
void Insert()
{
        int sel;
        SINGLE *data;

        if(NULL == (data=(SINGLE *)malloc(sizeof(SINGLE))) )
        {
                printf("Memory allocation error\n");
                return;
        }

        if(0 > get_input(data))
        {
                printf("Data Input error\n");
                return;
        }
        do
        {
                printf("# What do you want direction of data (head: 1, tail:2)? : ");
                sel=ReadstdinDecimal();
                if(sel!=1 && sel!=2)
                        printf("select 1 or 2\n");
        }while(sel!=1 && sel!=2);
        insert_elem(data, sel);

        printf("Data is successfully inserted\n\n");
}
int RecordFile()
{
        int ret=0;
        char filename[255];
        FILE *fp;
        do
        {
                printf("What do you save from (default:%s) : ", fname);
                ret=Readstdin(filename, 255);
                //scanf("%s", filename);
                if(ret==0)printf("[%s] Is it right? (y/n)", fname);
                else printf("[%s] Is it right ? (y/n) ",filename);
        }while('y'!=getchar());
        
        if(ret!=0)
        {
                strncpy(fname, filename, strlen(filename));
                fname[strlen(filename)]='\0';
        }        
        getchar();
        
        if(NULL == (fp = fopen(fname, "w+")) )
        {
                printf("File open error\n");
                return -1;
        }

        current=head->next;
        while(current!=tail)
        {
                fwrite(current, sizeof(SINGLE), 1, fp);
                current=current->next;
        }

        fclose(fp);
        printf("File Recording is successfully completed \n");
        getchar();
        return 1;
}
int ReadFromFile()
{
        int ret, sel;
        SINGLE *data;
        FILE *fp;
        char filename[255];

        memset(filename, 0, sizeof(char)*255);

        do
        {
                printf("What do you load from (default:%s) : ", fname);
                ret=Readstdin(filename, 255);
                //scanf("%s", filename);
                if(ret==0)printf("[%s] Is it right ? (y/n)", fname);
                else printf("[%s] Is it right ? (y/n) ", filename);
        }while('y'!=getchar());

        if(ret!=0)
        {
                strncpy(fname, filename, strlen(filename));
                fname[strlen(filename)]='\0';
        }
        
        printf("Do you want erase previous data(default:n) ?(y/n) : ");
        getchar();
        if('y' == getchar())
        {
                freeData();
                init();
        }
        if(NULL == (fp =fopen(fname, "r")) )
        {
                printf("File open error\n");
                return -1;
        }
        fseek(fp, 0, SEEK_SET);
        while(1)
        {
                if(NULL == (data=(SINGLE *)malloc(sizeof(SINGLE)) ) )
                {
                        printf("Memory allocation error\n");
                        fclose(fp);
                        free(data);
                        return -1;
                }
                fread(data, sizeof(SINGLE), 1, fp);
                if(0!=feof(fp) )
                {
                        free(data);
                        break;
                }
                insert_elem(data, TAIL_DIR);
        }
        printf("Reading Data from file %s is successfully completed!!\n", fname);
        return 1;
}
void freeData()
{
        current=head->next;
        while(current!=tail)
        {
                free(current);
                current=current->next;
        }

        free(head);
        free(tail);
}

void Search()
{
        char keyword[255];
        int sel, count=0;
        printf("##################################\n");
        printf("#        DATA SERACH             #\n");
        printf("##################################\n");
        printf("\n# Select Search field (1: s_no, 2(default):s_name ) : ");

        //scanf("%d", &sel);
        sel=ReadstdinDecimal();

        if(sel!=1 && sel!=2)sel=2;
        printf("# Insert Search keyword : ");
        Readstdin(keyword, 255);
        //scanf("%s", keyword);

        current=head->next;

        printf("##### SEARCH RESULT  ##############\n\n");

        while(current!=tail)
        {
                if(sel==1)
                {
                        if(NULL!=strstr(current->s_no, keyword))
                        {
                                count++;
                                show_elem(current);
                        }
                }
                if(sel==2)
                {
                        if(NULL!=strstr(current->s_name, keyword))
                        {
                                count++;
                                show_elem(current);
                        }
                }
                current=current->next;
        }
        
        printf("\n - Search Complete!!! (%d data is found)\n", count);
}
void Sort()
{
        int sel, sel2;
        SINGLE *sort_end;
        current=head->next;
        sort_end=tail;

        printf("###### DATA SORT ######\n");
        printf("\nSort as what field ?\n ( 1 : s_no(default), 2 : s_name ) :");
        sel=ReadstdinDecimal();
        if(sel!=1 && sel!=2)sel=1;

        while(sort_end!=head->next)
        {
                current=head->next;
                while(current!=sort_end->prev)
                {
                        //printf("%s, %s", current->s_no, current->next->s_no);
                        //getchar();
                        if(sel==1)
                        {
                                if(atoi((char *)current->s_no) > atoi((char *)current->next) )switch_elem(current, current->next);
                                else current=current->next;
                        }
                        else if(sel==2)
                        {
                                if(1==IsBig(current, current->next))switch_elem(current, current->next);
                                else current=current->next;
                        }
                        //current=current->next;

                }
                sort_end=sort_end->prev;
        }

        printf("\n\n Sort Completed!! \n");
}

int Readstdin(char *target, int size)
{
        int idx=0;
        char c;

        while('\n'!=(c=getchar()) )
        {
                if(size < idx)break;
                target[idx++]=c;
        }

        target[idx]='\0';
        return idx;
}
int ReadstdinDecimal()
{
        char temp[255];

        Readstdin(temp, 255);
        
        return atoi(temp);
}

void PrintAll()
{
        int sel=1, count=0;
        current=head->next;
        printf("##############################\n");
        printf("#    Show Element            #\n");
        printf("##############################\n");
        printf("# Select show direction\n ( 1(default): from HEAD, 2: from TAIL) : ");
        sel=ReadstdinDecimal();
        //scanf("%d", &sel);

        printf("\n\n #### List of DATA #####\n\n");
        printf("##############################\n");
        if(sel !=1 && sel!=2)sel=1;
        if(sel ==1)
        {
                current=head->next;
                while(current!=tail)
                {
                        show_elem(current);
                        current=current->next;        
                        count++;
                }
        }
        else if(sel==2)
        {
                current=tail->prev;
                while(current!=head)
                {
                        show_elem(current);
                        current=current->prev;
                        count++;
                }
        }
        printf("There is %d data\n", count);
}
int IsBig(SINGLE *src, SINGLE *target)// if src > target then return 1 else 0
{
        int minLength, i;

        int srclen, targetlen;

        srclen=strlen(src->s_name);
        targetlen=strlen(target->s_name);
        
        minLength=(srclen < targetlen) ? srclen : targetlen ;

        for(i=0; i < minLength ; i++)
        {
                if(src->s_name[i]==target->s_name[i])
                {
                        if(i==minLength-1 && targetlen < srclen)return 1;
                        continue;
                }
                else if(src->s_name[i] > target->s_name[i])return 1;
                else if(src->s_name[i] < target->s_name[i])return 0;
        }
        return 0;
}


구자경_김광철

제  목 : Double linked list를 이용한 데이타 관리
파일명 : project.c
작성자 : 구자경, 김광철
작성일 : 2005. 3. 17


실행 방법
        1. gcc project.c -o project.o
        2. ./project.o
        

전제사항
        1. 입력되는 데이터의 이름 데이타는 영문으로 한정된다.
        2. 정렬은 오름차순을 기준으로 한다.        


특징
        1. 입력시 잘못된 입력은 루프를 통해 재입력을 받도록 한다.
                저장용량보다 큰 용량의 입력의 경우 길이만큼만 읽어들인다.
        2. 입력 받는 함수를 재작성하여 입력 버퍼 잔존 문제 해결
        3. 최대한 모듈화를 실행하여 코드 공유성및 가독성을 높혔다.
        4. 모듈화를 통해 차후 업데이트 확장 및 수정이 용이하다.

#ifndef _DIC_H
#define _DIC_H

#define MAXLEN 512
#define UINT unsigned int
#define USHORT unsigned short

#define MAXWORDLEN        64

typedef struct dic_db
{
        char word[MAXWORDLEN];
        char meaning[MAXLEN];
        struct dic_db *next;
} DIC_DATA;

// 데이타 관리 스트럭쳐
typedef struct meta_info
{
        int eng_nData; // 데이타 갯수
        int kor_nData;
        DIC_DATA *eng_head;// 영문 단어에 대한 사전
        DIC_DATA *kor_head;// 한글 단어에 대한 사전

        DIC_DATA *e_Current;
        DIC_DATA *k_Current;
}MASTER_INFO;

MASTER_INFO master_info;



#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

#include "dic.h"
void print_prefix();
void print_postfix();
void prompt_command(UINT type);
void start_dic();
void insert_dic();
void search_dic();
void update_dic();
void get_input();
USHORT get_func();
UINT read_data(DIC_DATA *target);
UINT insert_data(int langType);// 1: eng, 2. kor
UINT search_data(int langType);

char temp[MAXLEN];

void init()
{
        master_info.eng_nData=0;
        master_info.kor_nData=0;
        master_info.eng_head=NULL;
        master_info.kor_head=NULL;
        master_info.e_Current=NULL;
        master_info.k_Current=NULL;
}

int main()
{
        int end=0;
        int func_sel=-1;

        init();

        print_prefix();
        while(1)
        {
                prompt_command(1);
                func_sel=get_func();
                switch(func_sel)
                {
                        case 1:
                                search_dic();
                                break;
                        case 2:
                                insert_dic();
                                break;
                        case 3:
                                end=1;
                                break;
                }
                if(end==1)break;
        }

        print_postfix();
}

UINT read_data(DIC_DATA *target)
{
        printf("# Data insert\n");
        printf(" Word : ");
        fflush(stdout);
        read(0, temp, MAXWORDLEN);
        strncpy(target->word, temp, strlen(temp));
        printf(" Meaning : ");
        fflush(stdout);
        read(0, temp, MAXLEN);
        strncpy(target->meaning, temp, strlen(temp));
        return 1;
}

UINT insert_data(int langType)// 1: eng, 2. kor
{
        DIC_DATA *data;
        data = (DIC_DATA *)malloc(sizeof(DIC_DATA));

        if(data==NULL)
        {
                printf("Memory Allocation Failure!\n");
                exit(0);
        }

        memset(data, 0, sizeof(DIC_DATA));

        if(1!=read_data(data))printf("Data insert Failure!\n");

        if(langType==1)
        {
                if(master_info.eng_head==NULL)
                {
                        master_info.eng_head=data;
                        data->next=NULL;
                        master_info.e_Current=data;
                }
                else
                {
                        data->next=master_info.eng_head;
                        master_info.eng_head=data;
                }
                master_info.eng_nData++;
                printf("New data is inserted\n");
                return 1;
        }
        if(langType==2)
        {
                if(master_info.kor_head==NULL)
                {
                        master_info.kor_head=data;
                        data->next=NULL;
                        master_info.k_Current=data;
                }
                else
                {
                        data->next=master_info.kor_head;
                        master_info.kor_head=data;
                }
                master_info.kor_nData++;
                printf("New data is inserted\n");
                return 1;
        }
        return 0;
}

UINT search_data(int langType)
{
        char select;
        int count, check, matchcount=0;

        if(langType==1)
        {
                master_info.e_Current=master_info.eng_head;
                while(master_info.e_Current!=NULL)
                {
                        check=strncmp(temp, master_info.e_Current->word, strlen(master_info.e_Current->word));
                        if(check==0)
                        {
                                printf(" meaning : %s\n", master_info.e_Current->meaning);
                                matchcount++;
                        }
                        master_info.e_Current=master_info.e_Current->next;
                }
                printf(" %i개의 의미가 검색되었습니다.\n", matchcount);
                if(matchcount > 0 )return 1;
        }
        if(langType==2)
        {
                master_info.k_Current=master_info.kor_head;
                while(master_info.k_Current!=NULL)
                {
                        check=strncmp(temp, master_info.k_Current->word, strlen(master_info.k_Current->word));
                        if(check==0)
                        {
                                printf(" meaning : %s\n", master_info.k_Current->meaning);
                                matchcount++;
                        }
                        master_info.k_Current=master_info.k_Current->next;
                }
                printf(" %i개의 의미가 검색되었습니다.\n", matchcount);
                if(matchcount > 0)return 1;
        }

        if(matchcount == 0)
        {
                printf("사전에 없는 단어입니다. 등록하시겠습니까 ? (y/n)");
                getchar();
                select=getchar();
                if(select == 'y' || select == 'Y')
                {
                        insert_data(langType);
                }
        }

}





void start_dic()
{
        USHORT end=0;
        USHORT func_sel=-1;

        while(1)
        {
                prompt_command(1);
                func_sel=get_func();
                switch(func_sel)
                {
                        case 1:
                                search_dic();
                                break;
                        case 2:
                                break;
                        case 3:
                                end=1;
                                break;
                }
                if(end)break;
        }
}

void search_dic()
{
        int i=0, noeng=0, lang_flag=0;
        get_input();
        
        for(i=0 ; i<strlen(temp) ; i++)
        {
                if( (temp[i] >= 'a' && temp[i] <= 'z') || (temp[i] >= 'A' && temp[i] <= 'Z') )continue;
                else noeng++;
        }
        if(noeng > 0)lang_flag=2;// 한글 단어의 의미분석
        else if(noeng == 0) lang_flag=1;// 영문 단어의 의미 분석
        printf("lang = %i\n", lang_flag);
        search_data(lang_flag);
}

void insert_dic()
{
        int i, noeng=0, lang_flag, langType;
        DIC_DATA *data;
        printf("# New data Insert \n");
        printf("# word : ");
        fflush(stdout);
        read(0, temp, MAXLEN);
        for(i=0 ; i<strlen(temp) ; i++)
        {
                if( (temp[i] >= 'a' && temp[i] <= 'z') || (temp[i] >= 'A' && temp[i] <= 'Z') )continue;
                else noeng++;
        }
        if(noeng > 0)langType=2;// 한글 단어의 의미분석
        else langType=1;// 영문 단어의 의미 분석

        printf("lang = %i\n", langType);

        data=(DIC_DATA *)malloc(sizeof(DIC_DATA));

        strncpy(data->word, temp, strlen(temp));
        printf("# meaning :");
        fflush(stdout);
        read(0, temp, MAXLEN);
        strncpy(data->meaning, temp, strlen(temp));
        
        if(langType==1)
        {
                if(master_info.eng_head==NULL)
                {
                        master_info.eng_head=data;
                        data->next=NULL;
                        master_info.e_Current=data;
                }
                else
                {
                        data->next=master_info.eng_head;
                        master_info.eng_head=data;
                        master_info.e_Current=data;
                }
                master_info.eng_nData++;
                printf("New data is inserted\n");
        }
        if(langType==2)
        {
                if(master_info.kor_head==NULL)
                {
                        master_info.kor_head=data;
                        data->next=NULL;
                        master_info.k_Current=data;
                }
                else
                {
                        data->next=master_info.kor_head;
                        master_info.kor_head=data;
                }
                master_info.kor_nData++;
                printf("New data is inserted\n");
        }
}

void get_input()
{
        int chk, i=0, noeng=0;
        
        prompt_command(2);
        fflush(stdout);
        chk=read(0, temp, MAXLEN);
}

USHORT get_func()
{
        int chk;

        scanf("%i", &chk);

        if(chk < 0 || chk > 3 )return 0;
        return chk;
}

void prompt_command(UINT type)
{
        switch(type)
        {
                case 1: //menu
                        printf("[ Select Menu ]: ");
                        break;
                case 2: // search
                        printf("[ Search Word ]: ");
                        break;
                case 3:
                        break;
        }
}

void print_prefix()
{
        printf("________________________________________\n\n");
        printf("+  [ my Dictionary ] :::::::::::::::::::\n");
        printf("+  Author : eph      :::::::::::::::::::\n");
        printf("+  Last Modified : 2005. 03. 14 ::::::::\n");
        printf("+  :::::::::::::::::::::::::::::::::::::\n\n");
        printf("+  1. Search  2. Update 3. Exit\n");
        printf("________________________________________\n");

        return;
}
void print_postfix()
{
        printf("________________________________________\n\n");
        printf("+  :::::::  Good Bye  ::::::::::::::::::\n\n");
        printf("________________________________________\n");
}

[팁!]

  다음으로 진행 하기에 앞서 커널 컴파일을 할 때 이에 대한 프로세서를 가장 우선순위에 두고 싶
  다면 make 명령 앞에 nice -20 또는 nice --20 을 적어 줍니다.

  예를 들어 아래와 같이 할 수 있습니다.

  nice -20 make mrproper menuconfig dep clean bzImage
  nice -20 make modules modules_install

  nice명령어는 어떤 프로그램을 컴파일을 하던지 ./configure 나 make명령 앞에 붙여 주면 됩니다.


  그리고,  2개 이상의 cpu 를 가지고 있을 경우 컴파일을 각 cpu 에 동시에 할당 해 주면, 컴파일
  을 병렬로 처리 하기 때문에 속도가 빨라 집니다.  그렇게 하기 위해서는 '-j (숫자)' 옵션을 사
  용 합니다.  -j 옵션 다음의 숫자를 지정할 공식은 다음과 같습니다.

          -j (숫자) =  ( 램 용량 / 8 ) + 1

  예로, 램이 128 메가인 경우에는 -j 17 이 됩니다. SMP 시스템에서 더 많은 이득을 볼 수 있지만,
  단일 프로세서 시스템에서도 -j 는 적절한 성능을 보여 줍니다.

  실제 사용 예는 아래와 같습니다.

  make -j5 mrproper menuconfig ....
  make -j5 modules modules_install ....

커널 컴파일시 make menuconfig를 통해서
커널 컴파일 옵션을 설정한다.
만약 커널 내부 변동이 없을경우
(단순히 커널 버젼만 올리는 경우)

/boot/config 파일을
(상황에 따라 버젼정보와 같은 접미어가 붙을 수 있다.)

커널 소스 디렉토리의 .config로 복사한다.

.config 파일은 make config, make menuconfig, make xconfig등을 통해서 설정내용이 저장되는 파일이다.